【Java】多态

原创已于 2025-09-12 23:08:25 修改 · 607 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2025-09-12 23:04:10 首次发布

前言

在 Java 面向对象编程的三大支柱 —— 封装、继承、多态中，多态无疑是最具 “灵活性” 与 “智慧感” 的存在。它如同现实世界中 “同一行为在不同场景下的多样表现”，让代码摆脱了僵化的绑定，呈现出更贴近生活逻辑的动态特性。

1.多态

顾名思义多态，就是多种态度，哈哈哈开玩笑的，在Java中的概念就是不同的对象调用同一个方法，会产生不同的状态。多态的核心思想是：父类引用可以指向子类对象，并且通过这个引用调用方法时，会执行子类重写后的方法（而非父类的方法）。所以说在多态中，只需要弄懂两个概念就可以理解多态，即向上转型和方法的重写。

2.向上转型

父类的引用引用了子类的对象

2.1向上转型的实现方式

向上转型的实现方式一共有三种，直接赋值，方法的传参，返回值

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

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

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


class Aminal {
    public String name;
    public int age;

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

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

    @Override
    public String toString() {
        return "Aminal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Text {

    public static Aminal show1(){
        return new Dog("小夏",21);
    }

    public static void show(Aminal aminal){
        System.out.println(aminal.toString());
    }

    public static void main(String[] args) {
        Aminal aminal = new Dog("旺财", 18);//直接赋值
        System.out.println(aminal.toString());

        show(new Dog("小黄",19));//方法的传参

        Aminal aminal1 = show1();//通过返回值
        System.out.println(aminal1.toString());

    }
}

在这里插入图片描述

注：

如果子类中的方法，父类没有重写的话，通过父类的引用只能调用自己独特的方法，无法调用子类的方法.
向上转型后，若子类重写了父类的方法，通过父类引用调用该方法时，实际执行的是子类重写后的版本（多态的核心体现）。
与方法不同，属性不具备多态性。向上转型后，通过父类引用访问的属性一定是父类中声明的属性，而非子类的同名属性。

3.方法的重写

特点:

方法名相同。
参数列表相同(数量，类型，顺序)。
返回值可以不一样，但是两者的返回值必须构成父子关系，除此情况之外，必须一样，否则报错。

3.1 动态绑定

上面那串代码中写了两个重写的方法，eat和toString，在构成向上转型的时候，如果调用的方法是重写的方法，那么在调用该方法的时候，会调用父类的方法，但是实际上是执行子类方法的，这种情况就叫做动态绑定

注：

不能被static所修饰，因为静态的方法是属于类的，不依赖于对象，向上转型后调用的是父类的静态方法
不能被final所修饰，被 final 修饰的方法无法被重写，向上转型后调用的是父类的 final 方法。
重写的时候，子类的限定修饰符必须大于等于父类，否测不能被调用，所以被private修饰的方法，无法被重写。

3.2 静态绑定

典型代表就是重载，在编译的时候，根据用户所传递的实参类型就确定了调用哪个方法。

3.2 向下转型

向下转型是有风险的，因为需要进行强转。如果父类引用指向的是其他类型的对象，强行向下转型会抛出 ClassCastException(类型转换异常)。为了避免 ClassCastException，转型前应使用 instanceof 运算符判断父类引用指向的对象是否为目标子类类型。

public class Text{
    public static void main(String[] args) {
        Aminal aminal = new Dog("小黄",21);
        Aminal aminal = new Cat("小雪",23);
        if (animal instanceof Dog) {
       		 Dog dog = (Dog)aminal;
		} else {
		    System.out.println("无法转换为Dog类型");
		}
    }
}