java上转型对象分析

定义：如果B类是A类的子类或间接子类，当用B类创建对象b并将这个对象b的引用赋给A类对象a时，如：

[java] view plain copy

1. A a= new B();    
2.   //OR    
3. B b = new B(); A a = b;  

          则称A类对象a是子类B对象b的上转型对象。

注意：1，A既可以是一般class，还可以是interface、abstract（可以参考文章：抽象类和接口的功能与区别）；

           2，上转型对象不能调用子类新增的属性和方法，只能调用子类继承和隐藏的属性，子类继承和重写的方法；

                 解释——属性：子类中与父类同名的属性也算作子类新增属性，不能被调用。所以我们在程序中显示调用的那个同名属性事实上是属于父类                                               的被隐藏属性，输出值当然会是父类的值。

                               方法：上转型对象调用的方法，要么是直接从父类那继承未被重写的方法，要么是被子类重写过的方法，不可能是隐藏方法。

           3，尽管2中说明上转型对象不能调用子类新增的属性和方法，但是上转型对象可以通过子类重写的方法操作子类以及父类中的所有方法和属性                    （不管新增还是隐藏）；

           4，上转型对象相对于子类对象，功能被弱化，但是能够强制转化为子类对象，从而具备子类的所有方法与属性B b=(B)a；

           5，子类对象实例被上转为父类对象，之所以还能够通过重写方法间接操作子类新增的方法与属性，是因为这个对象实例在内存中的本质还                            是子类类型的，只不过它的能力临时被消弱了；

           6，强制转化后的子类对象尽管功能较上转型对象增强，但是无论通过“==”还是“equals()”,比较结果都为true，因为他们的引用（指向的内存首地                     址）是相等的，即他们指向同一内存地址中的对象实例；

           7，Static静态方法属于类，能够被继承不能被重写；

           8，OOP遵守里氏代换原则——基类所出现的任何位置，子类都能出现；

实例：

        父类： 

[java] view plain copy

1. public class Subject{    
2.       
3.     public String b="我是父类b";  
4.       
5.     public void other(){  
6.         System.out.println("我是父类没被重写的方法");  
7.     }  
8.     public static void statics(){  
9.         System.out.println("我是父类的静态方法");  
10.     }  
11.       
12.     public void operation(){  
13.         System.out.println("我是父类方法");  
14.     };   
15. }    

        子类：

[java] view plain copy

1. public class MySubject extends Subject {    
2.     public String a="我是子类新增a";  
3.       
4.     public String b="我是子类b";  
5.       
6.       
7.     @Override    
8.     public void operation() {    
9.         System.out.println("我是子类方法");  
10.         System.out.println(b);  
11.         System.out.println(super.b);  
12.         System.out.println(getB1());  
13.         System.out.println(getB2());  
14.     }   
15.       
16.     public String getA(){  
17.         return a;  
18.     }  
19.     public void setA(String a){  
20.         this.a=a;  
21.     }  
22.       
23.     public String getB1(){  
24.         return this.b;  
25.     }  
26.     public String getB2(){  
27.         return super.b;  
28.     }  
29.       
30.     public void setB1(String b){  
31.         this.b=b;  
32.     }  
33.     public void setB2(String b){  
34.         super.b=b;  
35.     }  
36. }    

验证：

        测试类：

[java] view plain copy

1. public class ObserverTest {    
2.     
3.     public static void main(String[] args) {   
4.         Subject sub=new MySubject();  
5.         sub.operation();    
6.         MySubject sub1=(MySubject)sub;  
7.         System.out.println(sub1==sub);//true  
8.         System.out.println(sub1.equals(sub));//true  
9.     }    
10.     
11. } 

        测试结果：

[java] view plain copy

1. 我是子类方法  
2. 我是子类b  
3. 我是父类b  
4. 我是子类b  
5. 我是父类b  
6. true  
7. true  

另外：编译器提示：

           

          还能看到，如果我们通过@override强制重写父类的static静态方法