Java 多态

1. 多态的概念

在面向对象编程中，多态（Polymorphism）是三大特性之一（另外两个是封装和继承）。多态的意思是同一个方法调用，依据实际对象

的不同而产生不同的行为。

简单来说，父类引用可以指向子类对象，通过调用方法时，根据实际对象的类型决定调用哪个方法实现，这就是多态，如图所示：

img

多态性是对象多种表现形式的体现。

现实中，比如我们按下 F1 键这个动作：

  • 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
  • 如果当前在 Word 下弹出的就是 Word 帮助；
  • 在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

实例

img

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Shape {
    void draw() {}
}
  
class Circle extends Shape {
    void draw() {
        System.out.println("Circle.draw()");
    }
}
  
class Square extends Shape {
    void draw() {
        System.out.println("Square.draw()");
    }
}
  
class Triangle extends Shape {
    void draw() {
        System.out.println("Triangle.draw()");
    }
}

下面是一份关于 Java 多态的详细教学内容，涵盖基本概念、原理以及代码示例，供你参考。

2. 多态的实现条件

Java 中实现多态需要满足以下几个条件：

  • 继承/实现关系： 子类继承父类或实现接口。
  • 方法重写（Override）： 子类对父类中的方法进行重写（覆盖）。
  • 父类引用指向子类对象： 如 Animal a = new Dog();。

3. 编译时与运行时

  • 编译时： 编译器只关注引用的静态类型（例如上面例子中 a 的类型是 Animal）。
  • 运行时： JVM 根据对象的实际类型（在本例中是 Dog）调用相应的重写方法，这种机制称为“动态绑定”或“运行时多态”。

4. 代码示例

以下是一个简单的例子，展示了如何利用多态调用子类方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 父类
class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类 Dog 重写了 sound 方法
class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

// 子类 Cat 重写了 sound 方法
class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        // 父类引用指向不同的子类对象
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // 根据对象的实际类型调用对应的 sound 方法
        myDog.sound(); // 输出：Dog barks
        myCat.sound(); // 输出：Cat meows
    }
}

在上述代码中，尽管 myDog 和 myCat 的引用类型都是 Animal，但是在调用 sound() 方法时，JVM 会根据实际的对象类型（分别是 Dog 和 Cat）调用各自的实现。

5. 多态的优点

  • 灵活性和扩展性： 通过父类引用调用子类的方法，可以轻松扩展系统。例如增加新的动物类型时，只需要继承 Animal 类并重写方法即可，无需修改调用代码。
  • 代码复用： 统一接口调用不同实现，提高代码复用性。
  • 解耦合： 利用接口和抽象类设计可以降低系统各部分之间的耦合度，方便维护和扩展。

6. 接口与多态

多态不仅适用于继承关系，还适用于接口。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
interface Shape {
    void draw();
}

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

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

public class TestInterfacePolymorphism {
    public static void main(String[] args) {
        Shape s1 = new Circle();
        Shape s2 = new Rectangle();
        
        s1.draw(); // 输出：Drawing a circle
        s2.draw(); // 输出：Drawing a rectangle
    }
}

通过接口引用指向实现类的对象，同样可以实现多态，使得代码设计更加灵活。

7. 注意事项

  • 动态绑定： 多态依赖于运行时的动态绑定机制。如果方法没有被重写（例如被声明为 static、private 或 final），则无法实现多态。
  • 类型转换： 在实际开发中，有时需要进行向下转型（cast）操作，此时需要使用 instanceof 关键字判断类型，避免类型转换异常。
  • 设计原则： 多态有助于实现“面向接口编程”，可以大大提高系统的可维护性和可扩展性。

总结

Java 多态是面向对象编程的重要特性，它允许同一父类引用在运行时表现出不同的行为。通过继承和方法重写实现多态，不仅让代码更加灵活和扩展性更好，也有助于开发大型和复杂系统时降低耦合度。掌握多态的原理和应用，将为你编写更高效、易维护的代码打下坚实基础。