4.4 Java多态（对象类的转换、instanceof关键字、静态 、多态、向上转型、向下转型）

---

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

4.4.1 Java 多态概述

Java中的多态性（Polymorphism）是指允许不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同的对象以不同的方式实现。多态性分为两种：编译时多态（静态多态）和运行时多态（动态多态）。

编译时多态（静态多态）

编译时多态主要通过方法重载（Method Overloading）和运算符重载（Operator Overloading）实现。

• 方法重载：同一个类中有多个同名方法，但参数列表不同（参数的类型、数量或顺序不同）。
• 运算符重载：允许已有的运算符拥有不同的实现，使其可以对不同类型的数据执行运算。

运行时多态（动态多态）

运行时多态主要通过以下方式实现：

• 方法重写（Method Overriding）：子类重新定义父类的方法。
• 接口实现：类实现接口中的方法。

要实现运行时多态，需要满足以下条件：

1. 继承：必须存在继承关系。
2. 方法重写：子类必须重写父类的方法。
3. 向上转型（Upcasting）：子类对象需要被处理为父类类型。

代码案例

// 父类
class Animal {
   
    public void makeSound() {
   
        System.out.println("Some sound");
    }
}

// 子类
class Dog extends Animal {
   
    @Override
    public void makeSound() {
   
        System.out.println("Bark");
    }
}

public class TestPolymorphism {
   
    public static void main(String[] args) {
   
        Animal myAnimal = new Animal();
        Animal myDog = new Dog(); // 向上转型

        myAnimal.makeSound(); // 输出: Some sound
        myDog.makeSound(); // 输出: Bark

        // 动态绑定: 调用实际对象类型的makeSound方法
    }
}

在这个例子中，Animal是一个父类，Dog是继承自Animal的子类，并重写了makeSound方法。在TestPolymorphism类中，myDog对象实际上是Dog类型，但被声明为Animal类型。当调用myDog.makeSound()时，Java运行时会确定对象的实际类型并调用相应的方法，这就是动态多态。

流程图

下面是描述上述代码案例的流程图：

graph TD;
    A[开始] --> B[定义Animal类]
    B --> C{Animal类}
    C --> D[定义makeSound方法]
    D --> E[输出: Some sound]
    B --> F[定义Dog类]
    F --> G{Dog类}
    G --> H[继承自Animal]
    G --> I[重写makeSound方法]
    I --> J[输出: Bark]
    F --> K[结束Dog类定义]
    K --> L[在TestPolymorphism类中]
    L --> M[创建Animal对象myAnimal]
    L --> N[创建Dog对象myDog]
    N --> O[向上转型为Animal类型]
    M --> P[调用myAnimal.makeSound()]
    P --> Q[输出: Some sound]
    N --> R[调用myDog.makeSound()]
    R --> S[动态绑定调用Dog的makeSound]
    S --> T[输出: Bark]
    T --> U[结束]

说明

1. 定义Animal类：首先定义一个Animal类，它有一个makeSound方法。
2. 定义Dog类：然后定义一个Dog类，它继承自Animal类并重写了makeSound方法。
3. 向上转型：在TestPolymorphism类中，创建一个Dog对象并将其赋值给Animal类型的对象。
4. 动态绑定：调用myDog.makeSound()时，Java运行时会根据对象的实际类型调用Dog的makeSound方法。

多态性是面向对象编程的核心概念之一，它提供了极大的灵活性，允许将子类对象当作父类对象来处理，同时在运行时确定具体调用哪个类的方法。

4.4.2 Java 对象类的转换

在Java中，对象之间的转换通常涉及向上转型（Upcasting）和向下转型（Downcasting）。这两种转换是多态性的重要组成部分。

向上转型（Upcasting）

向上转型是指将子类对象赋值给父类引用。这种转换是隐式的，不需要进行任何特殊操作，因为子类对象是父类的一种“特殊”形式。

代码案例：

class Animal {
   
    public void makeSound() {
   
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
   
    @Override
    public void makeSound() {
   
        System.out.println("Bark");
    }
}

public class TestUpcasting {
   
    public static void main(String[] args) {
   
        Animal myAnimal = new Animal();
        Animal myDog = new Dog(); // 向上转型

        myAnimal.makeSound(); // 输出: Some sound
        myDog.makeSound(); // 输出: Bark
    }
}

在这个例子中，Dog对象被赋值给Animal类型的引用myDog，这是向上转型。

向下转型（Downcasting）

向下转型是指将父类对象赋值给子类引用。这种转换是显式的，需要进行强制类型转换。

代码案例：

class Animal {
   
    public void makeSound() {
   
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
   
    @Override
    public void makeSound() {
   
        System.out.println("Bark");
    }
    
    public void barkLoudly() {
   
        System.out.println("Bark loudly!");
    }
}

public class TestDowncasting {
   
    public static void main(String[] args) {
   
        Animal myAnimal = new Animal();
        Dog myDog = new Dog();

        Animal myBeagle = myDog; // 向上转型
        Dog myBeagleDowncasted = (Dog) myBeagle; // 向下转型

        myBeagleDowncasted.barkLoudly(); // 输出: Bark loudly!
    }
}

在这个例子中，myBeagle是Animal类型的引用