精华内容
下载资源
问答
  • Java关于继承的经典案例 点赞!点赞!点赞! 题干:结合继承的思想,分析下列需求并实现 1.定义项目经理类Manager 【属性:姓名 工号 工资 奖金】【行为:工作work】 2.定义程序员类Coder【属性:姓名 工号 工资】...

    Java关于继承的经典案例

    点赞!点赞!点赞!

    题干:结合继承的思想,分析下列需求并实现
    1.定义项目经理类Manager 【属性:姓名 工号 工资 奖金】【行为:工作work】
    2.定义程序员类Coder【属性:姓名 工号 工资】【行为:工作work】
    3.要求:通过有参构造创建两个类的对象,并调用各自的work方法

    首先:创建关于Manger和Coder的抽象类 Employee(共性提取)

    public abstract class Employee {
    	
    	
    	private String name;
    	private String id;
    	private double  money;
    	
    	
    	public Employee(String name, String id,double  money) {
    		this.name = name;
    		this.id = id;
    		this.money = money;
    	}
    	
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public double getMoney() {
    		return money;
    	}
    	public void setMoney(double money) {
    		this.money = money;
    	}
    	
    	public abstract void work();
    	
    	
    }
    

    然后创建类Coder,并提供构造方法

    public class Coder extends Employee{
    	
    	public Coder(String name, String id, double money) {
    		super(name,id,money);
    	}
    
    	//姓名为:张三,工号为:9527,工资为:10000.0,的程序员正在编写代码
    	@Override
    	public void work() {
    		// TODO Auto-generated method stub
    		System.out.println("姓名为:" + super.getName()+ ",工号为:" + super.getId() +",工资为:"+ super.getMoney() +",的程序员正在编写代码");
    		
    	}
    }
    
    

    然后创建Manger类,添加独有的成员变量,并提供构造方法

    public class Manger extends Employee{
    	
    	private double jangJiN;
    	
    	public Manger(String name, String id, double money, double jangJin) {
    		super(name, id, money);
    		this.jangJiN = jangJin;
    	}
    	
    	
    	public double getJangJiN() {
    		return jangJiN;
    	}
    
    
    	public void setJangJiN(double jangJiN) {
    		this.jangJiN = jangJiN;
    	}
    
    
    	//姓名为:李四,工号为:9528,工资为:15000.0,奖金为:2000.0,的项目经理正在管理程序员写代码
    	@Override
    	public void work() {
    		// TODO Auto-generated method stub
    		System.out.println("姓名为:" + super.getName()+ ",工号为:" + super.getId() +",工资为:"+ super.getMoney()+"奖金为:"+this.getJangJiN() +"的项目经理正在管理程序员写代码");
    	}
    
    }
    

    编写测试类Test

    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//姓名为:李四,工号为:9528,工资为:15000.0,奖金为:2000.0,的项目经理正在管理程序员写代码
    		Manger manger = new Manger("李四", "9528", 15000.0, 2000.0);
    		manger.work();
    		
    //		//姓名为:张三,工号为:9527,工资为:10000.0,的程序员正在编写代码
    		Coder coder = new Coder("张三", "9527", 1000.0);
    		coder.work();
    	}
    }
    

    随手来个赞,谢谢!
    关注感谢你一辈子!

    展开全文
  • 关于接口两个案例

    2018-12-26 22:21:54
    猫狗案例,加入跳高额外功能 分析:从具体到抽象 猫: 姓名,年龄 吃饭,睡觉 狗: 姓名,年龄 吃饭,睡觉 由于有共性功能,所以,我们抽取出一个父类: 动物: 姓名,年龄 吃饭();...
    /*
    	猫狗案例,加入跳高的额外功能
    	
    	分析:从具体到抽象
    		猫:
    			姓名,年龄
    			吃饭,睡觉
    		狗:
    			姓名,年龄
    			吃饭,睡觉
    			
    		由于有共性功能,所以,我们抽取出一个父类:
    		动物:
    			姓名,年龄
    			吃饭();
    			睡觉(){}
    			
    		猫:继承自动物
    		狗:继承自动物
    		
    		跳高的额外功能是一个新的扩展功能,所以我们要定义一个接口
    		接口:
    			跳高
    			
    		部分猫:实现跳高
    		部分狗:实现跳高
    	实现;
    		从抽象到具体
    		
    	使用:
    		使用具体类
    */
    //定义跳高接口
    interface Jumpping {
    	//跳高功能
    	public abstract void jump();
    }
    
    //定义抽象类
    abstract class Animal {
    	//姓名
    	private String name;
    	//年龄
    	private int age;
    	
    	public Animal() {}
    	
    	public Animal(String name,int age) {
    		this.name = name;
    		this.age = age;
    	}
    	
    	public String getName() {
    		return name;
    	}
    	
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	public int getAge() {
    		return age;
    	}
    	
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	//吃饭();
    	public abstract void eat();
    	
    	//睡觉(){}
    	public void sleep() {
    		System.out.println("睡觉觉了");
    	}
    }
    
    //具体猫类
    class Cat extends Animal {
    	public Cat(){}
    	
    	public Cat(String name,int age) {
    		super(name,age);
    	}
    	
    	public void eat() {
    		System.out.println("猫吃鱼");
    	}
    }
    
    //具体狗类
    class Dog extends Animal {
    	public Dog(){}
    	
    	public Dog(String name,int age) {
    		super(name,age);
    	}
    	
    	public void eat() {
    		System.out.println("狗吃肉");
    	}
    }
    
    //有跳高功能的猫
    class JumpCat extends Cat implements Jumpping {
    	public JumpCat() {}
    	
    	public JumpCat(String name,int age) {
    		super(name,age);
    	}
    
    	public void jump() {
    		System.out.println("跳高猫");
    	}
    }
    
    //有跳高功能的狗
    class JumpDog extends Dog implements Jumpping {
    	public JumpDog() {}
    	
    	public JumpDog(String name,int age) {
    		super(name,age);
    	}
    
    	public void jump() {
    		System.out.println("跳高狗");
    	}
    }
    
    class InterfaceTest {
    	public static void main(String[] args) {
    		//定义跳高猫并测试
    		JumpCat jc = new JumpCat();
    		jc.setName("哆啦A梦");
    		jc.setAge(3);
    		System.out.println(jc.getName()+"---"+jc.getAge());
    		jc.eat();
    		jc.sleep();
    		jc.jump();
    		System.out.println("-----------------");
    		
    		JumpCat jc2 = new JumpCat("加菲猫",2);
    		System.out.println(jc2.getName()+"---"+jc2.getAge());
    		jc2.eat();
    		jc2.sleep();
    		jc2.jump();
    		
    		
    	}
    }
    
    /*
    	老师和学生案例,加入抽烟的额外功能
    	
    	分析:从具体到抽象
    		老师:姓名,年龄,吃饭,睡觉
    		学生:姓名,年龄,吃饭,睡觉
    		
    		由于有共性功能,我们提取出一个父类,人类。
    		
    		人类:
    			姓名,年龄
    			吃饭();
    			睡觉(){}
    			
    		抽烟的额外功能不是人或者老师,或者学生一开始就应该具备的,所以,我们把它定义为接口
    		
    		抽烟接口。
    
    		部分老师抽烟:实现抽烟接口
    		部分学生抽烟:实现抽烟接口
    		
    	实现:从抽象到具体
    		
    	使用:具体
    */
    //定义抽烟接口
    interface Smoking {
    	//抽烟的抽象方法
    	public abstract void smoke();
    }
    
    //定义抽象人类
    abstract class Person {
    	//姓名
    	private String name;
    	//年龄
    	private int age;
    	
    	public Person() {}
    	
    	public Person(String name,int age) {
    		this.name = name;
    		this.age = age;
    	}
    	
    	public String getName() {
    		return name;
    	}
    	
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	public int getAge() {
    		return age;
    	}
    	
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	//吃饭();
    	public abstract void eat();
    	
    	//睡觉(){}
    	public void sleep() {
    		System.out.println("睡觉觉了");
    	}
    }
    
    //具体老师类
    class Teacher extends Person {
    	public Teacher() {}
    	
    	public Teacher(String name,int age) {
    		super(name,age);
    	}
    	
    	public void eat() {
    		System.out.println("吃大白菜");
    	}
    }
    
    //具体学生类
    class Student extends Person {
    	public Student() {}
    	
    	public Student(String name,int age) {
    		super(name,age);
    	}
    	
    	public void eat() {
    		System.out.println("吃红烧肉");
    	}
    }
    
    //抽烟的老师
    class SmokingTeacher extends Teacher implements Smoking {
    	public SmokingTeacher() {}
    	
    	public SmokingTeacher(String name,int age) {
    		super(name,age);
    	}
    
    	public void smoke() {
    		System.out.println("抽烟的老师");
    	}
    }
    
    //抽烟的学生
    class SmokingStudent extends Student implements Smoking {
    	public SmokingStudent() {}
    	
    	public SmokingStudent(String name,int age) {
    		super(name,age);
    	}
    
    	public void smoke() {
    		System.out.println("抽烟的学生");
    	}
    }
    
    class InterfaceTest2 {
    	public static void main(String[] args) {
    		//测试学生
    		SmokingStudent ss = new SmokingStudent();
    		ss.setName("林青霞");
    		ss.setAge(27);
    		System.out.println(ss.getName()+"---"+ss.getAge());
    		ss.eat();
    		ss.sleep();
    		ss.smoke();
    		System.out.println("-------------------");
    		
    		SmokingStudent ss2 = new SmokingStudent("刘意",30);
    		System.out.println(ss2.getName()+"---"+ss2.getAge());
    		ss2.eat();
    		ss2.sleep();
    		ss2.smoke();
    		
    		//测试老师留给自己练习
    	}
    }
    
    展开全文
  • 发红包项目,针对继承的案例 群主发普通红包: 1.群主的一笔金额,从群主余额中扣除,平均分成n等份,让成员领取。 2.成员领取红包后,保存到成员余额中。 请根据描述,完成案例中所有类的定义以及指定类之间的继承...

    例题描述

    发红包项目,针对继承的案例
    群主发普通红包:
    1.群主的一笔金额,从群主余额中扣除,平均分成n等份,让成员领取。
    2.成员领取红包后,保存到成员余额中。
    请根据描述,完成案例中所有类的定义以及指定类之间的继承关系,完成发红包的操作。

    例题分析

    由题意可知,
    关于类,有两个类,一个是群主类,一个是成员类。他们如果想要完成发红包这个动作,可以有两个重复的成员变量,姓名与余额。这时我们可以给她两写一个父类,进而用它们各自继承成员变量即可,优化了程序。
    关于方法,对于他们自身来说,群主需要一个发红包的方法,成员需要一个接受红包的方法。
    在这里插入图片描述

    例题实践

    一共四个类,父类User,子类Manager与Person,以及Main方法所在的类。其中包含了继承,匿名对象,JavaBean,ArrayList类的使用。大家有复习继承相关知识的话,可以拿它练练每一步的解析都有写哦,哈哈。

    package demo03;
    发红包项目,针对继承的案例
    群主发普通红包:
    1.群主的一笔金额,从群主余额中扣除,平均分成n等份,让成员领取。
    2.成员领取红包后,保存到成员余额中。
    请根据描述,完成案例中所有类的定义以及指定类之间的继承关系,完成发红包的操作。
    * */
    public class User {
        private String name;
        private int money;
        //无参构造
        public User() {
        }
        //有参构造
        public User(String name, int money) {
            this.name = name;
            this.money = money;
        }
        public void show(){
            System.out.println("你的姓名是:" + this.name + "你的余额为:" + this.money);
        }
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getMoney() {
            return money;
        }
    
        public void setMoney(int money) {
            this.money = money;
        }
    }
    
    package demo03;
    
    import java.util.ArrayList;
    
    public class Manager extends User{
        public Manager(){
        }
        public Manager(String name,int money){
            super(name,money);
        }
        //参数1:你总共要发多少钱 ,参数2:你要发多少个包
        public ArrayList<Integer> send(int totalMoney,int count){
            //首先需要一个集合,用来存储若干红包里的金钱
            ArrayList<Integer> redList = new ArrayList<>();
            //首先看一下群主自己有多少钱
            int leftMoney = super.getMoney();
            if(totalMoney > leftMoney){
                System.out.println("余额不足!");
                return redList;
            }
            //扣钱,并重新计算余额
             super.setMoney(leftMoney - totalMoney);
            //发红包需要平均拆分成count份
            int avg = totalMoney / count;
            int mod = totalMoney % count;//红包全部取整,但是分的红包数量每份不一定完全分平均,会有余数
            //把除不开的余数放在最后一个红包当中
            //然后把红包载入集合
            for (int i = 0; i < count - 1 ; i++) {//把平均分好的钱装在集合里
                redList.add(avg);
            }
            redList.add(avg + mod);//最后一个红包
            return redList;
        }
    }
    
    package demo03;
    
    import java.util.ArrayList;
    import java.util.Random;
    
    public class Person extends User{
        Person(){
        }
        public Person(String name, int money) {
            super(name, money);
        }
        //收红包的方法
        public void receive(ArrayList<Integer> list){
            //从若干红包中抽取一个给我
            //从集合中随机获取一个索引,抽出索引位置的红包
            int index = new Random().nextInt(list.size());
            //根据索引,从集合中删除红包,得到被删除的红包
            int get = list.remove(index);
            //得到红包后,加入到个人总余额里
            int pMoney = super.getMoney();
            super.setMoney(pMoney + get);
            //红包到账
        }
    }
    
    package demo03;
    
    import java.util.ArrayList;
    
    public class Main {
        public static void main(String[] args) {
            Manager man = new Manager("群主",200);
    
            Person per1 = new Person("小王",0);
            Person per2 = new Person("小红",0);
            Person per3 = new Person("小李",0);
            Person per4 = new Person("小金",0);
            //展示基本信息
            man.show();
            per1.show();
            per2.show();
            per3.show();
            per4.show();
            //群主大气,群主要发红包啦!
            ArrayList<Integer> red = man.send(110,4);
            per1.receive(red);
            per2.receive(red);
            per3.receive(red);
            per4.receive(red);
            //大家现在的信息是
            man.show();
            per1.show();
            per2.show();
            per3.show();
            per4.show();
        }
    }
    
    展开全文
  • 继承自抽象类题目

    2017-07-26 15:33:08
    写这个案例的时候,看到了有一些提问:关于继承时,子类调用父类无参构造器时,是否会产生父类对象问题。答案是不会,举个简单例子,如果父类是抽象类时,肯定不会产生对象了,调用父类无参构造器,只是完成了...


    写这个案例的时候,看到了有一些提问:关于继承时,子类调用父类无参构造器时,是否会产生父类对象的问题。答案是不会,举个简单的例子,如果父类是抽象类时,肯定不会产生对象了,调用父类无参的构造器,只是完成了父类的初始化操作。

    下面这个案例整合了继承,静态成员,构造器的执行顺序以及就近原则问题的分析,看到很多面试题经常会出此类的题目,具体看例子。


    父类:

    public abstract class Fu {
        static int count=3;
        int a=3;
        
        static{
        	System.out.println("父类的静态代码块");
        }
        
        public Fu() {
    		a=5;
    		System.out.println("执行父类的构造方法");		
    	}
    	
        public void display(){
        	System.out.println("父类的diaplay()方法");
        	System.out.println(a);
        	show();
        }
        
    	public void show(){
    		System.out.println("父类的show方法");
    	}
          
    }
    

    子类:

    public class Zi extends Fu {	
    	 static int count=10;
         int a=6;
         
         static{
        	 System.out.println("子类的静态代码块");
         }
         
         public Zi() {
    		System.out.println("执行子类的构造方法");		
    	}
    
    	public void show(){
        	 System.out.println("子类的show方法");
        	 System.out.println(a);
         }
    }

    测试类:

    public class Test {
    	static{
    		System.out.println("测试类的静态代码块!");
    	}
    	
    	public static void main(String[] args) {
    		Zi zi = new Zi();
    		zi.display();
    	}
             
    }
    

    执行main(),会得到怎样的结果呢?看控制台的输出结果:

    测试类的静态代码块!        1
    父类的静态代码块                2
    子类的静态代码块                3
    执行父类的构造方法            4
    执行子类的构造方法            5
    父类的diaplay()方法            6
    5                                              7
    子类的show方法                   8
    6                                              9

    下面是关于执行步骤的分析:

    1.jvm加载含有main()的类,打印结果1
    2.执行main(),创建子类对象,会在创建子类对象之前调用父类无参的构造方法,所以初始化父类,打印结果2
    3.初始化完父类,初始化子类,打印结果3
    4.执行父类的构造方法,完成父类的初始化,但不会创建父类对象(抽象类,即使不是抽象类,也不会创建父类对象,只有new,才会创建对象)。打印结果4
    5.执行子类的构造方法,准备创建子类对象,打印结果5
    6,调用子类的display()方法,子类没有重写,所以调用父类的diaplay()方法,打印结果6
    7.然后输出父类的成员,就近原则(看图)打印结果7
    8.在display()中调用show()方法,子类覆盖了其show(),子类的空间也有,调用的是子类的show()方法。打印结果8
    9.最后就近,打印子类的成员,打印结果9


    为此我还为继承的关系画了个内存图


    关于内存图的需要解释的地方:子类继承父类时,创建子类对象以后,会在堆内存中给子类对象分配一块内存空间,这个子类中空间中还存有一个父类的空间装着父类的一些成员。可以总结为,一块地址,两片空间。

    展开全文
  • 一、关于信息系统设计与开发  信息系统开发流程先对需求分析系统... 继承:定义一个类做为父类,将一些共有属性和方法定义在这个类中,当某一个类需要使用到这些方法和属性时候,就可以直接通过extends关键字...
  • 首先我们从一个关于鸭子的案例来讨论面向对象之继承、接口和抽象类的关系 案例一: 这个是一个关于鸭子的游戏,实现各种形状和类别的鸭子都能够游泳和叫 案例分析: 依据对象的特性,开发人员Jim通过建立一个鸭子...
  • 在旧村改造拆迁补偿方案中,我们经常都会看到每个方案都会有提到关于本村改造中拆迁补偿安置对象。如果村民不清楚补偿安置对象规定,因继承、婚姻等家庭成员关系等问题,就会产生纠纷或不满。旧村改造是关乎...
  •  今天来谈谈final关键字作用, 虽然有很多博文关于final进行了很深研究,但还是要去记录下谈谈自己见解加深下印象。下面直接进入主题: 二 final关键字作用  1、被final修饰类不能被继承。  这一点...
  • 关于内存布局主要是考某个类所占内存大小,通过以下几个案例加以分析继承:如果是虚继承,那么就会为这个类创建一个虚表指针,占用4个字节 #include<iostream> class A{ public: int a; };//...
  • Java多线程总结

    2019-02-16 03:04:07
    文章目录线程实现方式继承Thread类实现Runnable接口两种启动方式比较ThreadJDK源码分析源码中Thread.java代码中相关描述源码中关于start方法相关描述Thread构造方法变量在线程中使用成员变量局部变量...
  • Java代码实例

    2016-06-21 22:44:51
    15.4.1 基于继承的匿名内部类 334 15.4.2 基于接口实现的匿名内部类 335 15.4.3 匿名内部类的初始化 337 15.4.4 匿名内部类作用的体现 337 15.5 理解内部类 339 15.6 内部接口 340 15.6.1 定义在类中的...
  • Java SE 6.0编程指南 源码

    热门讨论 2012-05-18 13:40:45
    15.4.1 基于继承的匿名内部类 334 15.4.2 基于接口实现的匿名内部类 335 15.4.3 匿名内部类的初始化 337 15.4.4 匿名内部类作用的体现 337 15.5 理解内部类 339 15.6 内部接口 340 15.6.1 定义在类中的...
  • 箭头函数准确来讲是没有this绑定,在使用时它this是继承下来关于箭头函数this指向我们首先不要走进误区就是作用域链,既然他自身都没有this那怎么会根据作用域链来找this指向呢? 案例分析 箭头函数中...
  • UML2.0学习指南

    热门讨论 2008-12-07 12:39:03
    本书使用最常见的技术和方法,通过一个贯穿全书的案例分析,对面向对象的软件开发过程和使用面向对象技术的编程过程进行了透彻的讨论。首先阐述了面向对象软件项目的基本概念,然后基于广泛使用的方法,介绍了使用...
  • 1.5.2 systemstate转储案例分析一则 72 第2章 从OEM到Grid Control 79 2.1 OracleOEM工具 79 2.1.1 传统OEM工具 80 2.1.2 安装Database Control选件 82 2.1.3 手工配置DBControl 83 2.1.4 启停...
  • 常见25个典型模块和4个完整项目案例,详细介绍java语言特性、线程开发、图形用户开发(gui)、文件i/o操作 、applet程序、网络编程等知识。 《java典型模块与项目实战大全》附带1张dvd光盘,内容为与本书配套...
  • 《java典型模块与项目实战大全》以实战开发为原则,以java热门开发技术与项目案例开发为主线,通过java开发中最常见25个典型模块和4个完整项目案例,详细介绍java语言特性、线程开发、图形用户开发(gui)、...
  • 《java典型模块与项目实战大全》以实战开发为原则,以java热门开发技术与项目案例开发为主线,通过java开发中最常见25个典型模块和4个完整项目案例,详细介绍java语言特性、线程开发、图形用户开发(gui)、...
  • Java典型模块

    2012-02-25 18:27:40
    9.7.1 分析对话框和文件对话框用户界面 9.7.2 对话框用户界面 9.7.3 Dialog和FileDialog组件基本知识 9.8 小结 第10章 计算器(布局管理器) 10.1 计算器原理 10.1.1 项目结构框架分析 10.1.2 项目功能业务...
  • asp.net知识库

    2015-06-18 08:45:45
    关于能自定义格式、支持多语言、支持多数据库代码生成器想法 发布Oracle存储过程包c#代码生成工具(CodeRobot) New Folder XCodeFactory3.0完全攻略--序 XCodeFactory3.0完全攻略--基本思想 XCodeFactory...
  • 4.1.2 继承的实现 205 4.1.3 继承的限制 207 4.2 覆写 211 4.2.1 方法的覆写 211 4.2.2 属性的覆盖 217 4.3 继承案例 218 4.3.1 开发数组的父类 219 4.3.2 开发排序类 221 4.3.3 开发反转类 222 4.4 final...
  • 5.2.1 关于扩展内建对象讨论 166 5.2.2 原型陷阱 167 5.3 本章小结 169 5.4 练习题 170 第6章 继承 171 6.1 原型链 171 6.1.1 原型链示例 172 6.1.2 将共享属性迁移到原型中去 175 6.2 只继承于原型 178 6.3 uber...
  •  对于一位分布式存储系统开发者,Cassandra 无疑是非常引人注目,它无中心架构、高可用性、无缝扩展等继承自亚马逊Dynamo 特质,相对于其他主从架构NoSQL 系统更加简洁,也更具有美感。  我从2010 年初...
  • 技术分享部分(鸿洋玩Android,还有代码家干活集中营等等),关于flutter版本极致体验玩Android客户端 玩Android,鸿洋大神开放接口, 首页轮播图+list:推荐最新博客 知识体系:对安卓知识体系做整理 登录...
  • 4.5.3 ADDM性能分析 179 第5章 数据库安全 180 5.1 企业数据库安全问题 180 5.1.1 更强口令散列算法 180 5.1.2 创新安全性 181 5.1.3 延迟失败登录 183 5.1.4 口令区分大小写 184 5.1.5 基本遵从行业...
  • Java范例开发大全 (源程序)

    热门讨论 2011-04-27 07:47:22
     实例167 继承关系加载顺序 266  实例168 如何访问同名方法或变量 268  实例169 super()方法使用 271  实例170 this方法使用 274  实例171 一张考试成绩单 275  实例172 银行自动存取一体机 278 ...
  • java范例开发大全源代码

    热门讨论 2011-10-30 23:31:51
     实例167 继承关系加载顺序 266  实例168 如何访问同名方法或变量 268  实例169 super()方法使用 271  实例170 this方法使用 274  实例171 一张考试成绩单 275  实例172 银行自动存取一体机...
  • java范例开发大全

    2013-03-08 20:06:54
    实例255 一个关于泛型简单例子 511 实例256 带两个类型参数泛型 513 实例257 有界类型程序示例 514 实例258 通配符使用示例 515 实例259 泛型方法使用示例 516 实例260 泛型接口示例 518 实例261 泛型实现坐标...
  • 此次将长期思考、感悟,多年系统开发、设计和团队管理经验,以及深入分析众多项目实战宝贵成果和盘托出,力求将编程思想与具体实践融为一体,提炼出适合于广大读者快速理解和彻底掌握.NET软件开发最佳学习...
  • 必须要时从Java SE API源代码分析,了解各种语法在Java SE API中如何应用。  《Java JDK 7学习笔记》将IDE操作纳为教学内容之一,使读者能与实践结合,提供视频教学能更清楚地帮助读者掌握操作步骤。 内容简介 ...

空空如也

空空如也

1 2
收藏数 37
精华内容 14
关键字:

关于继承的案例分析