Java 面向对象编程 (OOP)

面向对象编程 (Object-Oriented Programming, OOP) 是一种编程范式，它使用“对象”来设计软件和应用程序。它通过将数据（属性）和操作数据的行为（方法）捆绑在一起，来模拟现实世界中的实体。Java 是一种纯粹的面向对象语言，其所有代码都必须存在于类中。

OOP 的核心思想主要围绕四大基本原则：

1. 封装 (Encapsulation)
2. 继承 (Inheritance)
3. 多态 (Polymorphism)
4. 抽象 (Abstraction)

1. 封装 (Encapsulation)

封装是指将对象的数据（属性）和操作数据的代码（方法）捆绑在一个独立的单元（即“类”）中。它还实现了数据隐藏，即限制外部对对象内部数据的直接访问。

在 Java 中，通常通过以下方式实现封装：

• 将类的属性声明为 private，这样它们就不能被外部类直接访问。
• 提供 public 的 getter 和 setter 方法来读取和修改这些私有属性。这允许我们在修改数据时加入控制逻辑（如验证）。

public class Person {
    // 1. 私有化属性
    private String name;
    private int age;

    // 2. 提供 public 的 getter 方法以访问数据
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 3. 提供 public 的 setter 方法以修改数据，并加入控制逻辑
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age > 0 && age < 150) { // 数据验证
            this.age = age;
        } else {
            System.out.println("无效的年龄值！");
        }
    }
}

// 在其他类中
Person person = new Person();
// person.name = "张三"; // 编译错误！不能直接访问私有属性
person.setName("张三");
person.setAge(30);
System.out.println("姓名: " + person.getName());

优点:

• 安全性: 保护数据不被意外或恶意修改。
• 灵活性: 类的内部实现可以自由修改，而不会影响到使用该类的外部代码。
• 可维护性: 代码更易于理解和维护。

2. 继承 (Inheritance)

继承是一种机制，允许一个类（称为子类或派生类）获取另一个类（称为父类或基类）的属性和方法。子类可以重用父类的代码，并且可以添加自己的新功能或重写父类的方法。

在 Java 中，使用 extends 关键字来实现继承。

// 父类
class Animal {
    public void eat() {
        System.out.println("这个动物在吃东西...");
    }
}

// 子类 Dog 继承自 Animal
class Dog extends Animal {
    public void bark() {
        System.out.println("狗狗在汪汪叫！");
    }
}

// 使用
Dog myDog = new Dog();
myDog.eat();  // 调用从父类继承来的方法
myDog.bark(); // 调用子类自己的方法

优点:

• 代码重用: 避免了代码冗余。
• 结构清晰: 建立了类之间的“is-a”（是一个）关系，符合现实世界的逻辑。

3. 多态 (Polymorphism)

多态（字面意思是“多种形态”）允许我们以统一的方式处理不同类型的对象。它指的是一个父类引用可以指向其任何一个子类的对象，并且在调用同一个方法时，会根据对象的实际类型执行不同的行为。

多态的实现通常需要两个条件：

1. 继承: 必须存在继承关系。
2. 方法重写 (Method Overriding): 子类重新定义了父类中的同名方法。

class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override // 注解表示这是方法重写
    public void makeSound() {
        System.out.println("汪汪！");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵！");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal; // 父类引用

        myAnimal = new Dog(); // 指向 Dog 对象
        myAnimal.makeSound();   // 执行 Dog 类的 makeSound() -> 输出: 汪汪！

        myAnimal = new Cat(); // 指向 Cat 对象
        myAnimal.makeSound();   // 执行 Cat 类的 makeSound() -> 输出: 喵喵！
    }
}

优点:

• 灵活性和可扩展性: 可以轻松地添加新的子类，而无需修改处理这些对象的现有代码。

4. 抽象 (Abstraction)

抽象是指隐藏复杂的实现细节，只向用户展示必要的功能。它帮助我们管理复杂性。

在 Java 中，抽象可以通过抽象类 (Abstract Class) 和接口 (Interface) 来实现。

• 抽象类: 一个不能被实例化的类，它可能包含抽象方法（没有方法体的方法）。它作为其他类的基类，强制子类实现其抽象方法。
• 接口: 一个完全抽象的“类”，它只包含抽象方法和常量。一个类可以实现多个接口，从而获得多种行为能力。

// 抽象类
abstract class Shape {
    // 抽象方法，没有方法体
    public abstract double getArea();

    public void printInfo() {
        System.out.println("这是一个形状。");
    }
}

class Circle extends Shape {
    private double radius;
    // ... 构造方法 ...

    // 必须实现父类的抽象方法
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

我们将在后续章节中更详细地探讨继承、抽象类和接口。