理解“面向对象编程”概念

科学禅道

已于 2024-01-21 11:34:27 修改

阅读量951

点赞数 25

分类专栏： PyTorch 文章标签：开发语言 python

于 2024-01-19 15:18:30 首次发布

本文链接：https://blog.csdn.net/xw555666/article/details/135697956

版权

PyTorch 专栏收录该内容

40 篇文章 6 订阅

订阅专栏

面向对象编程（Object-Oriented Programming，OOP）是一种软件开发范式，它以“对象”为核心，将程序视为一系列相互协作的对象集合。

面向对象编程语言，计算机学术语，它设计的出发点就是为了能更加直接地描述客观世界中存在的事件（及对象）以及它们之间的关系。

具体来说，面向对象编程是一种程序设计和开发的范式，其核心理念是将数据结构与操作数据的方法绑定在一起，形成一个名为“对象”的基本单元。在OOP中，程序被组织成一系列相互关联、协作的对象，每个对象都拥有自己的属性（数据成员或状态）和行为（方法或功能）。

借助面向对象编程，开发者能更好地抽象出问题域中的概念模型，并以一种更贴近人类认知习惯的方式表达程序逻辑，从而降低复杂度，提高软件开发效率和质量。同时，面向对象编程也有助于团队协作和代码重用，提升软件生命周期内的可维护性和可扩展性。

理解面向对象编程可以从以下几个关键概念出发：对象、类、封装、继承、多态和抽象。

封装、继承和多态是面向对象编程的三大核心特性：

封装：隐藏内部实现细节，仅对外暴露必要的接口，使得代码更易于理解和管理，同时也提高了数据安全性。
继承：允许子类继承父类的属性和方法，实现代码复用，并且可以在继承的基础上扩展或修改功能，构建出层次化的类体系。
多态：同一消息发送给不同的对象会引发不同的行为，即一个接口，多种实现，增强了系统的灵活性与扩展性。

通过这些关键特性，面向对象编程提供了一种更符合人类思维习惯的方式来组织和管理复杂的软件系统，使得开发者能够更加高效地进行设计、编码、测试和维护工作,能够更加直观、高效地对软件系统进行设计、开发和维护。面向对象编程通过模拟现实世界中的实体及其相互关系，将复杂的逻辑结构化为一系列的对象和类。这些对象具有状态（属性）和行为（方法），可以互相协作完成任务。

1、对象

对象是对现实世界实体的抽象表示，每个对象都有自己的属性和行为。属性是指对象的状态或特征，例如一个人可能有姓名、年龄等属性；行为则是对象能够执行的操作，如人可以行走、说话等。

1.1 对象1——账户Account

面向对象编程中，对象是对现实世界实体或概念的一种抽象和模拟。以银行系统中的“账户”为例：

属性（状态）：账户这个对象可以具有多个属性来描述其状态，如余额（balance）、户主姓名（account_holder_name）、账户类型（account_type）、开户日期（open_date）等。
行为（方法）：账户对象还可以拥有执行特定操作的方法，比如存款（deposit）、取款（withdraw）、查询余额（check_balance）、转账（transfer）等。这些方法定义了账户能够执行的功能，并且可能会影响账户的状态。

通过这种方式，我们可以在软件开发中创建一个“Account”类来表示账户这一实体，该类包含了上述提到的属性和方法。当实例化这个类时，我们就得到了一个具体的账户对象，它可以独立地存储和处理数据，同时与系统的其他部分进行交互。这种基于对象的设计有助于提高代码的可读性、复用性和维护性。

1.2 对象2——汽车Car

对象在面向对象编程（OOP）中是对现实世界实体的一种抽象表示。这种抽象将实体的特征（属性）和行为（方法）封装在一起，形成一个具有独立状态和功能的程序组件。

例如，在现实生活中，汽车是一个实体，它有颜色、品牌、速度等属性，也有启动引擎、刹车、加速等行为。在面向对象编程中，我们可以创建一个Car类来抽象这个实体：

class Car:
    def __init__(self, color, brand):
        self.color = color  # 属性：颜色
        self.brand = brand  # 属性：品牌
        self.speed = 0     # 属性：速度，默认初始化为0

    def start_engine(self):  # 方法：启动引擎
        print("Engine started.")

    def brake(self):  # 方法：刹车
        self.speed = 0
        print("Brake applied. Speed set to 0.")

    def accelerate(self, amount):  # 方法：加速
        self.speed += amount
        print(f"Accelerated by {amount}. Current speed: {self.speed}")

通过实例化这个Car类，我们可以创建出不同的汽车对象，每个对象都有自己的颜色、品牌和速度，并能执行相应的操作（如启动引擎、刹车或加速）。这样的设计更符合人类对于复杂问题建模和解决的习惯，有助于提高软件开发的效率和可维护性。

2、类

类是创建对象的蓝图或模板。在类中定义了对象共同的属性和方法。通过实例化一个类，可以创建具有相同结构但独立状态的具体对象。例如，Person类可以定义姓名、年龄等属性以及吃饭、睡觉等方法，然后根据这个类创建多个不同的个人对象。

在面向对象编程（OOP）中，类是一种抽象的数据类型定义，它规定了一组属性（变量）和方法（函数），这些属性和方法构成了该类所代表的对象类型的核心特征。

例如，我们可以定义一个Person类，其中包含姓名（name）、年龄（age）等属性：

Python

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(f"{self.name} is eating.")

    def sleep(self):
        print(f"{self.name} is sleeping.")

在这个Person类中，__init__是一个特殊的方法（构造方法或初始化方法），用于创建新对象时设置其初始状态。eat和sleep则是两个实例方法，它们定义了个人可以执行的行为。

然后通过实例化这个类，我们可以创建具有不同状态的具体个体：

Python

person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# 调用对象的方法
person1.eat()  # 输出 "Alice is eating."
person2.sleep()  # 输出 "Bob is sleeping."

尽管person1和person2都是由Person类创建出来的对象，但它们各自具有独立的状态——不同的姓名和年龄。同时，它们都继承了类中定义的吃饭和睡觉的行为。这就是面向对象编程中的“实例化”过程以及类与对象之间的关系。

3、封装

封装是将数据和处理这些数据的函数绑定在一起，并对外隐藏内部实现细节的过程。类通过私有成员变量和公共方法实现了封装，外部代码只能通过类提供的接口来访问和修改对象的状态，而不能直接操作其内部的数据。

封装是面向对象编程的三大核心特性之一（另外两个是继承和多态），其主要目标是为了实现数据的安全性和内部逻辑的隐藏。

在类的设计中，通过将数据成员声明为私有（private）或受保护（protected），可以限制外部对这些成员的直接访问。这意味着其他代码不能随意读取或修改这些私有数据成员的值。同时，类会提供一组公共方法（public methods），也称为接口或访问器（accessors，如getters）和修改器（mutators，如setters），来控制对这些私有数据成员的操作。

例如，在银行账户类中：

私有成员变量：private double balance; （余额）
公共方法：
- public double getBalance() ：用于获取账户当前余额，不直接暴露余额变量。
- public void deposit(double amount) ：存款操作，增加账户余额，但外部代码不能直接修改balance。
- public void withdraw(double amount) ：取款操作，减少账户余额，同样需要经过方法的逻辑验证和处理。

通过这种方式，封装确保了对象的状态只能以一种安全、一致和预定义的方式来改变，从而降低了由于直接操作内部数据导致的潜在错误风险，并有助于维持良好的软件设计原则。

4、继承

继承允许一个类（子类/派生类）从另一个类（父类/基类）获取并扩展其属性和方法。这样，子类既能复用父类的功能，又可以根据需要增加新的特性或重写部分功能，从而形成一个层次结构。例如，Animal类可以作为Dog类和Cat类的父类。

继承是面向对象编程中的另一个关键特性，它支持基于现有类创建新类的过程。在继承中，子类不仅能够自动拥有父类的所有公共和受保护成员（属性和方法），还可以根据需要添加新的属性、方法或者对从父类继承的方法进行重写（Override）以实现不同的功能。

以下是一个简单的例子（Python）来说明继承的概念：

Python

# 定义父类（基类）
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("动物在发出声音")

# 定义子类（派生类）Dog，继承自Animal类
class Dog(Animal):
    def __init__(self, name, breed):
        # 调用父类的初始化方法来设置共享属性
        super().__init__(name)
        self.breed = breed

    # 重写父类的方法以实现特定行为
    def speak(self):
        print(f"{self.name} 在汪汪叫")

# 创建一个Dog实例
my_dog = Dog("旺财", "哈士奇")

# 访问从父类继承的属性和方法
print(my_dog.name)  # 输出：旺财
my_dog.speak()      # 输出：旺财 在汪汪叫

# 使用Dog类独有的属性
print(my_dog.breed)  # 输出：哈士奇

在这个例子中：

Animal 类是父类或基类，它定义了一个公共属性 name 和一个方法 speak。
Dog 类通过在其定义中包含 (Animal) 来继承 Animal 类。这样，Dog 类自动拥有 Animal 类的所有公共和受保护成员（在这个例子中只有 name 属性和 speak 方法）。
Dog 类还添加了新的属性 breed，这是 Animal 类所没有的。
Dog 类重写了父类的 speak 方法，为狗这一特定种类提供了不同的叫声行为。

继承使得代码复用更加方便，并且允许我们根据需要对继承来的功能进行扩展或定制化处理。

5、多态

多态性意味着不同类的对象可以共享同一种接口或类型，但在运行时表现出各自不同的行为。通常通过方法重写（override）和接口实现（interface implementation）实现多态。这使得代码更加灵活且易于扩展。

多态（Polymorphism）是面向对象编程中的另一个核心特性，它允许不同类的对象对同一消息或方法调用做出不同的响应。通过多态，我们可以设计出更加灵活且通用的代码，使得程序在处理不同类型的数据时能够保持一致的行为模式。

实现多态主要有两种方式：

方法重写（Override）：在子类中重新定义父类已有的方法。这样，当使用子类对象调用这个方法时，将执行子类版本的方法而不是父类版本。例如，在Python中：
```
class Animal:
    def make_sound(self):
        print("动物发出声音")

class Dog(Animal):
    def make_sound(self):
        print("汪汪叫")

dog = Dog()
dog.make_sound()  # 输出：汪汪叫
```
接口实现（Interface Implementation）：在一些支持接口的语言（如Java、C#等）中，可以声明一个不包含任何具体实现的接口，然后让多个类去实现这个接口，各自提供不同的实现细节。虽然Python没有显式的接口概念，但可以通过抽象基类（Abstract Base Classes, ABCs）模拟类似的效果。

例如，在Python中：

from abc import ABC, abstractmethod

# 创建一个抽象基类（接口模拟）
class SoundMaker(ABC):
    @abstractmethod
    def make_sound(self):
        pass

# 实现抽象基类的子类
class Animal(SoundMaker):
    def make_sound(self):
        print("动物发出声音")

class Dog(SoundMaker):
    def make_sound(self):
        print("汪汪叫")

# 创建对象并调用方法
dog = Dog()
dog.make_sound()  # 输出：汪汪叫

animal = Animal()
animal.make_sound()  # 输出：动物发出声音

在Python中，虽然没有像Java或C#那样的显式接口关键字，但可以使用抽象基类（Abstract Base Classes, ABCs）来模拟接口的行为。通过定义一个包含抽象方法的抽象基类，要求任何继承自该抽象基类的子类都必须实现这些抽象方法，从而实现了多态性。

上述例子中，SoundMaker 是一个抽象基类，它声明了一个抽象方法 make_sound。Animal 和 Dog 类分别作为 SoundMaker 的子类，各自实现了 make_sound 方法，因此它们都能响应同一消息（即调用 make_sound 方法），但在运行时表现出不同的行为。这就是多态性的体现。

6、抽象

抽象是忽略具体实现细节，关注对象本质特征的过程。在面向对象编程中，抽象主要体现在抽象类和接口上，它们只提供基本的框架，不包含具体的实现，由其子类去填充实现细节。

在Python中，虽然没有显式地使用“抽象类”这个术语（像Java和C#那样），但可以通过abc模块中的ABC（Abstract Base Class）来模拟抽象类的功能。以下是一个在Python中创建抽象基类的例子：

from abc import ABC, abstractmethod

# 定义抽象基类 Animal
class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass  # 子类必须重写并提供实现
    
    def eat(self):
        print("动物正在吃东西")  # 具体方法，子类可以继承

# 继承自抽象基类并实现抽象方法
class Dog(Animal):
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        print(f"{self.name} 汪汪叫")

dog = Dog("小黑")
dog.make_sound()  # 输出：小黑 汪汪叫
dog.eat()         # 输出：动物正在吃东西

对于接口，Python采用了一种更灵活的方式，通常通过定义包含特定方法签名的抽象基类来模拟接口。多个类可以继承这个抽象基类，并各自实现这些方法。

尽管Python没有明确的“接口”关键字，但通过抽象基类，我们同样能够达到规定基本结构和功能的目的，强制子类遵循一定的规范，从而确保代码的可复用性和扩展性。同时，这也是实现多态性的基础，在运行时可以根据对象的实际类型调用相应的方法。

总结来说，面向对象编程通过模拟现实世界的实体及其交互方式，提供了良好的代码组织结构和设计模式，使程序更容易理解和维护，同时也促进了代码的复用性和可扩展性。

科学禅道

关注

25
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
理解“面向对象编程”概念

面向对象编程（Object-Oriented Programming，OOP）是一种软件开发范式，它以“对象”为核心，将程序视为一系列相互协作的对象集合。通过这些关键特性，面向对象编程提供了一种更符合人类思维习惯的方式来组织和管理复杂的软件系统，使得开发者能够更加高效地进行设计、编码、测试和维护工作。
复制链接

扫一扫