面向对象编程（Object-Oriented Programming，简称 OOP）是一种基于"对象"概念的编程范式。在面向对象编程中，程序由各种对象组成，每个对象都包含各种数据和方法，用来模拟现实世界中的事物和交互。
面向对象编程以对象为中心，将数据和操作数据的方法封装在一起，强调数据的封装、继承和多态。
+-------------------+
| Class |
| (Attributes, Methods) |
+-------------------+
|
| (Inheritance, Polymorphism)
v
+-------------------+
| Sub - Class |
| (Extended Attributes, Methods) |
+-------------------+
提高代码的可维护性
- 模块化设计：在面向对象编程中，程序被分解为多个独立的模块和对象，每个对象都有自己明确的职责。模块化的设计使得代码结构清晰，当需要修改某个功能时，只需要关注对应的对象，而不会影响到其他无关的部分。
- 信息隐藏与封装：封装是面向对象编程的重要特性之一，它将对象的内部数据和实现细节隐藏起来，只对外提供必要的接口。这样减少因误操作而导致的错误，提高了代码的安全性和可维护性。
增强代码的可扩展性
- 继承机制：继承允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以复用父类的代码，并且可以在此基础上添加新的属性和方法，或者重写父类的方法以实现不同的行为。继承大大提高了代码的可扩展性。
- 多态性：多态性使得不同的对象可以对同一消息做出不同的响应。通过多态，代码可以更加灵活和通用。
符合人类思维习惯
- 模拟现实世界：面向对象编程的概念与现实世界的事物和关系非常相似。在现实世界中，我们可以将各种事物看作对象，它们具有自己的属性和行为。开发人员可以根据现实世界的模型来设计程序，从而降低了编程的难度和复杂性。
便于团队协作开发
- 分工明确：由于面向对象编程将程序分解为多个独立的对象，每个对象都有自己明确的职责，因此团队成员可以分工负责不同的对象开发。这种分工明确的开发方式可以提高开发效率，减少团队成员之间的冲突和误解。
- 接口定义与协作：面向对象编程通过定义接口来规范对象之间的交互。团队成员可以根据接口的定义来开发各自的对象，而不需要了解其他对象的具体实现细节。
对象是类的一个实例，也是面向对象编程的基本单位。对象包含数据（称为属性）和行为（称为方法）
万物以类聚，通过分类可以将万事万物归纳起来。类可看作是创建对象的蓝图或模板，它定义了对象的数据属性和行为方法。
接口是一种抽象方法的集合，与类属于不同的概念。类描述对象的属性和方法，接口则定义类需要实现的方法。 接口和抽象类有点像，都是一种抽象类型，但两者很大不同。抽象类是对一种事物整体的抽象，即对类抽象，包括属性、行为等，子类和抽象类是一种"is-a"的关系。而接口是对行为的抽象，是对类局部（行为）进行抽象，接口表示一种"can-do"的关系。 抽象类作为子类的父类，它是一种模板式设计。接口是一种行为规范，它是一种辐射式设计。
即隐藏对象的属性和实现细节，只对外公开必要的接口，控制属性的读写访问级别。封装有助于保持代码的模块化和减少代码复杂性。
即子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法。继承的类被称为子类，提供继承的类被称为父类或基类，通过继承可以实现代码复用。在面向对象编程中，只在必须的时候使用继承，其他时候尽量使用组合。
部分与整体的关系。将一个对象是另一个对象的属性，从而实现对象之间的关联。与继承不同，组合强调的是一种“has-a”（拥有）关系，而不是“is-a”（是）的关系。组合通常用于建立复杂对象的内部结构，使得对象的构成更加灵活，并有助于代码的模块化和重用。
也是部分和整体的关系，一个对象（整体）包含或引用其他对象（部分），但这些部分对象在逻辑上可以独立于整体对象。与组合不同，聚合中的部分对象不一定是整体对象的严格组成部分，它们可以在整体对象销毁后继续存在。聚合关系松散，组合关系严密。
即同一个行为具有多个不同表现形式或形态的能力。表现形式为，子类重写父类方法，实现类实现接口方法，子类重写抽象类方法等。多态三个必要条件：继承、重写、父类引用指向子类对象。多态有效消除类型之间的耦合，并提供灵活的可扩展方案。
是一种简化复杂系统的方法，在更高层次上进行建模。在面向对象编程中，抽象意味着关注对象的模型架构而非具体实现。抽象包括两个方面，一是过程抽象，二是数据抽象。过程抽象，关注于目标的功能是什么，而不是功能是怎么实现的。数据抽象，关注数据的特性、用途和行为，而不是底层实现。
/**
* 体现了面向对象编程的以下概念：
* 类和对象：Animal是基类，Dog和Cat是从Animal继承的子类。通过创建类的实例，可以生成不同的对象。
* 继承：Dog和Cat继承了Animal类的属性和方法，同时也可以覆写父类的方法，实现自己特有的行为。
* 多态：通过父类引用子类对象，代码可以在运行时根据对象的类型调用相应的覆写方法。这允许更灵活的代码复用和扩展。
* 封装：类的属性被保护级别封装，确保只有子类和自身可以访问。这有助于保持对象的状态和行为的安全。
*/
// 定义一个Animal的基类
class Animal {
protected String name; // 封装，保护级别的属性，子类可以访问
public Animal(String name) {
this.name = name; // 初始化动物的名字
}
public void speak() {
System.out.println(name + " makes a sound."); // 通用的说话方法
}
}
// 定义一个Dog的子类，继承自Animal
class Dog extends Animal {
public Dog(String name) {
super(name); // 调用父类的构造方法
}
@Override // 覆写父类的方法
public void speak() {
System.out.println(name + " barks."); // 狗特有的说话方式
}
}
// 定义一个猫的子类，继承自Animal
class Cat extends Animal {
public Cat(String name) {
super(name); // 调用父类的构造方法
}
@Override // 覆写父类的方法
public void speak() {
System.out.println(name + " meows."); // 猫特有的说话方式
}
}
// 演示多态和继承
public class Test {
public static void main(String[] args) {
// 创建一个动物的对象
Animal genericAnimal = new Animal("Generic Animal");
genericAnimal.speak(); // 输出：Generic Animal makes a sound.
// 创建一个狗的对象
Dog dog = new Dog("Buddy");
dog.speak(); // 输出：Buddy barks.
// 创建一个猫的对象
Cat cat = new Cat("Whiskers");
cat.speak(); // 输出：Whiskers meows.
// 演示多态
Animal polymorphicAnimal;
// 父类声明子类Dog
polymorphicAnimal = new Dog("Rover");
polymorphicAnimal.speak(); // 输出：Rover barks.
// 对象改为Cat
polymorphicAnimal = new Cat("Fluffy");
polymorphicAnimal.speak(); // 输出：Fluffy meows.
}
}#include <stdio.h>
#include <stdlib.h>
// 定义 Animal 结构体
typedef struct Animal {
char *name;
void (*speak)(struct Animal *);
} Animal;
// Animal 的 speak 方法
void animal_speak(Animal *animal) {
printf("%s makes a sound.\n", animal->name);
}
// 创建 Animal 对象
Animal *create_animal(const char *name) {
Animal *animal = (Animal *)malloc(sizeof(Animal));
animal->name = strdup(name);
animal->speak = animal_speak;
return animal;
}
// 定义 Dog 结构体，模拟继承
typedef struct Dog {
Animal base; // 继承 Animal 的属性
} Dog;
// Dog 的 speak 方法
void dog_speak(Animal *animal) {
printf("%s barks.\n", animal->name);
}
// 创建 Dog 对象
Dog *create_dog(const char *name) {
Dog *dog = (Dog *)malloc(sizeof(Dog));
dog->base.name = strdup(name);
dog->base.speak = dog_speak;
return dog;
}
// 定义 Cat 结构体，模拟继承
typedef struct Cat {
Animal base; // 继承 Animal 的属性
} Cat;
// Cat 的 speak 方法
void cat_speak(Animal *animal) {
printf("%s meows.\n", animal->name);
}
// 创建 Cat 对象
Cat *create_cat(const char *name) {
Cat *cat = (Cat *)malloc(sizeof(Cat));
cat->base.name = strdup(name);
cat->base.speak = cat_speak;
return cat;
}
// 释放对象内存
void free_animal(Animal *animal) {
free(animal->name);
free(animal);
}
int main() {
// 创建一个 Animal 对象
Animal *generic_animal = create_animal("Generic Animal");
generic_animal->speak(generic_animal);
// 创建一个 Dog 对象
Dog *dog = create_dog("Buddy");
dog->base.speak((Animal *)dog);
// 创建一个 Cat 对象
Cat *cat = create_cat("Whiskers");
cat->base.speak((Animal *)cat);
// 演示多态
Animal *polymorphic_animal;
polymorphic_animal = (Animal *)create_dog("Rover");
polymorphic_animal->speak(polymorphic_animal);
polymorphic_animal = (Animal *)create_cat("Fluffy");
polymorphic_animal->speak(polymorphic_animal);
// 释放内存
free_animal(generic_animal);
free_animal((Animal *)dog);
free_animal((Animal *)cat);
free_animal(polymorphic_animal);
return 0;
}package main
import "fmt"
// 定义 Animal 结构体
type Animal struct {
name string
}
// Animal 的 speak 方法
func (a Animal) speak() {
fmt.Printf("%s makes a sound.\n", a.name)
}
// 定义 Dog 结构体，嵌入 Animal 结构体实现继承
type Dog struct {
Animal
}
// Dog 的 speak 方法，重写父类方法
func (d Dog) speak() {
fmt.Printf("%s barks.\n", d.name)
}
// 定义 Cat 结构体，嵌入 Animal 结构体实现继承
type Cat struct {
Animal
}
// Cat 的 speak 方法，重写父类方法
func (c Cat) speak() {
fmt.Printf("%s meows.\n", c.name)
}
func main() {
// 创建一个 Animal 对象
genericAnimal := Animal{name: "Generic Animal"}
genericAnimal.speak()
// 创建一个 Dog 对象
dog := Dog{Animal{name: "Buddy"}}
dog.speak()
// 创建一个 Cat 对象
cat := Cat{Animal{name: "Whiskers"}}
cat.speak()
// 演示多态
var polymorphicAnimal interface {
speak()
}
polymorphicAnimal = Dog{Animal{name: "Rover"}}
polymorphicAnimal.speak()
polymorphicAnimal = Cat{Animal{name: "Fluffy"}}
polymorphicAnimal.speak()
}// 定义 Animal 类
class Animal {
constructor(name) {
this.name = name;
}
speak() {
console.log(`${this.name} makes a sound.`);
}
}
// 定义 Dog 类，继承自 Animal 类
class Dog extends Animal {
speak() {
console.log(`${this.name} barks.`);
}
}
// 定义 Cat 类，继承自 Animal 类
class Cat extends Animal {
speak() {
console.log(`${this.name} meows.`);
}
}
// 演示多态和继承
const genericAnimal = new Animal("Generic Animal");
genericAnimal.speak();
const dog = new Dog("Buddy");
dog.speak();
const cat = new Cat("Whiskers");
cat.speak();
// 演示多态
let polymorphicAnimal;
polymorphicAnimal = new Dog("Rover");
polymorphicAnimal.speak();
polymorphicAnimal = new Cat("Fluffy");
polymorphicAnimal.speak();