×

1.12（java学习笔记）多态及向上、向下转型

我的笔记 我的笔记 发表于2018-07-23 21:26:04 浏览2348 评论0

抢沙发发表评论

一、多态

多态是指同一个方法被调用，由于对象不同导致行为不同。

例如调用自由活动方法，张三喜欢玩耍，那么他就会去玩耍。

李四喜欢学习，那么他可能去学习。调用方法因对象的不同

而产生了不同的行为。

 

形成多态的三个条件：

1.继承

2.子类重写父类方法。

3.父类类型，子类对象。

 

以下列代码为例：

 

 1 public class Test {
 2     public static void main(String[] args) {
 3         Student stu = new Student();
 4         Teach tea = new Teach();
 5         freeActivi(stu);
 6         freeActivi(tea);    
 7     }
 8     
 9     static void freeActivi(Person per){//实现多态的条件之父类类型，子类对象
10         per.freeActivi();              //这样对象不同可以展现出不同的行为
11     }                                  //虽然参数类型是父类Person，但子类对象（stu,tea）会自动向上转型
12                                        //成Person，但调用的还是被子类重写的方法。
13 }
14 
15 class Person{
16     void freeActivi(){
17         System.out.println("自由时间");
18     }
19 }
20 
21 class Student extends Person{           //实现多态的条件之继承
22     void freeActivi(){                  //实现多态的条件之重写
23         System.out.println("玩耍");
24     }
25 }
26 
27 class Teach extends Person{
28     void freeActivi(){
29         System.out.println("备课");
30     }
31 }

 

 

运行结果：
玩耍
备课

 

可能大家会说多态有什么好处？

如果没有多态，那么每一个子类都需要重写定义以方法，例如：

 

static void freeActivi(Student per){
        per.freeActivi();
}


static void freeActivi(Teach per){ 
        per.freeActivi();
}//假如有几十种类型，一个一个创建对应的方法就很麻烦。

如果没有多态，那么不同类型需要一个个创建方法，方法一多就非常麻烦，有了多态可以省去很多步骤。

 

二、转型

 

可能大家不是很能理解static void freeActivi(Person per)这里的Person类型。结合下面的向上转型大家可能更好理解。

对象向上转型  父类  父类对象 = 子类对象    将子类对象转为父类对象，例如 Person per = stu;

用下面代码便于大家理解

 1 public class Test {
 2     public static void main(String[] args) {
 3         Student stu = new Student(); //首先创建了一个子类对象
 4         Person per = stu;            //然后将子类对象向上转型
 5         per.freeActivi();            //然后调用父类对象中的方法。
 6     }
 7    //运行后我们发现，结果是玩耍，并不是自由时间。
 8    //如果对象发生向上转型，调用的一定是被子类重写的方法。
 9 }
10 
11 class Person{
12     void freeActivi(){
13         System.out.println("自由时间");
14     }
15 }
16 
17 class Student extends Person{
18     void freeActivi(){
19         System.out.println("玩耍");
20     }
21 }
运行结果：
玩耍

 

如果将一个子类对象向上转型后，则调用的父类方法是被子类重写之后的方法，因此可以实现多态。

但是向上转型后的对象，无法在调用子类中方法，例如将Student 类的stu对象向上转型成Person。

此时只能调用Person中的方法，无法调用Student中的方法，此时需要向下转型才能调用Student中的方法。

 

子类 子类对象 = （子类）父类对象； 向下转型， 父类对象转为子类对象。

 

如下代码：

 

 1 public class Test {
 2     public static void main(String[] args) {
 3         Person stu = new Student();     //这里发生了向上转型，父类 父类对象 = 子类对象。
 4         Student stu_s = (Student)stu;   //这里又发生了向下转型
 5         stu_s.test();                   //转型完后才可以调用子类中的test方法，没有转型是无法调用的。
 6         
 7     }
 8 }
 9 
10 class Person{
11     void freeActivi(){
12         System.out.println("自由时间");
13     }
14     
15 }
16 
17 class Student extends Person{
18     void freeActivi(){
19         System.out.println("玩耍");
20     }
21     void test(){
22         System.out.println("test");
23     }
24 }

 

运行结果：
test

 

我的笔记博客版权我的笔记博客版权