继承实现的基本原理.png

例子

• base类

public class Base {
            public static int s;
            private int a;
            static {
                System.out.println("基类静态代码块， s: "+s);
                s = 1;
            }
            {
                System.out.println("基类实例代码块， a: "+a);
                a = 1;
            }
            public Base(){
                System.out.println("基类构造方法， a: "+a);
                a = 2;
            }
            protected void step(){
                System.out.println("base s: " + s +", a: "+a);
            }
            public void action(){
                System.out.println("start");
                step();
                System.out.println("end");
            }
        }

• 子类

public class Child extends Base {
            public static int s;
            private int a;
            static {
                System.out.println("子类静态代码块， s: "+s);
                s = 10;
            }
            {
                System.out.println("子类实例代码块， a: "+a);
                  a = 10;
              }
              public Child(){
                  System.out.println("子类构造方法， a: "+a);
                  a = 20;
              }
              protected void step(){
                  System.out.println("child s: " + s +", a: "+a);
              }
          }

• main方法

public static void main(String[] args) {
            System.out.println("---- new Child()");
            Child c = new Child();
            System.out.println("\n---- c.action()");
            c.action();
            Base b = c;
            System.out.println("\n---- b.action()");
            b.action();
            System.out.println("\n---- b.s: " + b.s);
            System.out.println("\n---- c.s: " + c.s);
        }

• 输出结果

---- new Child()
基类静态代码块, s: 0
子类静态代码块, s: 0
基类实例代码块, a: 0
基类构造方法, a: 1
子类实例代码块, a: 0
子类构造方法, a: 10

---- c.action()
start
child s: 10, a: 20
end

---- b.action()
start
child s: 10, a: 20
end

---- b.s: 1

---- c.s: 10

类的加载

• 一个类的主要信息
  （1）类变量（静态变量）
  （2）类初始化代码

定义静态变量时的赋值语句
静态初始化代码块
先执行父类的，再执行子类的
父类执行时，子类静态变量的值也是有的， 是默认值。对于默认值，我们之前说过， 数字型变量都是0，boolean是false， char是'\u0000'，引用型变量是null。

（3）类方法（静态方法）
（4） 实例变量
（5）实例初始化代码

定义实例变量时的赋值语句
实例初始化代码块
构造方法

（6）实例方法
（7）父类信息引用

• 类加载过程包括：
  （1）分配内存保存类的信息
  （2）给类变量赋默认值
  （3）加载父类
  （4）设置父子关系
  （5）执行类初始化代码

内存

（1）栈存放函数的局部变量
（2）堆存放动态分配的对象
（3）方法区放类的信息
（4）例子加载后内存示意图

image.png

对象创建的过程

new Child()就是创建Child对象
（1）分配内存
（2）对所有实例变量赋默认值
（3）执行实例初始化代码
分配的内存包括本类和所有父类的实例变量，但不包括任何静态变量。实例初始化代码的执行从父类开始，先执行父类的，再执行子类的。但在任何类执行初始化代码之前，所有实例变量都已设置完默认值
每个对象除了保存类的实例变量之外，还保存着实际类信息的引用。
Child c = new Child();会将新创建的Child对象引用赋给变量c，而Base b = c;会让b也引用这个Child对象
创建和赋值后，内存布局

image.png

方法调用

• c.action()代码的执行过程
  （1）查看c的对象类型，找到Child类型，在Child类型中找action方法，发现没有，到父类中寻找
  （2）在父类Base中找到了方法action，开始执行action方法
  （3）action先输出了start，然后发现需要调用step()方法，就从Child类型开始寻找step方法
  （4）在Child类型中找到了step()方法，执行Child中的step()方法，执行完后返回action方法
  （5）继续执行action方法，输出end
  寻找要执行的实例方法的时候，是从对象的实际类型信息开始查找的，找不到的时候，再查找父类类型信息。
• b.action()
  这句代码的输出和c.action是一样的，这称之为动态绑定， 而动态绑定实现的机制，就是根据对象的实际类型查找要执行的方法， 子类型中找不到的时候再查找父类。这里，因为b和c指向相同的对象， 所以执行结果是一样的。
• 虚方法表
  所谓虚方法表，就是在类加载的时候，为每个类创建一个表， 这个表包括该类的对象所有动态绑定的方法及其地址， 包括父类的方法，但一个方法只有一条记录， 子类重写了父类方法后只会保留子类的。

image.png

对Child类型来说，action方法指向Base中的代码，toString方法指向Object中的代码，而step()指向本类中的代码。
这个表在类加载的时候生成，当通过对象动态绑定方法的时候，只需要查找这个表就可以了，而不需要挨个查找每个父类。

• 变量访问
  对变量的访问是静态绑定的，无论是类变量还是实例变量。代码中演示的是类变量：b.s和c.s，通过对象访问类变量，系统会转换为直接访问类变量Base.s和Child.s。
  例子中的实例变量都是private的，不能直接访问，如果是public的，则b.a访问的是对象中Base类定义的实例变量a，而c.a访问的是对象中Child类定义的实例变量a。