基础概念——类

在编程中，类（Class）是一种用于创建对象的蓝图或模板。它定义了对象的属性和行为，即对象可以拥有的数据和可以执行的操作。类是面向对象编程（Object-Oriented Programming，OOP）的核心概念之一。

类的结构：

在Python中，定义一个类的基本结构如下：

class ClassName:
    # 属性（类变量和实例变量）
    
    # 方法（类方法和实例方法）

• 属性（Variables）： 类中的属性可以是类变量或实例变量。类变量是类的所有实例共享的变量，它们通常用于存储与类相关的信息。实例变量是属于实例（对象）的变量，每个实例都可以拥有自己的实例变量。

• 方法（Functions）： 类中的方法可以是类方法或实例方法。类方法是属于类的方法，它们可以访问类变量但不能直接访问实例变量。实例方法是属于实例的方法，它们可以访问和操作实例变量。 

创建类和实例：

例子

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

    def bark(self):
        print("汪汪！")

# 创建实例
dog1 = Dog("小白", 3)
dog2 = Dog("旺财", 5)

# 访问实例变量
print(dog1.name)  # 输出：小白
print(dog2.age)   # 输出：5

# 调用实例方法
dog1.bark()  # 输出：汪汪！
dog2.bark()  # 输出：汪汪！

通过类，我们可以创建对象（实例）。实例化一个类就是根据类的模板创建一个具体的对象，然后我们可以使用这个对象调用类中定义的方法或访问属性。

在例子中，我们创建了一个名为Dog的类，定义了两个实例变量name和age以及一个实例方法bark。然后我们通过Dog类创建了两个dog1和dog2的实例，并使用它们访问实例变量和调用实例方法。

__init__方法

代码中的__init__ 是一个特殊的方法（函数）在Python类中，它被称为构造方法（Constructor）。当创建一个类的实例（对象）时，__init__ 方法会自动调用，并在对象创建后初始化对象的属性。

构造方法的命名固定为 __init__，它的第一个参数通常是 self，表示正在创建的实例对象自身。后续参数可以是我们想要在实例化对象时传递的数据，用于初始化实例的属性。

构造方法的作用：

1. 初始化实例变量：构造方法可以用来初始化类的实例变量，给对象赋予初始值。

2. 处理传递的参数：我们可以在构造方法中接收传递给类的参数，并用这些参数来初始化实例变量。

示例：

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

    def introduce(self):
        print(f"Hi, my name is {self.name}, and I am {self.age} years old.")

# 创建Person类的实例
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# 调用实例方法
person1.introduce()  # 输出：Hi, my name is Alice, and I am 25 years old.
person2.introduce()  # 输出：Hi, my name is Bob, and I am 30 years old.

在上例中，__init__ 方法被用来初始化 Person 类的实例变量 name 和 age。当我们创建 Person 类的实例 person1 和 person2 时，传递的参数会被用来初始化对应的实例变量。

继承、多重继承和方法重写：

继承

继承是面向对象编程中的一个重要概念，它允许我们创建一个新的类（子类），从现有的类（父类或基类）继承属性和方法。子类可以继承父类的特征，并且还可以在其基础上添加自己的属性和方法，实现代码的重用和扩展。

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

    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "汪汪！"

class Cat(Animal):
    def speak(self):
        return "喵喵！"

dog = Dog("小白")
cat = Cat("咪咪")

print(dog.name, dog.speak())  # 输出：小白 汪汪！
print(cat.name, cat.speak())  # 输出：咪咪 喵喵！

在上例中，我们定义了一个基类 Animal，它有一个实例变量 name 和一个抽象方法 speak()，抽象方法没有实际的实现，而是由子类实现。然后我们定义了两个子类 Dog 和 Cat，它们分别继承了 Animal 类，并重写了 speak() 方法，使其返回不同的字符串。

通过继承，子类获得了父类的属性和方法，并可以在其基础上进行定制化实现。这样，我们可以避免在每个子类中重复编写相同的代码，提高代码的复用性和可维护性。

多重继承

Python允许一个类继承自多个父类，这种继承方式称为多重继承。多重继承可以将多个类的功能组合到一个子类中，使其具有多个父类的特征。

class A:
    def method_a(self):
        print("调用方法A")

class B:
    def method_b(self):
        print("调用方法B")

class C(A, B):
    pass

c = C()
c.method_a()  # 输出：调用方法A
c.method_b()  # 输出：调用方法B

我们定义了三个类：A、B 和 C。C 类继承自 A 和 B，这样 C 类就同时具有了 A 类和 B 类的方法。

注意！

多重继承的使用需要谨慎，如果不正确地组织类之间的关系，可能会导致类的继承层次过于复杂，使得代码难以理解和维护。因此，在使用多重继承时，需要考虑设计的合理性和代码的可读性。

方法重写（覆盖）

当子类继承自父类时，如果子类的方法与父类的方法同名，子类的方法会覆盖父类的方法，这个过程称为方法重写或方法覆盖。

class Parent:
    def show(self):
        print("父类方法")

class Child(Parent):
    def show(self):
        print("子类方法")

child = Child()
child.show()  # 输出：子类方法

在例子中，Child 类继承自 Parent 类，并重写了 show() 方法。当我们调用 child.show() 时，子类的方法会被调用，而不是父类的方法。

通过方法重写，我们可以在子类中对父类的方法进行定制化实现，使得子类在具有父类的特征的同时，也可以表现出自己独特的行为。