java学习笔记之—多态



一、父类引用指向子类对象：

父类引用指向子类对象时，注意以下几点：
1、实例化一个没有名字的子类对象，然后向上转型为父类的父类的引用，先去调用子类重写的方法，子类没有重写就再去调用父类的方法。
2、只能调用父类中定义过的方法和变量（父类中没有定义过调用的时候要报错）
3、专属于子类的成员变量，在子类方法中被访问时，这时候通过父类引用还是可以调用子类重写的的方法
4、覆盖private方法虽然编译器不会报错但是也不会按照我们所期望的执行
5、覆盖变量后，调用的成员变量与我们所期望的不一样
6、静态方法的行为不具有多态性，因为静态方法是与类，而非是对单个对象相关联的。

class Son extends Super{int fo=2;//不是应该引用我吗？String s="子类专属的变量用在子类重写的方法中，利用父类引用可以调用该方法";public void f(int i){System.out.println(s);}void f(){System.out.println("不是应该调用子类方法的吗？");}static void g(){ System.out.println("子类静态方法");}}public class Super {int fo=1;//覆盖变量后，调用的成员变量与我们所期望的不一样，调用的是父类的成员变量     private void f(){System.out.println("父类方法访问权限为private时，调用父类方法");}     void f(int i){     System.out.println("子类的f(i)方法");     }     static void g(){     System.out.println("父类静态方法");     }public static void main(String[] args) {Super s1=new Son();s1.f(1);s1.f();//private方法对导出类是屏蔽的，所以覆盖private方法虽然编译器不会报错//但是也不会按照我们所期望的执行System.out.println("覆盖变量结果，fo="+s1.fo);s1.g();//调用的是父类的静态方法}}

运行结果：
子类专属的变量用在子类重写的方法中，利用父类引用可以调用该方法
父类方法访问权限为private时，调用父类方法
覆盖变量结果，fo=1
父类静态方法

二、多态：

多态存在的条件：
一、要有继承；
二、要有重写；注意不是重载
三、父类引用指向子类对象。实例化一个没有名字的子类对象，然后向上转型为父类的父类的引用
只能调用父类中定义过的方法和变量（父类中没有定义过调用的时候要报错）

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{}public class T1 {public static void main(String[] args) {        A a2 = new B();          B b = new B();          C c = new C();           D d = new D();        /*方法调用的优先级         1、this.show(O)         2、super.show(O)         3、this.show((super)O)、         4、super.show((super)O) */               System.out.println(a2.show(b));        /*         1、this.show(b)=a2.show(b)在A类里找show(b)方法，A类里没有show(b)方法         2、super.show(b)=?A类没有super类         3、this.show((super)b)=a2.show(a),在A类中有show(a)方法         4、a2引用指向的是B对象，且B类中有对A类中的show(a)方法重载，所以最终调用的是B类中的         show(a)方法                      第4步中                      父类引用指向子类对象，先去调用子类重写的方法，子类没有重写就再去调用父类的方法。                                              */        System.out.println(a2.show(c));        /*         1、this.show(c)=a2.show(c)在A类里找show(c)方法，A类里没有show(c)方法         2、super.show(c)=?A类没有super类         3、this.show((super)c)=a2.show(b),在A类中有show(a)方法                       接下来同上一输出         4、this.show(b)=a2.show(b)在A类里找show(b)方法，A类里没有show(b)方法         5、super.show(b)=?A类没有super类         6、this.show((super)b)=a2.show(a),在A类中有show(a)方法         7、a2引用指向的是B对象，且B类中有对A类中的show(a)方法重载，所以最终调用的是B类中的         show(a)方法         */        System.out.println(a2.show(d));        /*         this.show(d)=a2.show(d)在A类里找show(d)方法,A类中有show(d)方法                       因为B类中没有重载A类的show(d)方法，所以最终执行的是A类中的show(d)方法         */        System.out.println(b.show(b));        System.out.println(b.show(c));              System.out.println(b.show(d));        /*         1、this.show(d)=b.show(d),在B类中找show(d)方法，找不到。         2、super.show(d)=a.show(d),在A类中找show(d)方法，找到后调用A类的show(d)         */}}

运行结果：
B and A
B and A
A and D
B and B
B and B
A and D