继承学习（1）

继承初学习

使用继承时的对象实例、super的用法

public class Demo01 {
    public static void main(String[] args) {
        Father f = new Father();
        Son s = new Son();
        System.out.println("a of son is:"+s.a);
        System.out.println("a of Father is:"+f.a);
        //子类调用其方法来返回从父类继承的属性a:100
        System.out.println("a of son's super is:"+s.getA());
        System.out.println("======================================");

        System.out.println("子类调用父类的方法miner(),父类属性a：100-1=99");
        s.miner();
        System.out.println("a of son's super is:"+s.getA());
        System.out.println("子类属性a:0，没有受到影响");
        System.out.println("a of son is:"+s.a);
        System.out.println("对象f的属性没有改变");
        System.out.println("a of Father is:"+f.a);

    }
}
class Father{
    int a = 100;
    public void miner(){
        a--;
    }
}

class Son extends Father{
    /**
     * 这是子类Son自定义的属性a，与从Father类继承下来的属性a是两个属性，占用不同的内存
     */
    int a = 0;
    public void plus(){
        a++;
    }

    public int getA(){
        //super.a表示访问父类Father的属性a
        return super.a;
    }
}

在这里，有个新关键字——super出现，该关键字有两种用法

1. super可在子类内部用于表示父类，后面使用“.”运算符可以访问父类与子类同名的父类成员

2. 在子类中使用super可表示调用父类的构造方法，后面的括号内可向父类的构造方法传递参数

继承的初始化与收尾

class GrandParent{
    /**
     * 无参数的构造方法
     */
    GrandParent(){
        System.out.println("无参数的构造方法");
    }
    GrandParent(int i){
        System.out.println("GrandParent");
    }
}

class Parent extends GrandParent{
    Parent(int i){
        //GrandParent已有无参数构造方法，因此没有该语句也不会有问题
        super(i);
        System.out.println("Parent");
    }
    int One = 1;
}

class Child extends Parent{
    Child(){
        //Parent中没有无参数构造方法，因此该语句不可省略,且必须放在第一行
        super(2);
        System.out.println("Child");
        //super在子类中表示父类，通过“.”调用父类Parent的成员
        System.out.println(super.One);
    }
}

public class Demo02 {
    public static void main(String[] args) {
        Child child = new Child();
    }
}

心得：在创建类的时候，尽可能地提前写好无参数的构造方法，方便以后使用

继承与合成共存时的初始化

class Chair{
    Chair(int i){
        System.out.println("Chair:"+i);
    }
}

class DinnerChair extends Chair{
    DinnerChair(int i){
        super(i+1);
        System.out.println("DinnerChair:"+i);
    }
}

class Room{
    Room(int i){
        System.out.println("Room:"+i);
    }
}

class DinnerRoom extends Room{
    /**
     * 作为成员
     */
    DinnerChair chair1;
    Chair chair2;

    DinnerChair chair3 = new DinnerChair(3);

    DinnerRoom(int i){
        super(i+1);
        System.out.println("===================");
        chair1 = new DinnerChair(1);
        chair2 = new Chair(2);
        System.out.println("DinnerRoom:"+i);
    }
}

public class Demo03 {
    public static void main(String[] args) {
        //先完成父类初始化，再完成子类初始化
        new DinnerRoom(100);
    }
}

输出：

Room:101
Chair:4
DinnerChair:3

==================

Chair:2
DinnerChair:1
Chair:2
DinnerRoom:100

这部分初看时有些晕，大概总结就是：在继承中，数据成员初始化顺序为先完成父类初始化，再完成子类初始化，若既有继承关系，又有合成关系，遵循“先继承，后合成”的原则