从实例分析Java中的多态性及其常见陷阱

原创刺骨的言语ヽ痛彻心扉 2024-12-09 13:03 8阅读 0赞

多态性是面向对象编程（OOP）的一个核心特性，它允许不同类型的对象对同一消息做出响应。

以Java中的多态性为例：

1. 继承：子类继承父类的属性和方法，这样就实现了父类对子类的多态。

```java
class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.sound(); // 输出 "Dog barks"
    }
}
```

2. 接口：除了继承，接口也可以实现多态。

```java
interface Soundable {
    void makeSound();
}

class Dog implements Soundable {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Soundable mySoundable = new Dog();
        mySoundable.makeSound(); // 输出 "Dog barks"
    }
}
```

常见陷阱：

1. 对父类方法的覆盖：如果子类重写了父类的方法，那么在父类对象上调用这个方法时，会调用子类重写的方法。

```java
class Parent {
    void method() {
        System.out.println("Parent's method");
    }
}

class Child extends Parent {
    @Override
    void method() {
        System.out.println("Child's overridden method");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent parent = new Child();
        parent.method(); // 输出 "Child's overridden method"
    }
}
```

2. 对继承实现的不理解：子类继承了父类的所有属性和方法，但是默认行为是通过对象调用方法来体现的。如果想要改变这个默认行为，通常需要重写（Override）或者覆盖（Overload）。

以上就是Java中多态性及其常见陷阱的理解分析。