Java继承回顾（一）

/** ** A:继承(extends) * 让类与类之间产生关系,子父类关系 * B:继承案例演示： * 动物类,猫类,狗类 * 定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉) * C:案例演示 * 使用继承前 * D:案例演示 * 使用继承后 * * ###08.04_面向对象(继承的好处和弊端)(掌握) * A:继承的好处 * a:提高了代码的复用性 * b:提高了代码的维护性 * c:让类与类之间产生了关系，是多态的前提 * B:继承的弊端 * 类的耦合性增强了。*    什么是耦合，耦合性增强就是指两个类之间的关系越来越紧密，父类的变化影响着子类的变化，关系紧密 * 开发的原则：高内聚，低耦合。 * 耦合：类与类的关系 * 内聚：就是自己完成某件事情的能力 */public class Demo_extends {    public static void main(String[] args) {//        cat c=new cat();//        c.color="red";//        c.leg=4;//        c.eat();//        c.sleep();//        System.out.println(c.color +"...."+c.leg);//        DemoE e=new DemoE();//        e.show();//        e.methon();//        e.print();//        Son s=new Son();//        s.setName("sanmao");//        System.out.println(s.getName());//        Son s=new Son();//       s.print();//        Son2 s=new Son2();//        s.print();//        Son3 s=new Son3(2);//        Son4 s1=new Son4();//        System.out.println(s1.getName()+"..."+s1.getAge());//        System.out.println("-------------");//        Son4 s2=new Son4("sanmao",25);//        System.out.println(s2.getName()+"..."+s2.getAge());        Zi zi=new Zi();//        zi.show();    }}class Animal{    String color;    int  leg;    public void eat(){        System.out.println("吃饭");    }    public void sleep(){        System.out.println("睡觉");    }}class cat extends Animal{}class dog extends  Animal{}/** * ###08.05_面向对象(Java中类的继承特点)(掌握) * A:Java中类的继承特点 * a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹) * 有些语言是支持多继承，格式：extends 类1,类2,... * b:Java支持多层继承(继承体系) * B:案例演示 * Java中类的继承特点 * 如果想用这个体系的所有功能用最底层的类创建对象 * 如果想看这个体系的共性功能,看最顶层的类 */class DemoA{    public void show(){        System.out.println("DemoA");    }}class DemoB{    public void show(){        System.out.println("DemoB");    }}//class DemoC extends DemoA,DemoB{ //Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)////}class DemoD extends DemoA{    public void methon(){        System.out.println("DemoD");    }}class DemoC extends DemoA{ //如果是多继承那么继承两个类的话，两个类里有重复行为，执行内容不一样，有二义性                            //多继承具有安全隐患}class DemoE extends DemoD{ //Java支持多层继承，继承体系 E 继承 D ,D 继承 A 多层继承，继承是可以传递的    public void print(){        System.out.println("DemoE");    }}/** * ###08.06_面向对象(继承的注意事项和什么时候使用继承)(掌握) * A:继承的注意事项 * a:子类只能继承父类所有非私有的成员(成员方法和成员变量) * b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。 * (为什么不能继承父类的构造方法，构造方法都是和本类名一致，所以构造方法是本类私有的，用来创建类对象的 * ，既同一文件下不能有两个相同的类，不能传递给子类，) * c:不要为了部分功能而去继承 * 项目经理 姓名 工号 工资 奖金 * 程序员  姓名 工号 工资 * 项目经理 去继承程序员 实现上没有任何问题，但是不符合继承关系，应该创建一个员工类 让项目经理和程序员共同去继承 * B:什么时候使用继承 * 继承其实体现的是一种关系："is a"。 Person Student Teacher 水果 苹果 香蕉 橘子 采用假设法。 如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。 *//** * ###08.07_面向对象(继承中成员变量的关系)(掌握) * A:案例演示 * a:不同名的变量 * b:同名的变量*/class Father {    private String name;//子类只能继承父类所有非私有的成员(成员方法和成员变量)，   // 私有的将不会被继承，但可以用公共行为来调用    int num=10;    int num2=30;    public void show(){        System.out.println("Father");    }    private void show2(){        System.out.println("Father2");    }    public void setName(String name){ //子类可以继承父类公共的方法来，修改获取父类的私有成员变量        this.name=name;    }    public String getName(){        return name;    }}class Son extends Father{    int num2=20;    public void print(){        //子父类出现同名变量，只是在讲课上有，实际开发中不会存在这一情况                                //子类继承父类就是为了使用父类的成员变量，再声明一个同名变量无意义        System.out.println(num);        //10        System.out.println(num2);       //20 就近原则  子类有的成员变量，就不用父类了    }}/** * ###08.08_面向对象(this和super的区别和应用)(掌握) * A:this和super都代表什么 * this:代表当前对象的引用,谁来调用我,我就代表谁 * super:代表当前对象父类的引用 * B:this和super的使用区别 * a:调用成员变量 * this.成员变量 调用本类的成员变量,也可以调用父类的成员变量 * super.成员变量 调用父类的成员变量 * b:调用构造方法 * this(...)    调用本类的构造方法 * super(...)   调用父类的构造方法 * c:调用成员方法 * this.成员方法 调用本类的成员方法,也可以调用父类的方法 * super.成员方法 调用父类的成员方法*/class Father2{    int num1=10;    int num2=30;    private int num3=99;    public  void show(){        System.out.println("Fathre2");    }}class Son2 extends Father2{    int num2=20;    public void print(){        System.out.println(this.num1);//this 既可以调用本类的行为变量，也可以调用从父类继承的行为变量        System.out.println(this.num2);        System.out.println(super.num2);//super调用父类公开的行为和变量，       // System.out.println(super.num3); //super也无法调用父类的私有行为和变量        this.show();        super.show();//        this.print();                 方法可以调用方法本身，其实就是死循环，循环到一定次数，会出错，溢出错误    }}/** * ###08.09_面向对象(继承中构造方法的关系)(掌握) * A:案例演示 * 子类中所有的构造方法默认都会访问父类中 空参数 的构造方法 * B:为什么呢? * 因为子类会继承父类中的数据，可能还会使用父类的数据。 * 所以，子类初始化之前，一定要先完成父类数据的初始化。 * 其实： * 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。*/class Father3{                   //申请一个子类对象，就会默认先执行父类的无参构造参数，想执行父类的有参构造                                //方法，需要用super来调用有参构造方法    int num;    public Father3(){        System.out.println("Father3的无参构造方法");    }    public Father3(int num){        this.num=num;        System.out.println("Father3的有参构造方法");    }}class Son3 extends Father3{ //    int num1;    public Son3(){         //如不重写构造参数，编译器默认带有一个无参构造方法，如果你指定了一个有参构造参数                            //那么编译器将不再自动添加无参构造参数，你需要写上无参构造参数        super();     //如果不写 系统将默认加上，无论是系统自动的无参构造方法，还是你重申的，都会有super();        System.out.println("Son3的无参构造方法");    }    public Son3(int num1){        this.num1=num1;        System.out.println("Son3的有参构造方法");    }}/** * ###08.10_面向对象(继承中构造方法的注意事项)(掌握) * A:案例演示 * 父类没有无参构造方法,子类怎么办? * super解决 * this解决 * B:注意事项 * super(…)或者this(….)必须出现在构造方法的第一条语句上*/class Father4{    private String name;    private int age;//    public Father4(){//        System.out.println("Father4 空参构造");//    }    public Father4(String name,int age){  //super(…)或者this(….)必须出现在构造方法的第一条语句上*/        this.name=name;        this.age=age;        System.out.println("Father4 有参构造");    }    public void setName(String name){        this.name=name;    }    public String getName(){        return name;    }    public void setAge(int age){        this.age=age;    }    public int getAge(){        return this.age;    }}class Son4 extends Father4{    public Son4(){//super(…)或者this(….)必须出现在构造方法的第一条语句上*/      // super("yogchao",25);  调用父类中的构造方法        this("yongchao",24);  // 所以在构造方法里面super()，和this()只能出现一个！！！且放在第一位        System.out.println("Son4 空参构造");    }    public Son4(String name,int age){//super(…)或者this(….)必须出现在构造方法的第一条语句上*/        super(name,age);  //子类一定会访问父类        //super(); 有参构造里面也隐藏着super(); 而不是super(参数)，因为他根本不知道你要穿什么，所以默认是super()        System.out.println("Son4 有参构造");    }}/** * ###08.11_面向对象(继承中的面试题)(掌握) * A: 案例演示 * Fu 静态代码块 * Zi 静态代码块 * Fu 构造代码块 * Fu 构造方法 * Zi 构造代码块 * Zi 构造方法 * 执行过程 * 1.JVM 调用main方法，将main方法进栈 * 2.遇到 Zi z=new Zi(),会先将Fu.class和Zi.class分别加载到内存，在创建对象，当Fu.class加载进内存，Fu类 * 中的静态代码块会随着Fu.class一起加载到内存，当Zi.class加载进内存，Zi类中的静态代码块会随着Zi.class * 一起加载到内存，所以先输出 Fu静态代码块，再输出Zi静态代码块 *  3.走Zi类的构造方法，因为Java中是分层初始化的，先初始化父类，再初始化子类，所以先走父类的构造，但是在 *  执行父类构造时，发现父类有构造代码块，构造代码块是优先于构造方法执行的，所以第三个输出构造代码块 *  第四个输出构造方法 *  4.父类初始化完，子类开始初始化，第五个输出子类的构造代码块，第六个输出子类构造方法 * *  */ class Fu{    static{        System.out.println("Fu 静态代码块");    }    {        System.out.println("Fu 构造代码块");    }    public int num=10;    public Fu(){        System.out.println("Fu 构造方法");    }}class Zi extends Fu{    static {        System.out.println("Zi 静态代码块");    }    {        System.out.println("Zi 构造代码块");    }    public int num=20;    public Zi(){        System.out.println("Zi 构造方法");    }    public void show(){        int num=30;        System.out.println(num);   //30  考察就近原则        System.out.println(this.num); //20        System.out.println(super.num); //10    }}