面向对象编程疑惑：Java OOP中的抽象、继承和多态等概念实例

原创你的名字 2024-10-23 09:33 55阅读 0赞

在Java的面向对象编程（OOP）中，抽象、继承和多态是三个核心概念。以下为每个概念的实例：

1. 抽象（Abstract Class）

抽象类不能被实例化，它通常包含一个或多个抽象方法。

```java
// 抽象类
abstract class Animal {
    abstract void speak();
}

// 实现抽象方法的对象
class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Woof!");
    }
}

// 创建对象并调用方法
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.speak(); // 输出 "Woof!"
    }
}
```

2. 继承（Inheritance）

继承使得子类可以拥有父类的属性和方法，同时还可以添加新的属性和方法。

```java
// 父类
class Animal {
    // 属性
    private String name;

// 构造函数
    public Animal(String name) {
        this.name = name;
    }

// 父类方法
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

// 子类
class Dog extends Animal {
    // 添加子类特有的属性和方法

// 重写父类方法
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
        super.eat(); // 调用父类方法
    }
}

// 使用示例
public class Main2 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 输出 "Dog is eating." 和 "Animal is eating."
    }
}
```

3. 多态（Polymorphism）

多态是指一个接口（抽象类）可以被不同的子类实现，从而展现出多种行为。

```java
// 具体类1（实现方法1）
class Dog1 extends Animal {
    @Override
    public void speak() {
        System.out.println("Dog 1's bark.");
    }
}

// 具体类2（实现方法2）
class Dog2 extends Animal {
    @Override
    public void speak() {
        System.out.println("Dog 2's barks with a whine.");
    }
}

// 主程序演示多态
public class Main3 {
    public static void main(String[] args) {
        // 创建Dog1和Dog2的引用
        Animal dog1 = new Dog1();
        Animal dog2 = new Dog2();

// 多态调用方法
        dog1.speak(); // 输出 "Dog 1's bark."
        dog2.speak(); // 输出 "Dog 2's barks with a whine."
    }
}
```

以上就是Java OOP中抽象、继承和多态等概念的实例。