Java 对象多态

Java 对象多态是一种重要的面向对象编程概念，它允许我们使用父类类型的变量来引用子类对象，从而实现代码的复用和扩展。在本文中，我们将探讨 Java 对象多态的定义、特点、使用场景以及示例代码。

对象多态的定义

对象多态是指，在面向对象编程中，一个对象可以被看作是多种类型的实例。具体来说，如果一个类 A 是另一个类 B 的子类，那么类 A 的对象可以被当作类 B 的对象来使用。换句话说，父类类型的变量可以引用子类对象，从而实现多态性。

以下是一个对象多态的示例代码：

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("Dog is eating.");
    }
    
    public void bark() {
        System.out.println("Dog is barking.");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("Cat is eating.");
    }
    
    public void meow() {
        System.out.println("Cat is meowing.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        
        animal1.eat();
        animal2.eat();
        
        // animal1.bark(); // 编译错误，Animal 类型没有 bark 方法
        // animal2.meow(); // 编译错误，Animal 类型没有 meow 方法
        
        Dog dog = (Dog) animal1;
        dog.bark();
        
        Cat cat = (Cat) animal2;
        cat.meow();
    }
}

在这个示例中，我们定义了一个 Animal 类和两个子类 Dog 和 Cat。Animal 类中有一个 eat 方法，而 Dog 和 Cat 类分别重写了这个方法，并添加了 bark 和 meow 方法。

在主函数中，我们创建了两个 Animal 类型的变量 animal1 和 animal2，分别引用了一个 Dog 对象和一个 Cat 对象。然后，我们调用了它们的 eat 方法，可以看到，它们分别调用了 Dog 和 Cat 类中的 eat 方法。

接下来，我们试图调用 animal1 和 animal2 中没有的方法 bark 和 meow，但是编译器会报错，因为 Animal 类型并没有这些方法。为了调用这些方法，我们需要将 animal1 和 animal2 强制转换为 Dog 和 Cat 类型。

最后，我们可以看到，通过对象多态和强制类型转换，我们成功地调用了 Dog 和 Cat 类型的方法 bark 和 meow。

对象多态的特点

对象多态有以下几个特点：

1. 对象多态只适用于继承关系。只有当一个类是另一个类的子类时，才能使用对象多态。

2. 父类类型的变量可以引用子类对象。因为子类对象具有父类对象的所有属性和方法，所以可以用父类类型的变量来引用子类对象。

3. 对象多态只能调用父类类型中的方法。因为变量的类型是父类类型，所以只能调用父类类型中定义的方法，而不能调用子类类型中定义的方法。

4. 子类对象可以转换为父类对象。因为子类对象包含了父类对象的所有属性和方法，所以可以将子类对象转换为父类对象。

5. 父类对象不能转换为子类对象。因为父类对象不包含子类对象的所有属性和方法，所以无法将父类对象转换为子类对象。

对象多态的使用场景

对象多态通常用于以下几个场景：

1. 实现代码的复用和扩展。通过对象多态，可以使用父类类型的变量来引用子类对象，从而实现代码的复用和扩展。

2. 实现多态性。通过对象多态，可以实现多态性，即同一方法可以根据不同的对象调用不同的方法实现。

3. 实现接口的多态性。接口也可以用于实现多态性，通过接口类型的变量来引用实现了该接口的类对象，从而实现不同类对象的多态性。

4. 实现参数的多态性。通过将参数类型定义为父类类型，可以实现方法的多态性，即同一方法可以接受不同的参数类型。

5. 实现泛型的多态性。通过泛型，可以定义一种通用的类型，在运行时再确定具体的类型，从而实现泛型的多态性。

对象多态的示例代码

以下是一个对象多态的示例代码，它定义了一个 Shape 类和两个子类 Circle 和 Rectangle：

abstract class Shape {
    public abstract void draw();
}

class Circle extends Shape {
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

class Rectangle extends Shape {
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        
        shape1.draw();
        shape2.draw();
    }
}

在这个示例中，我们定义了一个 Shape 类和两个子类 Circle 和 Rectangle。Shape 类是一个抽象类，它有一个抽象方法 draw。Circle 和 Rectangle 类分别继承了 Shape 类，并重写了 draw 方法。

在主函数中，我们创建了两个 Shape 类型的变量 shape1 和 shape2，分别引用了一个 Circle 对象和一个 Rectangle 对象。然后，我们调用了它们的 draw 方法，可以看到，它们分别调用了 Circle 和 Rectangle 类中的 draw 方法。

这个示例说明了对象多态的使用方法，通过父类类型的变量来引用子类对象，并调用子类对象的方法，实现了代码的复用和扩展。