目录

一、什么是面向对象1.定义2.面向对象 VS 面向过程

二、核心概念1.对象对象的三大特征

2.类类与对象

3.封装4.继承5.多态

三、面向对象编程在实际项目中的应用1.企业级应用开发：2.游戏开发：3.移动应用开发：

四、总结

一、什么是面向对象

1.定义

面向对象是一种软件开发的编程范式、思维方式，它模拟了人类认识和理解世界的方式，将数据和操作数据的方法封装在一起，形成对象，并通过对象之间的交互来实现系统功能。

2.面向对象 VS 面向过程

面向过程

过程是负责完成某个具体任务的代码，基本可以理解为函数。面向过程编程的核心，就是把要实现的事情拆分成一个个步骤，依次完成。随着程序长度和复杂度的增加，代码的清晰度可能由此降低。

面向过程的方式会按照步骤一步步计算：

#include

// 面向过程的C语言实现

float calculateSalary(float baseSalary, float overtimeHours, float bonus) {

/* 步骤1: 计算加班工资 (每小时加班是基本工资的1.5倍)

假设每月工作160小时(baseSalary/160 = 每小时工资) */

float overtimePay = overtimeHours * (baseSalary / 160) * 1.5f;

/* 步骤2: 计算总工资 */

float totalSalary = baseSalary + overtimePay + bonus;

/* 步骤3: 计算税后工资 (假设税率20%) */

float tax = totalSalary * 0.2f;

float netSalary = totalSalary - tax;

return netSalary;

}

int main() {

// 使用示例

float base = 5000.0f;

float overtime = 10.0f;

float bonus = 1000.0f;

float salary = calculateSalary(base, overtime, bonus);

// 输出结果（%.2f保留两位小数）

printf("面向过程计算的结果: 税后工资为 %.2f 元\n", salary);

return 0;

}

面向对象

面向对象编程是一种以对象为核心的编程范式，它将数据（属性）和操作数据的行为（方法）封装在一起，形成独立的逻辑单元。与面向过程编程关注执行步骤不同，面向对象首先关注系统中需要哪些对象，每个对象应该具备什么属性和能力。

通过定义类来抽象对象的共同特征，再实例化出具体的对象。这种方式使代码结构更贴近现实世界的业务逻辑，将复杂的系统分解为多个相互作用的对象。对象内部封装细节，对外暴露清晰的接口，既保护了数据安全，又降低了模块间的关联度。

面向对象编程特别适合处理复杂的业务系统，它通过封装、继承和多态三大特性，使代码更易维护、扩展和复用。当系统规模增大、逻辑变复杂时，面向对象的优势会更加明显，能够保持代码的组织性和清晰度。这种编程范式不仅是一种技术实现方式，更是一种分析和解决问题的思维方法。

所谓方法，就是放在类里面的函数，所谓属性就是放在类里面的变量。

// 面向对象的方式

class Employee {

constructor(

public name: string,

private baseSalary: number,

private overtimeHours: number = 0,

private bonus: number = 0

) {}

// 计算加班工资

private calculateOvertimePay(): number {

return this.overtimeHours * (this.baseSalary / 160) * 1.5;

}

// 计算总工资

private calculateTotalSalary(): number {

return this.baseSalary + this.calculateOvertimePay() + this.bonus;

}

// 计算税后工资

calculateNetSalary(): number {

const total = this.calculateTotalSalary();

const tax = total * 0.2; // 20%税率

return total - tax;

}

// 可以添加其他方法

addBonus(amount: number): void {

this.bonus += amount;

}

logHours(hours: number): void {

this.overtimeHours += hours;

}

}

// 使用

const emp = new Employee("张三", 5000);

emp.logHours(10); // 记录10小时加班

emp.addBonus(1000); // 添加1000元奖金

const salary = emp.calculateNetSalary();

console.log(`面向对象计算的结果: ${emp.name} 的税后工资为 ${salary.toFixed(2)} 元`);

维度面向过程面向对象编程单位函数（按步骤组织代码）对象（数据 + 行为的封装单元）设计核心“怎么做”（关注算法和流程）“谁来做”（关注对象职责和交互）数据与行为数据与函数分离（数据通过参数传递）数据与方法绑定（对象自主管理状态）典型语言C、PascalJava、C#、TypeScript

二、核心概念

1.对象

对象是面向对象编程的基本单元，它是现实世界中事物的抽象表示。每个对象都有自己的状态和行为。比如，一辆汽车可看作对象，属性有颜色、型号、速度等，行为有启动、加速、刹车等。

//一个简单的汽车对象

const car = {

//属性

brand: "Toyota",

model: "Corolla",

speed: 0,

//加速（方法：定义行为）

accelerate(num: number) {

this.speed += num;

console.log(`加速到 ${this.speed} km/h`);

},

brake() {

this.speed = 0;

console.log("已刹车");

}

};

//访问属性

console.log(car.brand); //输出: Toyota

//调用方法

car.accelerate(50); //输出: 加速到 50 km/h

对象的三大特征

标识

每个对象在内存中具有唯一地址，即使属性完全相同也被视为不同对象

const obj1 = { id: 1 };

const obj2 = { id: 1 };

console.log(obj1 === obj2); // false（内存地址不同）

状态

对象属性会随时间改变（如车速从0加速到100）

const car = { speed: 0 };

car.speed = 100; // 状态变更

行为

方法可以响应外部请求并修改自身状态

const counter = {

value: 0,

increment() {

this.value++;

} // 行为影响状态

};

2.类

类是创建对象的模板或蓝图，它定义了一组对象共有的属性和方法。通过类可以创建多个具有相同特征和行为的对象。 定义类的关键字为class，后面跟着类名，类可以包含以下几个模块：

字段 − 类里面声明的变量。字段表示对象的有关数据。

构造函数 − 类实例化时调用，可以为类的对象分配内存。

方法 − 对象要执行的操作。

以 “汽车类” 为例，它规定了所有汽车对象共有的属性和方法，依据这个类就能创建出具体的汽车对象。

class Car {

//属性声明（类的状态）

brand: string;

model: string;

private speed: number; //私有属性

//构造函数（初始化对象）

constructor(brand: string, model: string) {

this.brand = brand;

this.model = model;

this.speed = 0;

}

//方法（类的行为）

accelerate(num: number): void {

this.speed += num;

console.log(`${this.brand} ${this.model} 加速到 ${this.speed} km/h`);

}

brake(): void {

this.speed = 0;

console.log(`${this.brand} ${this.model} 已刹车`);

}

// 获取当前速度

get currentSpeed(): number {

return this.speed;

}

}

// 创建Car类的实例

const myCar = new Car("Honda", "Accord");

myCar.accelerate(30); //输出: Honda Accord 加速到 30 km/h

console.log(myCar.currentSpeed); //输出: 30

// myCar.speed = 100; //错误: speed是私有属性

类与对象

类和对象的关系是：类是创建对象的模板，对象是类的实例。

当通过new关键字实例化类时，内存中会生成一个具有独立身份的对象。这个过程类似于：

类如同汽车设计图纸，规定了"汽车应该有哪些部件（属性）和功能（方法）"

对象则是根据该图纸生产的具体车辆，每辆车：

拥有图纸定义的标准配置（类属性）具备相同的操作方式（类方法）但各自维护独立的状态（如不同车辆的当前速度）

项目对象类创建方式直接定义使用 class 定义，new 实例化复用性单个实例可以创建多个实例方法直接定义在类中定义继承不支持支持 extends 继承适用场景简单数据集合/单例需要创建多个相似对象的复杂场景

3.封装

封装表示写类的人，将内部实现细节隐藏起来，使用类的人只通过外部接口访问和使用，这样能保护数据的安全性，防止外部的非法访问和修改。

接口可以被大致理解为提供使用的方法。

比如有人已经写好了账户类，其实只需要知道它有什么方法，方法怎么用就足够了，不需要知道方法里面具体是怎么写的。账户余额属于敏感信息，可将其属性设为私有，仅通过公有的存款和取款方法来操作。

封装能减少我们对不必要细节的精力投入。

可以通过以下方式实现信息隐藏：

访问控制

使用 private/protected 关键字隐藏敏感数据（如代码中的 balance 和 accountNumber）

仅暴露必要的公共方法作为操作接口（如 deposit()、withdraw()）

行为与数据的绑定

将数据修改逻辑封装在方法内（如存款时检查 amount > 0）外部调用者无法直接修改内部状态（尝试直接赋值 balance 会报错）

接口契约

使用者只需了解方法的输入输出（如 withdraw(amount) 返回布尔值表示成功与否）无需关心内部实现（如余额如何存储、如何校验）

class BankAccount {

private balance: number;

private readonly accountNumber: string;

constructor(accountNumber: string, initialBalance: number = 0) {

this.accountNumber = accountNumber;

this.balance = initialBalance;

}

//公开方法用于存款

deposit(amount: number): void {

if (amount > 0) {

this.balance += amount;

console.log(`存入 ${amount}，当前余额: ${this.balance}`);

} else {

console.log("存款金额必须大于0");

}

}

// 公开方法用于取款

withdraw(amount: number): boolean {

if (amount > 0 && amount <= this.balance) {

this.balance -= amount;

console.log(`取出 ${amount}，剩余余额: ${this.balance}`);

return true;

}

console.log("取款失败，余额不足或金额无效");

return false;

}

// 获取余额

getBalance(): number {

return this.balance;

}

}

const account = new BankAccount("123456789", 1000);

account.deposit(500); //输出: 存入 500，当前余额: 1500

account.withdraw(200); //输出: 取出 200，剩余余额: 1300

//account.balance = 10000; //错误: balance是私有属性

4.继承

面向对象编程允许创建有层次的类，就像现实中的儿子继承爸爸，爸爸继承爷爷，类也可以有子类和父类，来表示从属关系。 继承允许一个类（子类）从另一个类（父类）获取属性和方法。子类不仅拥有父类的所有特性，还能按需添加自身特有的属性和方法。 例如：小学生、大学生都是学生，都应该有学号，年级的属性，都要去学校。可以看到这两个类之间的共同之处，导致有很多重复代码产生。那我们可以创建出一个叫学生的父类，然后让小学生和大学生去继承这个类，这样做的好处是，父类的那些属性、方法，都可以被继承，不需要反复定义，减少代码的冗余。

class Student {

constructor(public id: string, public grade: number) {}

attendSchool(): void {

console.log(`学生 ${this.id} 去学校`);

}

}

class PrimaryStudent extends Student {

constructor(id: string, grade: number) {

super(id, grade); // 调用父类构造函数

}

}

class CollegeStudent extends Student {

constructor(id: string, grade: number) {

super(id, grade);

}

}

// 使用

const pupil = new PrimaryStudent("P100", 3);

const college = new CollegeStudent("C200", 2);

pupil.attendSchool(); // 输出: 学生 P100 去学校

5.多态

多态指的是同样的接口，因为对象具体类的不同，而有不同表现。 比如因为小学生和大学生都要写作业，但内容的难度肯定不一样，所以这个写作业的方法，就不能直接定义在父类里面，而是要分别定义在子类里，否则大学生和小学生用的是同一个方法。那假如作为俩孩子的家长，家里正好一个大学生一个小学生，要这俩对象写作业的时候，其实不用管具体写的是高难度还是低难度作业，都可以一视同仁，调用写作业方法，而他们会由于所属类不同，执行不同的写作业方法，这就是多态。可以想象一下，如果不用类，而用if，我们就需要先去判断学生的类型，然后手动调用不同的写作业函数。而面向对象的多态，让我们可以无需判断，统一调用同一名称的方法。 多态指同一个方法在不同对象中可以有不同的表现形式。这让程序在运行时能根据对象的实际类型调用相应的方法，提高了代码的灵活性和可扩展性。

class Student {

doHomework(): void {

console.log("写作业");

}

}

class PrimaryStudent extends Student {

doHomework(): void {

console.log("写小学数学题");

}

}

class CollegeStudent extends Student {

doHomework(): void {

console.log("写高等数学习题");

}

}

// 多态调用

function askToWork(student: Student): void {

student.doHomework(); // 根据实际对象类型调用对应方法

}

askToWork(new PrimaryStudent()); // 输出: 写小学数学题

askToWork(new CollegeStudent()); // 输出: 写高等数学论文

三、面向对象编程在实际项目中的应用

在实际的软件开发项目中，面向对象编程被广泛应用于各个领域。

1.企业级应用开发：

在企业资源规划、客户关系管理等大型企业级应用中，面向对象编程可以很好地组织复杂的业务逻辑和数据结构。通过将不同的业务模块抽象为对象和类，使得系统的架构更加清晰，便于团队协作开发和后期维护。

2.游戏开发：

游戏中的角色、道具、场景等都可以看作是对象，它们具有各自的属性和行为。通过面向对象编程，可以实现游戏中丰富的交互效果和复杂的逻辑。例如，在一个角色扮演游戏中，不同的角色可以通过继承一个基类来拥有共同的属性（如等级、经验值）和方法（如攻击、防御），同时每个角色又可以有自己独特的技能和外观。

3.移动应用开发：

无论是 iOS 还是 Android 平台的移动应用开发，面向对象编程都是主要的编程范式。在移动应用中，界面元素（如按钮、文本框）、数据模型、业务逻辑等都可以通过对象和类来进行组织和管理。通过封装和复用，可以提高应用的开发效率和性能。

四、总结

面向对象编程以其独特的概念和优势，成为现代软件开发中不可或缺的编程范式。它不仅提供了一种更加自然和直观的编程方式，还通过代码复用、可维护性和可扩展性等特性，弥补了面向过程编程在复杂场景下的不足。 然而，两种编程范式并非非此即彼：面向过程编程在小型工具开发、性能敏感场景（如嵌入式系统）中仍有一席之地；而面向对象编程更适合构建大型、高可维护性的软件系统。开发者需要根据具体需求灵活选择，甚至将两种范式结合使用，以实现最佳的开发效果。