父类引用指向子类对象，动态绑定

package base;

//创建一个父类型A
class A {
    //给父类一个静态成员变量
   static int a = 1;
    
    //一个静态方法
   public static void f () {
      a ++;
   }
    
    //一个普通方法
   public String g( A obj ){
      return "A";
   }
}

//让子类型B去继承A
public class B extends A {
    
    //方法重写
   public static void f () {
      a += 2;
   }

   //这里实际上属于方法重载（参数不一样），所以其实这个类里还有父类的那个g方法被隐藏了，那个方法的参数是A类
   public String g( B obj ){
      return "B";
   }
    
    //实验后证明，如果我在这里加一个重名方法，并且参数和父类A中的方法完全一致
    //那么这个时候才算作方法重写，后面的所有动态绑定后调用g方法都会实际调用该方法，返回一个"B"
    /*public String g(A obj) {
      return "B";
	}*/

    //如果我们在子类中单独创建一个新方法，语法上来说没有任何问题
    //但就不能通过动态绑定来调用该方法了。因为这是子类的独有方法，编译器在父类中会找不到
   public int test() {
      return 1;
   }

   public static void main ( String [] args ) {
   
      A a2 = new A();
//    a2.test();  这里是用不了test方法，因为test方法独属于子类，父类对象”看不见”这个方法

      //语法1非常简单，我们来先用语法2做个示范
      B b = new B() ;

//    (A)b.test(); 会报错，用不了，因为向上转型在编译阶段会被看做A类，但A类中没有test方法

       //实际编写中这里可以用一个父类引用保存一下这个强转后的对象，提高复用率。这里是为了介绍一下语法的多种可能性
       //这里我们用实例引用调用静态方法，语法上可以通过，但其实是相当于A.f();
      ((A)b).f() ;
       
      String res = ((A)b).g(b); //这里我们把b向上转型强转成A类，所以g接收的参数是A类
                           //方法重载了（参数不同），所以调用的是父类的g方法，显示A
       
      System.out.println(a);//2
      System.out.println(res);//A

       //语法1
      A tmp = new B(); //动态绑定
//    tmp.test(); 同样的，这种写法也不行，它会先去A类中尝试寻找test方法，找不到，会报错
   
      tmp.f();
      System.out.println(a);//3
      System.out.println(tmp.g(tmp)); //A，这里同样，动态绑定了，声明类型为A，所以当tmp作为参数时，被视为A类
       
      //创建一个单纯的B类对象检查一下代码没有问题
      B tmp2 = new B();
      System.out.println(tmp2.g(tmp2)); //B

   }
}

控制台输出：

2

A

3

A

B

动态绑定

当我们创建一个对象时，如果声明类型与实际new的类型不一样，怎么办？

这种情况一般出现在父类与子类之间，也只有使用父类作为声明类型、子类作为实际类型，才是Java允许的合法语法。

当调用同名方法时，会使用实际类型中的方法，我们把这种情况称为动态绑定。

声明方法

一般有两种写法：

父类型 引用名称 = new 子类型();  //第一种

子类型 子类引用名 = new 子类型();  //第二种
父类型 引用名称 = (父类型强转)子类引用名;

如果使用这个对象来调用某个普通方法，编译器首先会去父类中找，有没有这个方法。

如果没有，会报错，无法通过编译。

如果有，再去子类中调用子类重写后的方法。

这好比是用一个父类型的箱子外壳把子类型对象给装起来了，外壳上贴着父类的一个方法目录，如果调用的方法在这个目录上，那就没有问题，允许通过。但实际的方法还是装在箱子里面，实际是子类自己的重写方法，调用就是拿箱子里面的这个。

注意事项

需要注意的是：

• 当子类重写了继承于父类的静态方法后，该方法无法通过动态绑定获取。
• 动态绑定后 如果想使用重写后的静态方法，必须使用子类名.方法名() 的方式。如果使用实例引用，则会默认使用父类方法。