Java多态的本质

　　今天复习了java多态，感觉收获颇多。多态的实现方式有两种，继承父类和实现接口。本质体现在重写上，不同的类重写时体现出不同的特征。编译时和运行时的不同上。编译时只能调用父类的方法，如果调用了子类独有的方法，如果是在notepad++上不会报错，但是javac时会编译错误。运行时可以调用父类的方法，如果子类中有和父类方法重名的方法，优先执行子类重写的方法除非调用super，只要编译时为父类了，就不能访问子类独有的方法。如果要访问子类独有的方法，要进行向下转型。

　　向下转型只能强制转换，子类引用变量指向父类实例，如果父类实例不是同一个子类向上转型得到的，在编译时不会报错，但在运行时会报java.lang.ClassCastException。所以向下转型只有在向上转型后才能用。

　　向上转型时，父类引用变量指向子类实例，这时可以调用子类中重写父类的方法，但不能调用子类独有的方法，否则在编译时就会报错。

　　方法中的成员变量不具备多态性，因为变量不会被重写，在编译时有两块存储堆内存，并取决于编译时所声明变量类型。和运行时对象的变量不是一块内存区域。简洁得来说，不能重写就没法表现出多态。

下面两道小练习

     public static void main(String[] args) {
         A a1 = new A();
         A a2 = new B();
         B b = new B();
         C c = new C();
         D d = new D();
         System.out.println("(1)" + a1.show(b));
         System.out.println("(2)" + a2.show(d));
         System.out.println("(3)" + b.show(c));
         System.out.println("(4)" + b.show(d));
     }
  class A{
     public String show(D obj){
         return ("A and D");
     }
     public String show(A obj){
         return "A and A";
     }
 }
 class B extends A{
     public String show(B obj){
         return "B and B";
     }
     public String show(A obj){
         return "B and A";
     }
 }
 class C extends B{
 
 }
 class D extends B{
 
 }

结果如下：

(1)A and A
(2)A and D
(3)B and B
(4)A and D

 public static void main(String[] args) {
         A a1 = new A();
         A a2 = new B();
         B b = new B();
         C c = new C();
         D d = new D();
         System.out.println("(1)" + a1.show(b));
         System.out.println("(2)" + a2.show(d));
         System.out.println("(3)" + b.show(c));
         System.out.println("(4)" + b.show(d));
     }
 }
 
 class A {
     public String show(C obj) {
         return ("A and C");
     }
 
     public String show(A obj) {
         return "A and A";
     }
 }
 
 class B extends A {
     public String show(B obj) {
         return "B and B";
     }
 
     public String show(A obj) {
         return "B and A";
     }
 }
 
 class C extends B {
 
 }
 
 class D extends B {
 
 }

结果如下：

(1)A and A
(2)B and A
(3)A and C
(4)B and B

还有一点，属性是没有多态性的，因为属性不会被重写

 public class Test03 {
     public static void main(String[] args) {
         Base b1 = new Base();
         Base b2 = new Sub();
     }
 }
 
 class Base {
     Base() {
         method(100);
     }
 
     public void method(int i) {
         System.out.println("base : " + i);
     }
 }
 
 class Sub extends Base {
     Sub() {
         super.method(70);
     }
 
     public void method(int j) {
         System.out.println("sub : " + j);
     }
 }

运行结果：

base : 100
sub : 100
base : 70