面向对象编程（OOP）

OOP是基于对象的编程范式。在OOP中，数据和功能都被封装在对象中，对象之间通过消息传递进行交互。OOP的主要特点包括封装性、继承性、多态性和抽象性。

封装性：对象可以隐藏其内部状态和行为，只暴露必要的接口给外部。

继承性：创建具有层次结构的类，子类可以继承父类的属性和方法。

多态性：允许使用父类类型的引用来引用子类对象，并调用其方法。

抽象性：通过抽象类和接口来定义通用的行为，而不需要具体的实现。

// 父类 Animal  
class Animal {  
    private String name;  
  
    // 构造方法  
    public Animal(String name) {  
        this.name = name;  
    }  
  
    // 公共方法：获取名字  
    public String getName() {  
        return name;  
    }  
  
    // 公共方法：设置名字  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    // 公共方法：动物的行为（抽象方法）  
    public void makeSound() {  
        System.out.println("The animal makes a sound");  
    }  
}  
  
// 子类 Dog，继承自 Animal  
class Dog extends Animal {  
    // 构造方法  
    public Dog(String name) {  
        super(name); // 调用父类的构造方法  
    }  
  
    // 重写父类的 makeSound 方法  
    @Override  
    public void makeSound() {  
        System.out.println("The dog barks");  
    }  
}  
  
// 子类 Cat，继承自 Animal  
class Cat extends Animal {  
    // 构造方法  
    public Cat(String name) {  
        super(name); // 调用父类的构造方法  
    }  
  
    // 重写父类的 makeSound 方法  
    @Override  
    public void makeSound() {  
        System.out.println("The cat meows");  
    }  
}  
  
// 主类，用于测试 Animal、Dog 和 Cat  
public class Main {  
    public static void main(String[] args) {  
        // 创建 Animal 对象  
        Animal animal = new Animal("Generic Animal");  
        animal.makeSound(); // 调用父类方法  
  
        // 创建 Dog 对象  
        Dog dog = new Dog("Buddy");  
        dog.makeSound(); // 调用子类重写的方法  
  
        // 创建 Cat 对象  
        Cat cat = new Cat("Whiskers");  
        cat.makeSound(); // 调用子类重写的方法  
  
        // 多态示例：使用父类类型的引用来引用子类对象  
        Animal[] animals = {dog, cat};  
        for (Animal a : animals) {  
            a.makeSound(); // 调用各自子类的 makeSound 方法  
        }  
    }  
}