JAVA中的多态

Posted on In Views:

多态的定义

多态、封装和继承是面向对象的三大特性。现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。

Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。一个Student对象既可以赋值给一个Student类型的引用，也可以赋值给一个Person类型的引用。

最终多态体现为父类引用变量可以指向子类对象：父类类型 变量名 = new 子类类型();

  1. 多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。
  2. 在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

多态的表现形式

  1. 方法重载：通常是指在同一个类中，相同的方法名对应着不同的方法实现，这些方法名相同的方法其区别在于他们需要的参数不同；
  2. 方法重写：方法重写主要用于父类和子类间，子类重写父类的方法，只是对应的方法实现不同，其方法名和参数都相同；
  3. 抽象类：在java语言中，一个类中的方法只给出了标准，而没有给出具体的实现方法，这样的类就是抽象类。例如父类就是抽象类，它不会被实例化的类；
  4. 接口：在多态机制中，接口比抽象类使用起来更加方便。而抽象类组成的集合就是接口。

多态的三种形式

  • 普通类多态定义的格式：父类类型 变量名 = new 子类类型()。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    class Father {
        int num = 4;
    }
     
    class Son extends Father {
        int num = 5;
    }
     
    //普通类多态形式
    Father father = new Son();

  • 抽象类多态定义的格式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    abstract class Father {
        abstract void method();
    }
     
    class Son extends Father {
        public void method() {
            System.out.println("abstract");
        }
    }
     
    //抽象类多态表现形式
    Father father = new Son();

  • 接口多态定义的格式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    interface Father {
        public void method();
    }
     
    class Son implements Father{
        public void method() {
            System.out.println("implements")
        }
    }
    //接口多态的表现形式
    Father father = new Son();

注意：同一个父类的方法会被不同的子类重写。在调用方法时，调用的为各个子类重写后的方法。

1
2
3
4
Person p1 = new Student();
Person p2 = new Teacher();
p1.work(); //p1会调用Student类中重写的work方法
p2.work(); //p2会调用Teacher类中重写的work方法

多态的编译和运行

成员变量：编译和运行都看左边。

多态出现后类的成员有啥变化呢？学习继承时，我们知道子父类之间成员变量有了自己的特定变化，那么当多态出现后，成员变量在使用上有没有变化呢？
多态出现后会导致子父类中的成员变量有微弱的变化。如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Father {
    int num = 4;//没有这句会编译失败
}
class Son extends Father {
    int num = 5;
}
class Demo {
    public static void main(String[] args)  {
        Father f = new Son();
        System.out.println(f.num);
        Son z = new Son();
        System.out.println(z.num);
    }
}

打印结果：4
5
总结：当子父类中出现同名的成员变量时，多态调用该变量时：

  1. 编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败
  2. 运行时期：也是调用引用型变量所属的类中的成员变量。

简单记：编译和运行都参考等号的左边。编译运行看左边。

成员方法：编译看左边，运行看右边。

多态出现后会导致子父类中的成员方法有微弱的变化，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Father {
    int num = 4;
    //没有这个方法，编译失败
    void show() {
        System.out.println("Father show num");
    }
}
class Son extends Father {
    int num = 5;
    //重写父类方法
    void show() {
           System.out.println("Son show num");
    }
    void show_1{
           System.out.println("Son show show_1");
    }
}
class Demo {
    public static void main(String[] args)  {
        Father f = new Son();
        f.show();
        //f.show_1();
    }
}

打印结果：Son show num
总结：多态成员方法

  1. 编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败(如果把f.show_1()前面的注释打开，则编译失败)。
  2. 运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法（如果把子类重写的show()方法注释掉，那么打印的结果是Father show num）。

简而言之：编译看左边，运行看右边。

多态的转型

  • 向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。
    使用格式：父类类型 变量名 = new 子类类型()
    Person p = new Student();
  • 向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的！
    使用格式：子类类型 变量名 = （子类类型）父类类型
    Person p = new Student();
    Student stu = (Student) p

多态的好处与弊病

当父类的引用指向子类对象时，就发生了向上转型，即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型，提高了代码的扩展性。但向上转型也有弊端，只能使用父类共性的内容，而无法使用子类特有功能，功能有限制。如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
//描述动物类，并抽取共性eat方法
abstract class Animal {
    abstract void eat();
}

// 描述狗类，继承动物类，重写eat方法，增加lookHome方法
class Dog extends Animal {
    void eat() {
        System.out.println("啃骨头");
    }

    void lookHome() {
        System.out.println("看家");
    }
}

// 描述猫类，继承动物类，重写eat方法，增加catchMouse方法
class Cat extends Animal {
    void eat() {
        System.out.println("吃鱼");
    }

    void catchMouse() {
        System.out.println("抓老鼠");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Dog(); //多态形式，创建一个狗对象
        a.eat(); // 调用对象中的方法，会执行狗类中的eat方法
        // a.lookHome();//使用Dog类特有的方法，需要向下转型，不能直接使用
        // 为了使用狗类的lookHome方法，需要向下转型
        // 向下转型过程中，可能会发生类型转换的错误，即ClassCastException异常
        // 那么，在转之前需要做健壮性判断 
        if( !a instanceof Dog){ // 判断当前对象是否是Dog类型
                System.out.println("类型不匹配，不能转换"); 
                return; 
        } 
        Dog d = (Dog) a; //向下转型
        d.lookHome();//调用狗类的lookHome方法
    }
}

什么时候使用向上转型?
当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型：
Animal a = new Dog();
a.eat();

什么时候使用向下转型?
当要使用子类特有功能时，就需要使用向下转型：
Dog d = (Dog) a; //向下转型
d.lookHome();//调用狗类的lookHome方法
向下转型的好处：可以使用子类特有功能。
向下转型的弊端：需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。
如：if( !a instanceof Dog){…}