OOP三大核心特征

封装

封装是面向对象编程（OOP）的三大核心特性之一（另外两个是继承和多态），它是隐藏对象内部细节，对外提供公共访问接口的一种设计原则。封装的主要目的是提高代码的可维护性、降低耦合度、增强数据的安全性和保护性。以下是封装的几个关键要点：

1. 数据隐藏（Encapsulation of Data）

私有化成员变量：将类的内部数据（如属性、状态）声明为私有（private），使得外部代码无法直接访问这些数据。这样做可以防止数据被随意修改，确保数据的一致性和完整性。
提供访问器（Getter）和修改器（Setter）方法：为了能让外部代码在必要时能够读取或更新私有数据，类通常会提供相应的公共方法（public）。访问器（getter）返回私有变量的值，修改器（setter）允许设置私有变量的新值。这样，类可以控制对数据的访问方式，如添加校验、触发事件通知等。

public class BankAccount {
    // 私有属性：存款金额（数据隐藏）
    private double balance;

    // 构造函数：初始化账户余额
    public BankAccount(double initialBalance) {
        if (initialBalance >= 0) {
            balance = initialBalance;
        } else {
            throw new IllegalArgumentException("Initial balance must be non-negative.");
        }
    }

    // 公开方法：获取账户余额（只读访问）
    public double getBalance() {
        return balance;
    }

    // 公开方法：存入指定金额
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited " + amount + ". New balance: " + balance);
        } else {
            throw new IllegalArgumentException("Deposit amount must be positive.");
        }
    }

    // 公开方法：取出指定金额
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrew " + amount + ". New balance: " + balance);
        } else {
            throw new IllegalArgumentException("Invalid withdrawal amount.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建BankAccount对象实例
        BankAccount account = new BankAccount(1000);

        // 通过公开方法访问和修改账户余额
        System.out.println("Initial balance: " + account.getBalance());

        account.deposit(500); // 存入500元
        account.withdraw(300); // 取出300元

        System.out.println("Final balance: " + account.getBalance());
    }
}

 在这个例子中，BankAccount类封装了balance属性，将其声明为private，确保外部代码无法直接访问或修改。类提供了以下公共方法：
getBalance(): 返回当前账户余额，实现了只读访问，允许外部查看账户状态但不能直接修改。
deposit(double amount): 存入指定金额到账户，方法内部负责更新balance值，并进行有效性的检查（如确保金额为正数）。
withdraw(double amount): 从账户中取出指定金额，同样在方法内部更新balance值，并进行有效性检查（如确保金额为正数且不超过当前余额）。
通过这种方式，外部代码只能通过BankAccount类提供的公开方法来与对象交互，无法直接访问或修改balance属性，实现了数据隐藏，提高了代码的健壮性和安全性。

public class Temperature {
    // 私有属性：温度值（单位：摄氏度）
    private double value;

    // 构造函数：初始化温度值
    public Temperature(double initialValue) {
        value = initialValue;
    }

    // 公开方法：获取温度值
    public double getValue() {
        return value;
    }

    // 公开方法：设置新的温度值（仅限合法范围）
    public void setValue(double newValue) {
        if (newValue >= -273.15 && newValue <= 1000.0) { // 假设限制温度在绝对零度至1000℃之间
            value = newValue;
        } else {
            throw new IllegalArgumentException("Temperature out of valid range.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建Temperature对象实例
        Temperature temp = new Temperature(25.0);

        // 通过公开方法访问和修改温度值
        System.out.println("Initial temperature: " + temp.getValue());

        temp.setValue(30.0); // 设置新的温度值

        System.out.println("Updated temperature: " + temp.getValue());
    }
}

 

2. 封装行为（Encapsulation of Behavior）

除了数据，类还应封装相关的操作（方法）。这些方法可以对内部数据进行处理，对外提供服务。将行为封装在类中，有助于保持代码的模块化，使类成为具有完整功能的单元，易于理解和复用。

3. 信息隐藏（Information Hiding）

封装不仅限于隐藏数据细节，还包括隐藏实现细节。类的内部实现可以随时改变，只要保持对外提供的公共接口不变，就不会影响到使用该类的客户端代码。这种隔离变化的能力增强了系统的灵活性和可维护性。

4. 建立清晰的边界（Defining Clear Boundaries）

封装使类成为具有明确职责和接口的独立单元，明确了类与类之间的交互方式。这样，每个类只需关注自身的功能实现，降低了类之间的耦合度，有利于大型软件项目的开发和维护。
综上所述，封装是通过将数据和行为打包到类中，并通过公共接口控制对这些数据和行为的访问，从而实现对内部细节的隐藏，提高代码的模块化、安全性和可维护性。封装是构建良好面向对象设计的基础。

---

继承 

继承是面向对象编程（OOP）中的一个重要概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类、基类或超类）的属性和行为，从而实现代码的复用、层次化结构和多态性。

继承是一种创建新类的方式，新创建的类（子类）继承了现有类（父类）的所有属性（成员变量）和行为（方法），并可以添加新的属性、方法或覆盖（override）父类的方法。通过继承，子类不仅拥有父类的所有功能，还可以根据需要扩展或定制特定功能，而不必从头开始编写所有代码。

继承的关键特征

1. 继承关系：通过关键字（如Java中的extends，C++中的:）明确指定子类与父类之间的继承关系。
2. 继承属性：子类自动获得父类的所有非私有（如protected、public）属性，这些属性在子类中可以直接使用。
3. 继承方法：子类继承父类的所有非私有方法。子类可以直接调用父类的非私有方法，也可以通过覆盖（override）父类方法来提供定制实现。
4. 方法重写（Override）：子类可以定义与父类同名、同参数列表、同返回类型的方法，称为重写。在子类对象上调用重写的方法时，将执行子类的实现，而非父类的实现。
5. 多态性：继承是实现多态性的基础。通过继承，子类对象可以被当作父类对象对待，即父类引用可以指向子类对象。当父类引用调用被子类重写的方法时，实际执行的是子类的实现，体现了“一个接口，多种实现”的多态性。
6. 构造函数：子类不会继承父类的构造函数。子类必须提供自己的构造函数，并可以选择在构造函数中使用super()语句调用父类的构造函数，以初始化继承自父类的属性。
7. 访问权限：
   私有（Private）：子类无法直接访问父类的私有成员，但可以通过父类提供的公共或受保护方法间接访问。
   受保护（Protected）：子类可以访问父类的受保护成员，但外部类不能直接访问。
   公共（Public）：子类和所有其他类都可以直接访问父类的继承的注意事项公共成员。

继承的注意事项

• 过度继承：过多的继承层级或不必要的继承可能导致代码复杂、难以理解，应谨慎使用继承，优先考虑组合或接口实现多态。
• 菱形继承问题（钻石问题）：在某些语言（如C++）中，多重继承可能导致子类通过不同的路径继承到同一祖先类的多个副本，引发二义性问题。为解决此问题，可使用虚拟继承（C++）或接口（Java）等技术。 

---

多态

多态允许不同类的对象对同一消息（方法调用）做出不同的响应。多态使得程序在运行时能够根据对象的实际类型来决定所调用的方法，从而实现代码的通用性、灵活性和扩展性。

多态是指一个接口（可以是接口、抽象类或普通类的公共方法）在不同上下文中表现出不同的实现行为。具体表现为：
编译时多态（静态多态）：通过函数重载（Overloading）或运算符重载实现，编译时就能确定调用哪个函数。取决于函数签名（参数列表、返回类型等）的差异。
运行时多态（动态多态）：通过虚函数、接口实现、方法重写（Override）等机制实现，只有在运行时才能确定调用哪个方法。取决于对象的实际类型（动态绑定）。

实现方式

方法重写（Override）：

在继承体系中，子类可以定义与父类同名、同参数列表、同返回类型的方法。当父类引用指向子类对象并调用该方法时，实际执行的是子类的实现，实现了运行时多态。

   class Animal {
       void makeSound() { System.out.println("Generic animal sound"); }
   }

   class Dog extends Animal {
       @Override
       void makeSound() { System.out.println("Woof!"); }
   }

   Animal animal = new Dog();  // 父类引用指向子类对象
   animal.makeSound();  // 输出 "Woof!"，动态绑定到Dog类的makeSound方法
   

接口实现：

类可以实现一个或多个接口，提供接口中定义的方法的具体实现。接口引用可以指向任何实现了该接口的对象，当调用接口方法时，实际执行的是对象所属类的实现。

   interface Shape {
       void draw();
   }

   class Circle implements Shape {
       @Override
   void draw() { System.out.println("Drawing a circle."); }
   }

   class Square implements Shape {
       @Override
       void draw() { System.out.println("Drawing a square."); }
   }

   Shape shape = new Circle();  // 接口引用指向Circle对象
   shape.draw();  // 输出 "Drawing a circle."，动态绑定到Circle类的draw方法
   

虚函数（Virtual Functions）（C++）：

在C++中，通过在基类中声明虚函数并在派生类中重写，可以实现运行时多态。使用virtual关键字标记虚函数，基类指针或引用可以调用到派生类的虚函数实现

   class Base {
   public:
       virtual void print() { cout << "Base class"; }
   };

   class Derived : public Base {
   public:
       void print() override { cout << "Derived class"; }
   };

   Base* basePtr = new Derived();
   basePtr->print();  // 输出 "Derived class"，动态绑定到Derived类的print方法
   

多态的优点

• 代码复用：通过基类或接口定义通用的操作接口，各子类或实现类只需关注自己的特有实现，简化代码结构。
• 灵活性与扩展性：无需修改原有代码即可添加新的子类或实现类，只需确保它们遵循相同的接口约定，即可无缝融入系统。
• 抽象化与解耦：多态使得代码关注接口而非实现细节，降低模块间的耦合度，便于维护和升级。

多态的关键要素

• 继承或接口：多态通常依赖于继承或接口实现，形成类型层次结构或实现集合。
• 方法重写或接口方法实现：子类或实现类提供与基类或接口方法同名、同签名的方法，覆盖默认行为。
• 父类引用或接口引用：通过父类引用或接口引用指向子类对象，调用方法时根据对象的实际类型动态绑定。
  
   

总结来说，多态是面向对象编程中的一种重要机制，它使得不同类的对象能够对相同的消息（方法调用）做出不同的响应，实现了代码的通用性、灵活性和扩展性。多态主要通过方法重写、接口实现和虚函数等技术实现，并在面向对象系统中发挥着重要作用。