Python中类和类、对象和对象的关系

一、类与类之间的关系

1. 继承/泛化 (Inheritance/Generalization)

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("子类必须实现speak方法")

class Dog(Animal):  # Dog 继承 Animal
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    
    def speak(self):
        return f"{self.name} says: Woof!"

class Cat(Animal):  # Cat 继承 Animal
    def speak(self):
        return f"{self.name} says: Meow!"

# 使用
dog = Dog("Buddy", "Golden Retriever")
cat = Cat("Whiskers")
print(dog.speak())  # Buddy says: Woof!
print(cat.speak())  # Whiskers says: Meow!

2. 实现 (Realization) - 使用抽象基类

from abc import ABC, abstractmethod

class Vehicle(ABC):  # 抽象基类，相当于接口
    @abstractmethod
    def start(self):
        pass
    
    @abstractmethod
    def stop(self):
        pass

class Car(Vehicle):  # Car 实现 Vehicle 接口
    def start(self):
        return "Car starting with key ignition"
    
    def stop(self):
        return "Car stopping with brakes"

class Bicycle(Vehicle):  # Bicycle 实现 Vehicle 接口
    def start(self):
        return "Bicycle starting by pedaling"
    
    def stop(self):
        return "Bicycle stopping by braking"

# 使用
vehicles = [Car(), Bicycle()]
for vehicle in vehicles:
    print(vehicle.start())

3. 组合 (Composition) - 强拥有关系

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower
    
    def start(self):
        return f"Engine with {self.horsepower}HP starting"

class Car:
    def __init__(self, brand, horsepower):
        self.brand = brand
        # 组合关系：Car负责创建Engine，生命周期一致
        self.engine = Engine(horsepower)
    
    def start(self):
        return f"{self.brand}: {self.engine.start()}"

# 使用
car = Car("Toyota", 150)
print(car.start())
# 当car对象被销毁时，其engine对象也会被销毁

4. 聚合 (Aggregation) - 弱拥有关系

class Teacher:
    def __init__(self, name, subject):
        self.name = name
        self.subject = subject
    
    def __str__(self):
        return f"Teacher {self.name} ({self.subject})"

class School:
    def __init__(self, name):
        self.name = name
        self.teachers = []  # 聚合关系：老师可以独立于学校存在
    
    def add_teacher(self, teacher):
        self.teachers.append(teacher)
    
    def list_teachers(self):
        return [str(teacher) for teacher in self.teachers]

# 使用
# 老师对象可以独立创建和存在
teacher1 = Teacher("Mr. Smith", "Math")
teacher2 = Teacher("Ms. Johnson", "Science")

school = School("Central High")
school.add_teacher(teacher1)
school.add_teacher(teacher2)

print(f"{school.name} teachers: {school.list_teachers()}")
# 即使school不存在了，teacher1和teacher2仍然存在

5. 关联 (Association) - 结构性连接

class Student:
    def __init__(self, name, student_id):
        self.name = name
        self.student_id = student_id
        self.courses = []  # 关联到Course
    
    def enroll(self, course):
        self.courses.append(course)
        course.add_student(self)  # 双向关联
    
    def __str__(self):
        return f"Student {self.name} (ID: {self.student_id})"

class Course:
    def __init__(self, name, code):
        self.name = name
        self.code = code
        self.students = []  # 关联到Student
    
    def add_student(self, student):
        self.students.append(student)
    
    def list_students(self):
        return [str(student) for student in self.students]

# 使用 - 建立关联关系
math_course = Course("Mathematics", "MATH101")
student1 = Student("Alice", "S001")
student2 = Student("Bob", "S002")

# 建立双向关联
student1.enroll(math_course)
student2.enroll(math_course)

print(f"{math_course.name} students: {math_course.list_students()}")

6. 依赖 (Dependency) - 临时使用关系

class EmailService:
    @staticmethod
    def send_email(to, message):
        return f"Sending email to {to}: {message}"

class NotificationManager:
    # 依赖关系：NotificationManager 依赖 EmailService
    def send_notification(self, user, message):
        # EmailService作为工具被临时使用
        result = EmailService.send_email(user.email, message)
        return result

class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

# 使用
user = User("John", "john@example.com")
notifier = NotificationManager()
print(notifier.send_notification(user, "Welcome to our service!"))

二、对象与对象之间的关系

1. 依赖关系 (运行时)

class OrderProcessor:
    def process_order(self, order, payment_processor):
        # order和payment_processor是临时依赖
        print(f"Processing order: {order.id}")
        payment_processor.charge(order.amount)
        return f"Order {order.id} processed"

class PaymentProcessor:
    def charge(self, amount):
        return f"Charged ${amount}"

class Order:
    def __init__(self, order_id, amount):
        self.id = order_id
        self.amount = amount

# 运行时建立依赖关系
order = Order("ORD001", 100.0)
processor = OrderProcessor()
payment = PaymentProcessor()

# processor对象临时依赖order和payment对象
result = processor.process_order(order, payment)
print(result)

2. 关联关系 (运行时)

class Department:
    def __init__(self, name):
        self.name = name
        self.employees = []  # 运行时建立关联
    
    def add_employee(self, employee):
        self.employees.append(employee)
        employee.department = self  # 双向关联

class Employee:
    def __init__(self, name, emp_id):
        self.name = name
        self.emp_id = emp_id
        self.department = None  # 运行时建立关联

# 运行时建立关联关系
hr_dept = Department("HR")
engineering_dept = Department("Engineering")

emp1 = Employee("Alice", "E001")
emp2 = Employee("Bob", "E002")

# 建立对象间的关联
hr_dept.add_employee(emp1)
engineering_dept.add_employee(emp2)

print(f"{emp1.name} works in {emp1.department.name}")
print(f"{emp2.name} works in {emp2.department.name}")

3. 聚合关系 (运行时)

class Project:
    def __init__(self, name):
        self.name = name
        self.team_members = []  # 聚合关系
    
    def add_member(self, employee):
        self.team_members.append(employee)
    
    def get_team_info(self):
        return [f"{emp.name} ({emp.specialty})" for emp in self.team_members]

class Developer:
    def __init__(self, name, specialty):
        self.name = name
        self.specialty = specialty

# 运行时建立聚合关系
# 开发者对象可以独立存在
dev1 = Developer("Carol", "Backend")
dev2 = Developer("David", "Frontend")
dev3 = Developer("Eve", "Database")

website_project = Project("Website Redesign")
website_project.add_member(dev1)
website_project.add_member(dev2)

api_project = Project("API Development") 
api_project.add_member(dev1)  # 同一个开发者可以在多个项目
api_project.add_member(dev3)

print(f"Website team: {website_project.get_team_info()}")
print(f"API team: {api_project.get_team_info()}")

4. 组合关系 (运行时)

class Computer:
    def __init__(self, brand):
        self.brand = brand
        # 组合关系：电脑创建时同时创建组件
        self.cpu = CPU("Intel i7")
        self.memory = Memory(16)  # GB
        self.storage = Storage(512)  # GB
    
    def get_specs(self):
        return f"{self.brand}: {self.cpu}, {self.memory}, {self.storage}"

class CPU:
    def __init__(self, model):
        self.model = model
    
    def __str__(self):
        return f"CPU {self.model}"

class Memory:
    def __init__(self, size_gb):
        self.size_gb = size_gb
    
    def __str__(self):
        return f"RAM {self.size_gb}GB"

class Storage:
    def __init__(self, size_gb):
        self.size_gb = size_gb
    
    def __str__(self):
        return f"Storage {self.size_gb}GB"

# 使用
my_computer = Computer("Dell")
print(my_computer.get_specs())
# 当my_computer对象被销毁时，其cpu、memory、storage对象也会被销毁

综合示例：完整的系统模型

# 综合演示多种关系
from abc import ABC, abstractmethod
from datetime import datetime

# 继承 + 实现
class Person(ABC):
    def __init__(self, name, id_number):
        self.name = name
        self.id_number = id_number
    
    @abstractmethod
    def get_role(self):
        pass

class Student(Person):
    def __init__(self, name, id_number, major):
        super().__init__(name, id_number)
        self.major = major
        self.enrolled_courses = []  # 关联
    
    def get_role(self):
        return "Student"
    
    def enroll_in_course(self, course):
        self.enrolled_courses.append(course)
        course.add_student(self)

class Professor(Person):
    def __init__(self, name, id_number, department):
        super().__init__(name, id_number)
        self.department = department
        self.taught_courses = []  # 关联
    
    def get_role(self):
        return "Professor"
    
    def assign_to_course(self, course):
        self.taught_courses.append(course)
        course.professor = self  # 双向关联

# 组合
class University:
    def __init__(self, name):
        self.name = name
        # 组合关系：大学创建时创建核心部门
        self.registry = Registry()
        self.library = Library()
        self.departments = []  # 聚合关系
    
    def add_department(self, department):
        self.departments.append(department)

# 聚合
class Department:
    def __init__(self, name):
        self.name = name
        self.professors = []  # 聚合
        self.courses = []     # 组合
    
    def add_professor(self, professor):
        self.professors.append(professor)
    
    def create_course(self, code, name):
        course = Course(code, name, self)
        self.courses.append(course)
        return course

# 关联
class Course:
    def __init__(self, code, name, department):
        self.code = code
        self.name = name
        self.department = department  # 关联
        self.professor = None         # 关联
        self.students = []            # 关联
    
    def add_student(self, student):
        self.students.append(student)
    
    def get_course_info(self):
        professor_name = self.professor.name if self.professor else "TBA"
        return f"{self.code} - {self.name} (Prof: {professor_name}, Students: {len(self.students)})"

# 组合中的部分类
class Registry:
    def __init__(self):
        self.records = []
    
    def add_record(self, record):
        self.records.append(record)

class Library:
    def __init__(self):
        self.books = []
    
    def add_book(self, book):
        self.books.append(book)

# 依赖
class GradeCalculator:
    @staticmethod
    def calculate_average(grades):
        return sum(grades) / len(grades) if grades else 0

# 使用完整的系统
university = University("Tech University")

# 创建部门
cs_department = Department("Computer Science")
university.add_department(cs_department)

# 创建人员
prof_smith = Professor("Dr. Smith", "P001", cs_department)
student_alice = Student("Alice", "S001", "Computer Science")
student_bob = Student("Bob", "S002", "Computer Science")

# 建立关联
cs_department.add_professor(prof_smith)

# 创建课程
python_course = cs_department.create_course("CS101", "Python Programming")

# 建立教学关系
prof_smith.assign_to_course(python_course)
student_alice.enroll_in_course(python_course)
student_bob.enroll_in_course(python_course)

# 使用依赖关系
grades = [85, 92, 78]
average = GradeCalculator.calculate_average(grades)
print(f"Average grade: {average}")

# 输出系统状态
print(f"\nUniversity: {university.name}")
print(f"Course: {python_course.get_course_info()}")
print(f"Students in course: {[s.name for s in python_course.students]}")

这些示例清晰地展示了Python中各种类关系和对象关系的实现方式。关键区别在于：

· 类关系：关注代码结构、继承层次、成员变量类型
· 对象关系：关注运行时对象间的引用和交互模式