封装，继承，多态（三）- Java

原创 于 2025-02-06 13:30:52 发布 · 1.1k 阅读 · 12 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

多态

多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。

在这里插入图片描述

总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。

向上转型

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。
语法格式：父类类型 对象名 = new 子类类型()；

Animal animal = new Dog("旺财",11);

在这里插入图片描述

public class Animal {
    public String name;
    public int age;

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

    public void eat(){
        System.out.println(this.name + "正在吃饭...");
    }
}

public class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    public void bark(){
        System.out.println(this.name + "正在汪汪汪叫...");
    }

    @Override
    public void eat(){
        System.out.println(this.name + "正在吃狗粮...");
    }
}

那只有这一种方式实现向上转型吗？

其实不然，一共有三种方式实现向上转型：

  1. 直接赋值

    Animal animal = new Dog("旺财",11);

  2. 方法的传参

    private static void func(Dog dog) {
        ...
    }
    
    public static void main(String[] args) {
        Dog dog = new Dog("旺财",10);
        func(dog);
    }
  1. 以返回值的形式
  	private static Animal func2() {
        Dog dog = new Dog("旺财",10);
        return dog;
    }

    public static void main(String[] args) {
        Animal animal = func2();
    }

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

在这里插入图片描述

如果父类想要调用子类特有的方法，就会报错。

重写

在这里插入图片描述

观察上述代码，我们发现父类和子类这两个方法：

  1. 方法名相同
  2. 参数列表相同[个数，类型，顺序]
  3. 返回值相同

那么此时这两个方法就构成了重写。

至于子类重写的方法上面的@Override，这个被称作为注解。他的作用就是**提示作用，**表示当前修饰的这个方法是被重写的。

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。

重写的注意事项：

  1. 不能是一个静态方法；

  2. 被final修饰的方法，不能被重写；【密封方法】

  3. 如果子类重写父类的方法，子类的权限要大于等于父类的权限；[public > protected > default ]

  4. 被private修饰的方法，是不能被重写的；

  5. 返回值构成父子类关系，也是重写；

    在这里插入图片描述

重载与重写的区别：

在这里插入图片描述

即：方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

动态绑定：

在这里插入图片描述

这段代码中，产生了向上转型：父类应用指向子类对象，而且上面也说了向上转型的缺点是父类引用不能调用子类的特有方法，那我引用变量animal调用的eat()因该是父类的eat方法，可为什么输出的却是调用了子类的eat方法？

那我们看一下这段代码是怎么编译的：

在这里插入图片描述

我们发现程序在编译的时候，确实调用的是父类的eat方法，但是当运行代码的时候，通过父类引用，调用了父类和子类重写的那个方法，结果实际调用了子类的方法，此时我们就把这种情况叫做动态绑定。

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。

而且动态绑定是理解多态的基础！

  1. 父类引用引用子类对象
  2. 通过父类引用，调用了父类和子类重写的那个方法。
    private static void func(Animal animal) {
        animal.eat();
    }
    
    public static void main(String[] args) {
        Dog dog = new Dog("旺财",10);
        func(dog);
        System.out.println("======");
        Bird bird = new Bird("小鸟",11);
        func(bird);
    }
    
    
    旺财正在吃狗粮...
		======
		小鸟正在吃鸟粮...

animal引用的对象不一样，但是**调用的是同一个方法，**此时表现出的现象不一样，此时这种思想，我们就叫做多态。

静态绑定与向下转型(了解即可)

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。

向下转型：

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换（需要强制类型转换）。

在这里插入图片描述

public static void main(String[] args) {
        Animal animal = new Bird("小鸟",11);//向上转型
        Bird bird = (Bird) animal;//向下转型
        bird.fly();
        System.out.println("===========");
        //但是也不是所有的向下转型都是可以成功的
        Animal animal1 = new Dog("旺财",10);
        Bird bird1 = (Bird) animal1;
        bird1.fly();
        //因为animal1实际指向的是狗，现在要强制还原成鸟，就无法正常还原！
    }
    
小鸟正在飞...
===========
Exception in thread "main" java.lang.ClassCastException: 
class Dog cannot be cast to class Bird (Dog and Bird are in unnamed module of loader 'app')

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。

public static void main(String[] args) {
        Animal animal = new Bird("小鸟",11);//向上转型
        Bird bird = (Bird) animal;//向下转型
        bird.fly();
        System.out.println("===========");
        //但是也不是所有的向下转型都是可以成功的
        Animal animal1 = new Dog("旺财",10);
        if(animal1 instanceof Bird){
            Bird bird1 = (Bird) animal1;
            bird1.fly();
        }
    }

多态实现条件

在java中要实现多态，必须要满足如下几个条件，缺一不可：

  1. 必须在继承体系下
  2. 子类必须要对父类中方法进行重写
  3. 通过父类的引用调用重写的方法

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

public class Animal {
    public String name;
    public int age;

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

    public void eat(){
        System.out.println(this.name + "正在吃饭...");
    }
}

public class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat(){
        System.out.println(this.name + "正在吃狗粮...");
    }
}

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

    @Override
    public void eat(){
        System.out.println(this.name + "正在吃鸟粮...");
    }
}

///////////////////////////////分割线//////////////////////////////////////////////

public class Test {
    private static void func(Animal animal) {
        animal.eat();
    }
    
    public static void main1(String[] args) {
        Dog dog = new Dog("旺财",10);
        func(dog);
        System.out.println("======");
        Bird bird = new Bird("小鸟",11);
        func(bird);
    }
}

运行结果：
旺财正在吃狗粮...
======
小鸟正在吃鸟粮...

在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者 编写的.

当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的animal 引用指向的是哪个类型(哪个子类)的实例. 此时 animal这个引用调用 eat方法可能会有多种不同的表现(和 animal 引用的实例相关), 这种行为就称为 多态。

多态的优缺点：

public class Shape {
    public void draw(){
        System.out.println("画图形");
    }
}
public class Rect extends Shape {
    public void draw(){
        System.out.println("矩形");
    }
}
public class Cycle extends Shape{
    public void draw(){
        System.out.println("圆形");
    }
}
public class Flower extends Shape{
    public void draw(){
        System.out.println("❀");
    }
}

我们假设上面的三个子类代表服务器接收请求触发的三种不同情况：再没学多态之前，我们可能会用if-else来处理：

public static void main(String[] args) {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();

        String[] strings = {"cycle","rect","cycle","rect","flower","cycle"};//代表从客户端拿来的请求

        for(String s: strings){
            if (s.equals("cycle")){
                cycle.draw();
            } else if (s.equals("rect")) {
                rect.draw();
            }else {
                flower.draw();
            }
        }
    }

再我们学完多态之后，就可以简化代码了：

public static void main(String[] args) {
        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();

        Shape[] shapes = {cycle,cycle,rect,flower,rect};
        for (Shape shape:shapes){
            shape.draw();
        }
    }

【使用多态的好处】

  1. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else

什么叫 “圈复杂度” ?
圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂.
因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数，这个个数就称为 “圈复杂度”。如果一个方法的圈复杂度太高, 就需要考虑重构，不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10。

  1. 可扩展能力更强

如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.

对于类的调用者来说, 只要创建一个新类的实例就可以了, 改动成本很低.
而对于不用多态的情况, 就要把for循环中的 if - else 进行一定的修改, 改动成本更高。

多态缺陷：代码的运行效率降低。

  1. 属性没有多态性

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

  1. 构造方法没有多态性
class B{
    public B(){
        func();
    }

    public void func() {
        System.out.println("B.func()");
    }
}

class D extends B{
    private int num = 1;

    public void func(){
        System.out.println("D.func()" + num);
    }
}

public class Test {
    public static void main(String[] args) {
        D d = new D();
    }
}

对于上述代码两个问题：

  1. 输出结果是什么？

    在这里插入图片描述

    输出结果：D.func()0

  2. 子类D的func方法中num此时的值为什么是0？

    在继承那篇博客我们讨论了初始化，我们知道先执行父类的静态，在执行子类的静态，在执行父类的实例，在执行父类的构造，在执行子类的实例，最后执行子类的构造。

    上面那个图画出了代码的执行过程，能明显的发现 private int num = 1; 这行代码就没有执行到，所以num就默认是0 了。

Reggie_L
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值