Java SE知识点六：面向对象之：多态

无限进步的Wilbur

于 2024-08-06 16:25:30 发布

阅读量493

点赞数 11

分类专栏： Java SE知识点文章标签： java 开发语言改行学it idea intellij idea 后端

本文链接：https://blog.csdn.net/Wilburli99/article/details/140923697

版权

Java SE知识点专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1. 多态的概念

多态也是Java面向对象的三大要点之一，多态的概念通俗来讲就是一个事物的多种形态，让不同的对象去完成一个方法时会出现不同的状态。

比如，猫吃饭和狗吃饭就是不同的状态，但用到的方法都是一样。

2. 实现多态

2.1 实现条件

要实现多态需要遵循以下条件：

必须是在继承体系之下；
子类要对父类的方法进行重写；
通过父类的引用调用重写的方法；

多态在实现上会体现出，在代码运行时，传递不同的对象，会调用对应类的方法。

class Animals{
    public String name;
    public int age;

    public Animals(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public void play(){
        System.out.println(name + "正在玩耍");
    }
}

class Dog extends Animals{
    //超键匹配父类的构造方法
    public Dog(int age, String name) {
        super(age, name);
    }

    public void eat(){
        System.out.println(name + "正在吃狗粮");
    }
    public void play(){
        System.out.println(name + "正在玩球");
    }
}

class Bird extends Animals{

    public Bird(int age, String name) {
        super(age, name);
    }

    public void eat(){
        System.out.println(name + "正在虫子");
    }

    public void fly(){
        System.out.println(name + "正在飞");
    }
}

public class Animal2 {
    // 编译器在编译代码时，并不知道要调用 Dog 还是 bird 中eat的方法
    // 等程序运行起来后，形参 animal 引用的具体对象确定后，才知道调用那个方法 
    // 注意:此处的形参类型必须时父类类型才可以
    public static void eat(Animals animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog(5,"小黑");
        Bird bird = new Bird(3,"小雀");
        
        eat(dog);
        eat(bird);
}

2.2 重写

前面多次提到了重写，到底什么是重写呢？

重写（override）：也称为覆盖，是子类对父类的实现过程进行重新编写，返回值和参数都不变，名称也相同。

重写需要遵循以下规则：

子类在重写父类的方法时，一般必须与父类方法原型一致: 返回值类型方法名 (参数列表) 要完全一致被重写的方法返回值类型可以不同，但是必须是具有父子关系的。
访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected。
父类被static、private修饰的方法、构造方法都不能被重写。
重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写。

重写也有一些注意事项：

必须是子类对父类的成员方法进行重写
成员方法是非静态，非private修饰，非final修饰，非构造方法

2.3 重写和重载的区别

我们前面也提到过重载，这两个词也看着挺相似，其实这两个是完全不相同的。

重载：参数列表（必须不同），返回类型（可以不同），访问限定符（可以不同）

重写：参数列表（必须相同），返回类型（一定不能修改，除非构成父子类关系），访问限定符（须比父类方法的访问权限高）

重载是静态绑定，在编译时就已经根据用户传递的实参类型确定调用的哪个方法。

重写是动态绑定，在编译时不能确定具体调用哪个方法，需要等程序运行时，才能够确定。

2.4 向上转型和向下转型

向上转型：

向上转型是实现动态绑定的方法：

1. 直接赋值

        //父类引用了子类，向上转型1:直接赋值
        Animals animals = new Dog(6,"小黄");
        animals.play(); //父类只能调用自己的方法，//

接着上面的代码，这种父类直接赋值子类是向上转型的一种，这种情况下父类只能调用自己的方法。

2. 方法传参

    public static void func(Animals animals){
        animals.eat(); // 承接上面代码
    
    }

    public static void main(String[] args){
        // 向上转型2:方法传参方式
        func(dog);
        func(bird);
    }

3. 作为返回值

    public static Animals func2(){
        return new Bird(3,"小雀");
    }

    public static void main(String[] args) {
        // 向上转型3:返回值方式
        Animals animals3 = func2();
    }

向下转型：

向下转型是一种“强转”的方法，子类在用 new 关键字定义对象时，转成父类。

class Animals{
    public String name;
    public int age;

    public Animals(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public void play(){
        System.out.println(name + "正在玩耍");
    }
}

class Dog extends Animals{
    //超键匹配父类的构造方法
    public Dog(int age, String name) {
        super(age, name);
    }

    public void eat(){
        System.out.println(name + "正在吃狗粮");
    }
    public void play(){
        System.out.println(name + "正在玩球");
    }
}

class Bird extends Animals{

    public Bird(int age, String name) {
        super(age, name);
    }

    public void eat(){
        System.out.println(name + "正在虫子");
    }

    public void fly(){
        System.out.println(name + "正在飞");
    }
}

public class Animal2 {
    
    public static void main(String[] args) {
        //向下转型,不安全（强转父类）
        Animals animals4 = new Dog(6,"小红");
        Dog dog3 = (Dog)animals4;
        animals4.play();

        ((Dog) animals4).eat();//向下转型只能引用自己的方法，转谁，用谁的方法

        if (animals4 instanceof Dog){ //instanceof判断可以提高安全性，如果该表达式为            true，则可以安全转换
            ((Dog) animals4).eat();
        }else {
            System.out.println("can't eat");
        }
}

以上就是向上转型和向下转型。

3. 多态的优缺点

3.1 多态的优点

多态能够降低圈复杂度，圈复杂度其实就是使用 if - else 语句的数量。因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 "圈复杂度" 如果一个方法的圈复杂度太高, 就需要考虑重构.

可以看下面的代码

class Shape { //属性....
    public void draw() {
        System.out.println("画图形!");
    }
}
class Rect extends Shape{
    @Override
    public void draw() { //重写
        System.out.println("♦");
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {//重写
        System.out.println("●");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {//重写
        System.out.println("❀");
    }
}

public class duotai {
    
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        Rect rect = new Rect();
        Flower flower = new Flower();
        Shape[] shapes = {cycle, rect, flower};
        
        //如果没有使用多态,使用if - else
        for (String shape : shapes) { 
            if (shape.equals("cycle")) {
                cycle.draw();
            } else if (shape.equals("rect")) {
                rect.draw();
            } else if (shape.equals("flower")) {
                flower.draw();
            }
        
        }
    }
}

这是没有涉及多态时的写法，下面是使用多态的写法

public class duotai {
    
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        Rect rect = new Rect();
        Flower flower = new Flower();
        Shape[] shapes = {cycle, rect, flower};
        
        //多态写法
        for (Shape shape : shapes){
            shape.draw(); //简洁写法
        }
    }
}

这么一对比就很明显了，使用多态写的代码不仅简洁而且具有相应的功能。

3.2 多态的缺点

1. 属性没有多态性

当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性

2. 构造方法没有多态性

看如下代码：

class B { 
    public B() {
        // do nothing
        func(); 
    }
    public void func() { 
        System.out.println("B.func()");
    } 
}

class D extends B {    //D继承了B
    private int num = 1;  //子类中有 成员变量 赋值为1
    @Override
    public void func() {。//子类重写了父类的方法
        System.out.println("D.func() " + num); 
    }
}

public class Test {
    public static void main(String[] args) {
        D d = new D();  //最终会输出 什么？
    }
}

有些人看到创建了子类 D 对象，肯定想的是输出 D.func() 1，因为num = 1。

但是，我们可以仔细梳理一下，当创建 D 对象时，因为子类重写了父类的方法，而父类中有一个构造方法调用了被重写的成员方法 func，所以：