java学习之编译时类型（前期绑定）和运行时类型 （后期绑定、动态绑定、运行时绑定）

编译时类型和运行时类型：  

    Java的引用变量有两个类型，一个是编译时类型，一个是运行时类型，编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。若是编译时类型和运行时类型不一致，会出现所谓的多态。由于子类实际上是一种特殊的父类，所以java容许把一个子类对象直接赋值给一个父类引用变量，无须任何类型转换，或者被称为向上转型，由系统自动完成。

    引用变量在编译阶段只能调用其编译时类型所具备的方法，但运行时则执行它运行时类型所具备的方法，所以，编写Java代码时，引用变量只能调用声明该变量所用类里包含的方法。与方法不一样的是，对象的属性则不具有多态性。经过引用变量来访问其包含的实例属性时，系统老是试图访问它编译时类所定义的属性，而不是它运行时所定义的属性。

 —— 以上摘自《疯狂Java讲义》

前期绑定和后期绑定（动态绑定、运行时绑定）：

绑定：将一个方法调用同方法主体关联起来叫作绑定

前期绑定：在程序执行以前进行绑定（若是有的话，由编译器和链接器完成），前期绑定是面向过程程序设计语言中默认的绑定方式，例如，C语言只有一种方法调用，那就是前期绑定。

后期绑定：就是在程序运行时根据对象的类型进行绑定，也叫做动态绑定或运行时绑定。

注意：Java中除了static和final方法（private方法属于final方法，由于类中的private方法被隐式指定为final方法）以外，其余方法都是后期绑定。这意味着一般没必要断定是否该进行后期绑定，由于它是自动发生的。

下面举例说明：

1.子类方法覆盖父类方法（ 子类重写父类中的方法，调用子类中的方法）

class Father{
      public void method(){
          System.out.println("父类方法："+this.getClass());
      }
 }
 public class Son extends Father{
	public void method(){
          System.out.println("子类方法："+this.getClass());
      }
	public static void main(String[] args){
		Father instance = new Son();
		instance.method();
	}
}

运行结果：子类方法：class Son

2. 子类没有重写父类中的方法，因此到父类中寻找相应的方法

class Father{
      public void method(){
          System.out.println("父类方法："+this.getClass());
      }
 }
 public class Son extends Father{
      public static void main(String[] args){
		Father instance = new Son();
		instance.method();
	}
}

运行结果： 父类方法： class Son

3.动态绑定只是针对对象的方法，对于属性无效。由于属性不能被重写。

class Father{
     public String name = "Father'name";
      
 }

 public class Son extends Father{
	public String name = "Son'name";

	public static void main(String[] args){
		Father instance = new Son();
		System.out.println(instance.name);
	}
}

运行结果：Father'name

这里还能够从另一个方面来讲明：若是将Father类的

public String name = "Father'name";

那么编译器将报错：  错误: name能够在Father中访问private  这行代码执行时，访问的是父类的 name属性，而该属性被声明为private，因此没法访问，于是报错！

下面再分析一个例子：

class A
{
    int count = 20;
}

class B extends A
{
    int count = 200;
}

public class Test 
{
    public static void main(String[] args) 
    {
        A a = new A();
        System.out.println(a.count);
        B b = new B();
        System.out.println(b.count);
        A ab = b;   //向上转型
        System.out.println(ab.count);
    }
}

运行结果  ： 20
           200
           20

结果分析：

 前两行的输出毫无疑问，问题在

        A ab = b;    

        System.out.println(ab.count);

的输出是20，而不是200；在这之间咱们能够用

        System.out.println(ab == b);   

来进行简单的判断，结果输出为 true ，说明 ab 和 b 两个引用变量指向同一个实例，既然 ab 和 b 指向同一个实例，为何输出的是20不是200呢？缘由在于：

一、对于 class A 和class B来讲，class B是class A的子类，因为子类的变量并不会覆盖父类的变量，因此实际上在class B中是存在来两个count，在这分别记做 A.count 和B.count ；

二、虽然在 class B中存在A.count 和B.count ，可是究竟输出那一个 count ，取决于该引用变量的声明时类型（本文开头红色文字部分已经说明），此处 声明时类型 是 class A，因此输出 20 即A.count ，同理若改成 B ab = b ；则输出 200 即 B.count ；