Java多态的本质

2023年4月10日 155次阅读

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

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

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

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

 

下面两道小练习 

 1     public static void main(String[] args) {
 2         A a1 = new A();
 3         A a2 = new B();
 4         B b = new B();
 5         C c = new C();
 6         D d = new D();
 7         System.out.println("(1)" + a1.show(b));
 8         System.out.println("(2)" + a2.show(d));
 9         System.out.println("(3)" + b.show(c));
10         System.out.println("(4)" + b.show(d));
11     }
12 13 class A{
14     public String show(D obj){
15         return ("A and D");
16     }
17     public String show(A obj){
18         return "A and A";
19     }
20 }
21 class B extends A{
22     public String show(B obj){
23         return "B and B";
24     }
25     public String show(A obj){
26         return "B and A";
27     }
28 }
29 class C extends B{
30     
31 }
32 class D extends B{
33     
34 }

结果如下：

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

 

 1 public static void main(String[] args) {
 2         A a1 = new A();
 3         A a2 = new B();
 4         B b = new B();
 5         C c = new C();
 6         D d = new D();
 7         System.out.println("(1)" + a1.show(b));
 8         System.out.println("(2)" + a2.show(d));
 9         System.out.println("(3)" + b.show(c));
10         System.out.println("(4)" + b.show(d));
11     }
12 }
13 
14 class A {
15     public String show(C obj) {
16         return ("A and C");
17     }
18 
19     public String show(A obj) {
20         return "A and A";
21     }
22 }
23 
24 class B extends A {
25     public String show(B obj) {
26         return "B and B";
27     }
28 
29     public String show(A obj) {
30         return "B and A";
31     }
32 }
33 
34 class C extends B {
35 
36 }
37 
38 class D extends B {
39 
40 }

结果如下：

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

 

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

 1 public class Test03 {
 2     public static void main(String[] args) {
 3         Base b1 = new Base();
 4         Base b2 = new Sub();
 5     }
 6 }
 7 
 8 class Base {
 9     Base() {
10         method(100);
11     }
12 
13     public void method(int i) {
14         System.out.println("base : " + i);
15     }
16 }
17 
18 class Sub extends Base {
19     Sub() {
20         super.method(70);
21     }
22 
23     public void method(int j) {
24         System.out.println("sub : " + j);
25     }
26 }

运行结果：

base : 100
sub : 100
base : 70

 

点赞