【Python学习笔记】类与对象的基本概念解析

在 Python 中，类是面向对象编程（OOP）的核心概念之一。类是用于创建对象的模板，它定义了对象的属性和行为。我们通过类来封装数据和功能，使得代码更具可复用性、扩展性和组织性。

1. 类的定义

使用 class 关键字来定义一个类。

基本语法：

class ClassName:
    # 类的属性（变量）
    attribute = value
    
    # 类的方法（函数）
    def method(self):
        # 方法体
        pass

2. 类的构造函数（__init__）

构造函数（Constructor）是面向对象编程（OOP）中的一个特殊方法，它在创建类的实例时被自动调用，用于初始化对象的属性或执行其他必要的操作。构造函数的主要目的是为对象提供初始状态。

在 Python 中，构造函数是 __init__() 方法。它会在每次创建对象时被自动调用，通常用于给对象赋予初始值。

构造函数的特点：

1. 自动调用：构造函数会在对象实例化时自动执行，不需要显式调用。
2. 初始化对象：构造函数通常用于为新创建的对象设置初始状态或属性值，或者执行其他与对象创建相关的操作。

示例：

class Dog:
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age
        
    def bark(self):
        print(f"{self.name} is barking!")

# 创建对象
dog1 = Dog("Buddy", 3)
print(dog1.name)  # 输出：Buddy
dog1.bark()  # 输出：Buddy is barking!

在这个例子中，__init__ 方法初始化了 name 和 age 两个实例属性。通过 self 引用当前对象，self.name 和 self.age 是当前对象的属性。

3. 实例化对象

实例化一个类时，我们会创建一个该类的对象（也称为实例）。每个对象都拥有自己的属性和方法。self 是 Python 中类方法的第一个参数，代表当前实例，允许方法访问实例的属性和行为。虽然可以把 self 改成其他名字，但通常约定使用 self，以遵循 Python 的惯例和保持代码的可读性。违背这一惯例可能会影响代码的清晰度。类的实例方法必须包含 self，而类方法（如 __init__）也需要，它指代的是初始化时创建的当前对象。

class Cat:
    def __init__(self, name, color):
        self.name = name
        self.color = color
    
    def meow(self):
        print(f"{self.name} says meow!")

# 创建对象
cat1 = Cat("Whiskers", "black")
cat1.meow()  # 输出：Whiskers says meow!

4. 类的属性与实例的属性

示例：

class Car:
    wheels = 4  # 类属性
    
    def __init__(self, brand, model):
        self.brand = brand  # 实例属性
        self.model = model  # 实例属性
    
    def drive(self):
        print(f"{self.brand} {self.model} is driving!")

# 创建对象
car1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")

# 访问类属性
print(car1.wheels)  # 输出：4
print(car2.wheels)  # 输出：4

# 修改类属性
Car.wheels = 6
print(car1.wheels)  # 输出：6
print(car2.wheels)  # 输出：6

5. 类的方法

类的方法是与类实例关联的函数。方法定义时，必须包含一个 self 参数，它代表当前实例对象。

示例：实例方法

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# 创建对象并调用实例方法
p1 = Person("Alice", 30)
p1.greet()  # 输出：Hello, my name is Alice and I am 30 years old.

示例：类方法

class Animal:
    species = "Unknown"  # 类属性

    @classmethod
    def set_species(cls, species):
        cls.species = species  # 修改类属性

    @classmethod
    def show_species(cls):
        print(f"Species: {cls.species}")

# 调用类方法
Animal.set_species("Dog")
Animal.show_species()  # 输出：Species: Dog

示例：静态方法

class Math:
    @staticmethod
    def add(x, y):
        return x + y

    @staticmethod
    def subtract(x, y):
        return x - y

# 调用静态方法
result1 = Math.add(5, 3)
result2 = Math.subtract(5, 3)
print(result1)  # 输出：8
print(result2)  # 输出：2

6. 继承与多态

继承

继承使得一个类可以继承另一个类的属性和方法，称为子类（派生类）继承父类（基类）。子类可以重写父类的方法，也可以添加新的方法。

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

# 创建子类对象
dog = Dog()
dog.speak()  # 输出：Dog barks

多态

多态是指不同类型的对象对同一消息做出响应的能力。例如，Dog 和 Cat 都是 Animal 类的子类，虽然它们有相同的方法 speak，但它们的实现不同。

class Cat(Animal):
    def speak(self):
        print("Cat meows")

# 创建对象
animals = [Dog(), Cat()]

# 多态性：同一方法调用，不同对象表现出不同的行为
for animal in animals:
    animal.speak()
# 输出：
# Dog barks
# Cat meows

7. 封装

封装是指将数据（属性）和方法（操作数据的函数）组合成一个单元。封装使得数据更加安全，防止外部直接访问或修改。

访问控制：

示例：

class Employee:
    def __init__(self, name, salary):
        self.name = name           # 公共属性
        self._salary = salary      # 受保护的属性
        self.__password = "secret" # 私有属性

    def show_info(self):
        print(f"Employee: {self.name}, Salary: {self._salary}")

    def __private_method(self):
        print("This is a private method.")

# 创建对象
emp = Employee("John", 50000)
emp.show_info()  # 可以访问公共方法

# 访问私有属性和方法会报错
# print(emp.__password)  # AttributeError: 'Employee' object has no attribute '__password'
# emp.__private_method()  # AttributeError: 'Employee' object has no attribute '__private_method'

8. 总结

作者：蜡笔小电芯