面向对象编程原则在Java中的应用案例

原创古城微笑少年丶 2024-10-23 06:48 49阅读 0赞

面向对象编程（Object-Oriented Programming，OOP）有四个主要原则，在Java中体现得尤为明显。这些原则包括：

1. 封装（Encapsulation）：将数据和操作数据的方法打包在一起。
2. 继承（Inheritance）：让一个类（子类）继承另一个类（父类）的属性和方法。
3. 多态（Polymorphism）：同一个名称在不同的上下文中，可以被不同的对象调用。
4. 抽象（Abstraction）：通过定义接口来隐藏实现细节。

以下是一些Java应用案例：

1. 封装：
```java
class BankAccount {
    private double balance;

// Getter and Setter
    public double getBalance() {
        return balance;
    }

public void setBalance(double balance) {
        this.balance = balance;
    }
}
```
2. 继承：
```java
class Animal {
    // Base class functionality
}

class Dog extends Animal {
    // Specific dog behavior
}
```
3. 多态（在方法调用上）：
```java
interface AnimalSound {
    void makeSound();
}

class Dog implements AnimalSound {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        AnimalSound dogSounds = new Dog();

// 多态: 调用方法时不需要显式类型转换
        dogSounds.makeSound();
    }
}
```
4. 抽象（抽象类）：
```java
abstract class Shape {
    abstract double getPerimeter();
    abstract double getArea();
}

class Circle extends Shape {
    private double radius;

// Constructor and Getter-Setter for radius
    public Circle(double radius) {
        this.radius = radius;
    }

@Override
    double getPerimeter() {
        return 2 * Math.PI * radius;
    }

@Override
    double getArea() {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);

// 调用抽象方法，不需要显式类型转换
        System.out.println("Circle perimeter: " + circle.getPerimeter());
        System.out.println("Circle area: " + circle.getArea());
    }
}
```
以上案例展示了面向对象编程原则在Java中的应用。