面向对象编程基础

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它通过抽象和封装现实世界中的事物，使用类（class）和对象（object）的概念来组织代码。相比于过程化编程，OOP 更加关注数据与行为的结合，通过封装、继承和多态三个特性来实现代码的复用性、灵活性和扩展性。

封装（Encapsulation）

封装是指将数据（属性）和操作这些数据的方法捆绑在一起，形成一个独立的单元（类），并对外提供接口来访问这些数据和方法。这样可以隐藏实现细节，只暴露必要的接口，从而提高代码的安全性和可维护性。

继承（Inheritance）

继承是指一个类（子类）可以继承另一个类（父类）的属性和方法，从而重用和扩展父类的功能。子类可以继承父类的所有成员（属性和方法），也可以添加自己的属性和方法，甚至可以重写父类的方法来实现不同的功能。

多态（Polymorphism）

多态是指一个接口可以有多种实现形式，即不同的对象可以对同一个消息作出不同的响应。多态使得代码更加灵活，可以在运行时动态地决定调用哪个对象的方法。

类的定义

类是面向对象编程中的基本构造单元，它定义了一组属性和方法，这些属性和方法描述了对象的特征和行为。类的定义包括类名、属性和方法。

class Animal:
    # 类属性
    species = 'mammal'

    # 初始化方法（构造函数）
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 实例方法
    def make_sound(self):
        print(f"{self.name} makes a sound.")

    # 类方法
    @classmethod
    def get_species(cls):
        return cls.species

    # 静态方法
    @staticmethod
    def is_adult(age):
        return age >= 18

对象的定义

对象是类的实例化，通过类定义的属性和方法，可以创建具体的对象。对象有自己的属性值和行为，可以通过对象的方法来访问和修改这些属性。

# 创建对象
dog = Animal('Doggy', 5)

# 调用实例方法
dog.make_sound()  # 输出: Doggy makes a sound.

# 调用类方法
print(Animal.get_species())  # 输出: mammal

# 调用静态方法
print(Animal.is_adult(20))  # 输出: True

实例属性与类属性

实例属性是属于对象的属性，每个对象都有自己独立的实例属性。类属性是属于类的属性，所有对象共享同一个类属性。

class Car:
    # 类属性
    brand = 'Toyota'

    def __init__(self, model, color):
        self.model = model
        self.color = color

    # 实例方法
    def describe(self):
        print(f"This is a {self.color} {self.brand} {self.model}.")

    # 修改类属性
    @classmethod
    def set_brand(cls, new_brand):
        cls.brand = new_brand

# 创建对象
car1 = Car('Corolla', 'blue')
car2 = Car('Camry', 'red')

# 调用实例方法
car1.describe()  # 输出: This is a blue Toyota Corolla.
car2.describe()  # 输出: This is a red Toyota Camry.

# 修改类属性
Car.set_brand('Honda')

# 再次调用实例方法
car1.describe()  # 输出: This is a blue Honda Corolla.
car2.describe()  # 输出: This is a red Honda Camry.

构造函数

构造函数是类中的一种特殊方法，当创建对象时自动调用。构造函数通常用于初始化对象的属性。

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

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

# 创建对象
person = Person('Alice', 25)

# 调用方法
person.introduce()  # 输出: Hello, my name is Alice and I am 25 years old.

继承

继承是面向对象编程中的一个重要特性，它允许一个类继承另一个类的属性和方法。子类可以从父类继承所有属性和方法，并可以添加自己的属性和方法，甚至可以重写父类的方法。

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

    def make_sound(self):
        print(f"{self.name} makes a sound.")

class Dog(Animal):
    def make_sound(self):
        print(f"{self.name} barks.")

    def wag_tail(self):
        print(f"{self.name} wags its tail.")

# 创建对象
dog = Dog('Buddy', 3)

# 调用方法
dog.make_sound()    # 输出: Buddy barks.
dog.wag_tail()      # 输出: Buddy wags its tail.

多态

多态是指一个接口可以有多种实现形式。父类定义的方法可以被子类重写，从而实现不同的功能。多态使得代码更具灵活性，可以在运行时动态地决定调用哪个对象的方法。

class Animal:
    def make_sound(self):
        print("An animal makes a sound.")

class Dog(Animal):
    def make_sound(self):
        print("A dog barks.")

class Cat(Animal):
    def make_sound(self):
        print("A cat meows.")

# 创建对象
dog = Dog()
cat = Cat()

# 调用方法
dog.make_sound()  # 输出: A dog barks.
cat.make_sound()  # 输出: A cat meows.

抽象类

抽象类是一种不能直接实例化的类，它主要用于定义一组抽象方法，这些方法在子类中必须被实现。抽象类可以包含普通方法和抽象方法，抽象方法没有实现体。

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("A dog barks.")

# 创建对象
dog = Dog()
dog.make_sound()  # 输出: A dog barks.

接口

接口是一种特殊的抽象类，它只包含抽象方法，不包含普通方法。接口主要用于定义一组方法的签名，子类必须实现这些方法。

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

    @abstractmethod
    def move(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("A dog barks.")

    def move(self):
        print("A dog moves.")

# 创建对象
dog = Dog()
dog.make_sound()  # 输出: A dog barks.
dog.move()        # 输出: A dog moves.

属性的封装

封装是指将数据（属性）和操作这些数据的方法捆绑在一起，形成一个独立的单元（类），并对外提供接口来访问这些数据和方法。封装可以隐藏实现细节，只暴露必要的接口。

class BankAccount:
    def __init__(self, account_number, balance):
        self.__account_number = account_number  # 私有属性
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount > self.__balance:
            print("Insufficient funds.")
        else:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

# 创建对象
account = BankAccount('123456', 1000)

# 调用方法
account.deposit(500)
print(account.get_balance())  # 输出: 1500

account.withdraw(2000)
print(account.get_balance())  # 输出: 1500
account.withdraw(1000)
print(account.get_balance())  # 输出: 500

方法的封装

封装不仅可以隐藏属性，还可以隐藏实现细节。通过封装方法，可以控制对象的行为，确保数据的一致性和安全。

class Temperature:
    def __init__(self, value):
        self.__value = value

    def celsius_to_fahrenheit(self):
        return (self.__value * 9/5) + 32

    def fahrenheit_to_celsius(self):
        return (self.__value - 32) * 5/9

# 创建对象
temp = Temperature(100)

# 调用方法
print(temp.celsius_to_fahrenheit())  # 输出: 212.0
temp.__value = 32
print(temp.fahrenheit_to_celsius())  # 输出: 0.0

代码的复用性

面向对象编程通过封装、继承和多态等特性，使得代码更加模块化和可重用。类和对象的定义可以被多次使用，减少了代码的重复。

class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

# 创建对象
rectangle = Rectangle(5, 10)
circle = Circle(7)

# 调用方法
print(rectangle.area())  # 输出: 50
print(circle.area())     # 输出: 153.86

代码的灵活性和扩展性

面向对象编程使得代码更加灵活，可以根据需求动态地扩展功能。通过继承和多态，可以方便地添加新的类和方法，而无需修改现有的代码。

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

    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print(f"{self.name} barks.")

class Cat(Animal):
    def make_sound(self):
        print(f"{self.name} meows.")

# 创建对象
dog = Dog('Buddy')
cat = Cat('Whiskers')

# 调用方法
dog.make_sound()  # 输出: Buddy barks.
cat.make_sound()  # 输出: Whiskers meows.

# 新增一个类
class Duck(Animal):
    def make_sound(self):
        print(f"{self.name} quacks.")

# 创建对象
duck = Duck('Donald')
duck.make_sound()  # 输出: Donald quacks.

代码的可维护性

封装和抽象使得代码更加清晰和模块化，从而提高了代码的可维护性。通过封装，可以隐藏实现细节，只暴露必要的接口，使得代码更易于理解和维护。

class BankAccount:
    def __init__(self, account_number, balance):
        self.__account_number = account_number
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount > self.__balance:
            print("Insufficient funds.")
        else:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

# 创建对象
account = BankAccount('123456', 1000)

# 调用方法
account.deposit(500)
print(account.get_balance())  # 输出: 1500

account.withdraw(2000)
print(account.get_balance())  # 输出: 1500
account.withdraw(1000)
print(account.get_balance())  # 输出: 500

示例1：创建一个简单的图形类

定义一个Shape类，它有一个area方法，用于计算图形的面积。然后定义Rectangle和Circle两个子类，分别计算矩形和圆形的面积。

class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

# 创建对象
rectangle = Rectangle(5, 10)
circle = Circle(7)

# 调用方法
print(rectangle.area())  # 输出: 50
print(circle.area())     # 输出: 153.86

示例2：创建一个简单的动物类

定义一个Animal类，它有一个make_sound方法，用于打印出动物发出的声音。然后定义Dog和Cat两个子类，分别实现不同的make_sound方法。

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("Barks.")

class Cat(Animal):
    def make_sound(self):
        print("Meows.")

# 创建对象
dog = Dog()
cat = Cat()

# 调用方法
dog.make_sound()  # 输出: Barks.
cat.make_sound()  # 输出: Meows.

示例3：创建一个简单的银行账户类

定义一个BankAccount类，它有两个属性account_number和balance，以及deposit、withdraw和get_balance方法，用于管理账户余额。

class BankAccount:
    def __init__(self, account_number, balance):
        self.__account_number = account_number
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount > self.__balance:
            print("Insufficient funds.")
        else:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

# 创建对象
account = BankAccount('123456', 1000)

# 调用方法
account.deposit(500)
print(account.get_balance())  # 输出: 1500

account.withdraw(2000)
print(account.get_balance())  # 输出: 1500
account.withdraw(1000)
print(account.get_balance())  # 输出: 500

示例4：创建一个简单的温度类

定义一个Temperature类，它有两个方法celsius_to_fahrenheit和fahrenheit_to_celsius，用于在摄氏度和华氏度之间进行转换。

class Temperature:
    def __init__(self, value):
        self.__value = value

    def celsius_to_fahrenheit(self):
        return (self.__value * 9/5) + 32

    def fahrenheit_to_celsius(self):
        return (self.__value - 32) * 5/9

# 创建对象
temp = Temperature(100)

# 调用方法
print(temp.celsius_to_fahrenheit())  # 输出: 212.0
temp.__value = 32
print(temp.fahrenheit_to_celsius())  # 输出: 0.0

面向对象编程是一种强大的编程范式，它通过封装、继承和多态等特性来组织代码。封装可以隐藏实现细节，提高代码的安全性和可维护性。继承和多态使得代码更加模块化和灵活，可以方便地扩展和复用代码。在实际编程中，面向对象编程可以使代码更加清晰和易于维护，是现代软件开发的主流范式。