Java编程：面向对象编程原则及实际应用案例

原创快来打我* 2024-10-23 15:54 48阅读 0赞

面向对象编程（Object-Oriented Programming, OOP）是现代编程的重要方式，它主要基于四个核心原则：

1. 封装（Encapsulation）：将数据和操作这些数据的函数封装在一起，对外部隐藏实现细节。

```java
class Car {
    private String brand;
    private int year;

// 构造器，初始化对象
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

// 获取品牌
    public String getBrand() {
        return brand;
    }

// 设置年份
    public void setYear(int year) {
        this.year = year;
    }
}
```

2. 继承（Inheritance）：子类可以从父类继承属性和方法，形成代码的重用。

```java
class SportsCar extends Car {
    private int speedLimit;

// 构造器，初始化子类对象
    public SportsCar(String brand, int year, int speedLimit) {
        super(brand, year);
        this.speedLimit = speedLimit;
    }

// 设置速度限制
    public void setSpeedLimit(int speedLimit) {
        this.speedLimit = speedLimit;
    }

// 输出当前汽车信息，包括继承的属性
    @Override
    public String toString() {
        return "SportsCar {" +
                "brand='" + getBrand() + '\'' +
                ", year=" + year +
                ", speedLimit=" + speedLimit +
                "}"; 
    }
}
```

3. 多态（Polymorphism）：允许不同的对象对同一个消息做出响应。

```java
public class Main {
    public static void main(String[] args) {
        Car car1 = new Car("Toyota", 2020));
        Car car2 = new SportsCar("Ferrari", 2023, 300));

// 多态示例：不同类型的对象对同一个方法响应
        car1.setYear(2025); // 调用Car类的方法
        System.out.println(car1.toString()); // 输出结果

car2.setSpeedLimit(400); // 调用SportsCar类的方法
        System.out.println(car2.toString()); // 输出结果
    }
}
```

4. 封装-继承-多态的原理（The Law of Encapsulation, Inheritance, and Polymorphism）：

- 保护数据不受外部干扰。
- 提高代码的复用性和可维护性。
- 增强系统灵活性和适应新需求的能力。