java向上转型和向下转型1

　　在java继承体系中，认为父类(超类)在上层，子类在下层(派生类) ，向上转型就是把子类对象转成父类对象。

1 public class Father {    
2     public void eat(){
3         System.out.println("我是父类的方法吃。。。。。");
4     }
5 }

1 public class Son extends Father{
2     
3     public void eat(){
4         System.out.println("我是Son的方法吃。。。。。");
5     }
6     public void sleep(){
7         System.out.println("Son睡觉");
8     }
9 }

测试

 1 public static void main(String[] args) {
 2            Father f=new Son();//子类向上转型           
 3            Person p=new Son();//普通的new
 4            f.eat();    
 5             //f.sleep();无法调用此方法 此方法不存在
 6            p.eat();
 7            p.sleep();
 8     
 9         
10     }    
11  运行结果： 我是子类的方法吃
12                 我是子类的方法吃
13                 睡觉

　　此处无法调用f.sleep() ，就是向上转型之后会失去父类中没有定义的方法，只能调用父类中定义的方法。那到底向上转型有什么用处那为何不直接那子类自己定义的对象直接调用？

如果直接new Son() 打点调用也可以这样就没有体现出面向对象的抽象的编程思想，而且代码的可扩展性差。

　　若果该父类还有一个子类Son1

1 public class Son1 extends Father {
2     public void eat(){
3         System.out.println("son1 的eat方法");
4     }
5     public void sleep(){
6         System.out.println("son1 的sleep方法");
7     }
8 
9 }

　　看下边测试代码

 1 public class Test {
 2     public static void main(String[] args) {
 3        
 4         tt(new Son());
 5         tt(new Son1());
 6     }
 7     
 8     
 9     public static void tt(Son son){
10         
11         son.eat();
12     }
13     public static void tt(Son1 son){
14         
15         son.eat();
16     }
17 
18 }

我的tt方法中需要调用各个子类的一些或所有方法，代码如上所示，假若我有很多个子类这样代码就显的特别沉于重复率太高

向上转型就可以完美的解决此类问题：无论我有多少个子类都可以一个方法搞定。。

 1 public class Test {
 2     public static void main(String[] args) {
 3        
 4         tt(new Son());
 5         tt(new Son1());
 6     }
 7     
 8     
 9     public static void tt(Father son){
10         //父类对象当做实例化参数
11         son.eat();
12     }
13 }

java向上转型和向下转型1

猜你喜欢