【基础】Python中的面向对象编程概念与实践

# 1. **2.1 类和对象**

### 2.1.1 类的定义和实例化

在Python中，类是用来创建对象的蓝图。类定义了对象的属性和方法，而对象是类的实例。

# 定义一个类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 实例化一个对象
person = Person("John", 30)

在这个例子中，`Person`类定义了两个属性`name`和`age`，以及一个构造函数`__init__`。`person`对象是`Person`类的实例，它具有`name`和`age`属性，分别为"John"和30。

# 2. Python面向对象编程实践

### 2.1 类和对象

#### 2.1.1 类的定义和实例化

Python 中的类使用 `class` 关键字定义，类名首字母大写。类的定义包括属性和方法，属性用于存储数据，方法用于操作数据。

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

    def get_name(self):
        return self.name

    def get_age(self):
        return self.age

实例化类时，使用 `class_name()` 语法。实例化后，可以访问类的属性和方法。

person = Person("John", 30)
print(person.get_name())  # 输出："John"
print(person.get_age())  # 输出：30

#### 2.1.2 对象的属性和方法

对象是类的实例，具有自己的属性和方法。属性可以是实例属性（在实例化时指定）或类属性（在类定义中指定）。

class Person:
    species = "Homo sapiens"  # 类属性

    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age  # 实例属性

对象的方法可以访问和修改对象的属性。

person = Person("John", 30)
person.name = "Jane"  # 修改实例属性
print(person.species)  # 输出："Homo sapiens"（访问类属性）

### 2.2 继承和多态

#### 2.2.1 继承的语法和机制

继承允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以使用父类的所有公共属性和方法，并可以定义自己的新属性和方法。

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def bark(self):
        print("Woof!")

子类 `Dog` 继承了父类 `Animal` 的 `name` 属性，并定义了新的 `bark` 方法。

#### 2.2.2 多态的实现和应用

多态性允许对象以不同的方式响应相同的方法调用。这可以通过方法重写（在子类中重新定义父类的方法）来实现。

class Animal:
    def make_sound(self):
        print("Animal sound")

class Dog(Animal):
    def make_sound(self):
        print("Woof!")

当调用 `make_sound` 方法时，不同的动物对象会根据其类型发出不同的声音。

### 2.3 封装和抽象

#### 2.3.1 封装的原则和实现

封装将对象的内部状态和实现细节隐藏起来，只对外暴露必要的接口。这有助于提高代码的可维护性和安全性。

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性，以双下划线开头
        self.age = age

    def get_name(self):
        return self.__name  # 通过方法访问私有属性

私有属性只能在类的内部访问，外部无法直接访问。

#### 2.3.2 抽象类的定义和使用

抽象类定义了接口，但没有实现方法。抽象类不能被实例化，只能被子类继承。子类必须实现抽象类中定义的所有抽象方法。

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def get_area(self):

class Square(Shape):
    def __init__(self, side_length):
        self.side_length = side_length

    def get_area(self):
        return self.side_length ** 2

抽象类 `Shape` 定义了 `get_area` 方法，但没有实现。子类 `Square` 实现 `get_area