Python深入面向对象

目录

一、对象的关联

1. 对象拥有属性（简单关联）

2、组合 

3、 聚合 (Aggregation)

4.、依赖 (Dependency)

二、重写 

三、静态方法

四、类属性

五、类方法

六、类对象

---

一、对象的关联

1. 对象拥有属性（简单关联）

这是最简单的形式，一个类中的对象包含对另一个类的对象的引用。

# 示例：
class Employee: #创建类
    def __init__(self, name):  #初始化__init__方法，接受self和name两个参数
        self.name = name #设置了一个实例的属性name

class Department: #创建类
    def __init__(self, name, manager): #初始化__init__方法
        self.name = name #设置实例
        self.manager = manager

# 创建对象
manager = Employee("Alice") #创建Employee的新实例，并将参数"Alice"赋给manager
dept = Department("Engineering", manager) #创建Employee的新实例，并将参数"Engineering"赋给dept 而 manager 属性则被设置为前面创建的 manager 对象。

2、组合 

组合是一种特殊形式的关联，表示“整体-部分”的关系。部分对象只能存在于整体对象之中，当整体被销毁时，部分也必须被销毁。

# 示例
class Engine: #创建类
    def start(self): #设置了一个方法
        print("Engine started.") #当调用start方法时会打印Engine started

class Car: #创建类
    def __init__(self): #初始化__init__
        self.engine = Engine() #当创建了Car实例时，构造方法会创建一个Engine实例，并赋给engine

    def start(self): #设置方法
        self.engine.start() #当Car实例调用start方法时，他会调用存在engine的实例Engine中的start方法

car = Car() #创建Car实例
car.start() #调用start方法，这里调用的是Car类的方法

3、 聚合 (Aggregation)

聚合也是一种“整体-部分”关系，但部分可以独立于整体存在，并且可以在不同的整体之间共享。

# 示例：
class Tire:
    def __init__(self, brand):
        self.brand = brand

class Car:
    def __init__(self, tires):
        self.tires = tires

    def display_tires(self):
        return [t.brand for t in self.tires] #列表推导式

tire1 = Tire("BrandX")
tire2 = Tire("BrandY")
car = Car([tire1, tire2]) #创建了一个 `Car` 实例 `car`，并将 `tire1` 和 `tire2` 作为一个列表传递给 `Car` 的构造函数。

print(car.display_tires())

4.、依赖 (Dependency)

依赖是指一个对象使用另一个对象提供的服务，但没有拥有关系。这通常通过方法调用来实现。

class Printer:
    def print_document(self, document):
        print(f"Printing {document}")

class Document:
    def __init__(self, content):
        self.content = content

doc = Document("Hello World")
printer = Printer()
printer.print_document(doc.content) #调用了 printer 实例的 print_document 方法，并将 doc.content 作为参数传递。

二、重写 

子类可以提供与父类相同名称的方法，但具有不同的实现细节。这使得子类能够改变或扩展父类的行为。

# 示例：
class Document:
    def __init__(self, content):
        self.content = content

    def get_content(self):
        return self.content


class PrintableDocument(Document): #继承了Document类
    def __str__(self):
        return f"Printable Document: {self.get_content()}" #调用get_content()方法


class Printer:
    def print_document(self, document):
        print(f"Printing {document}")


doc = Document("Hello World") #创建实例，给参数
printable_doc = PrintableDocument("Hello World, this is a printable document.") #创建实例，给参数

printer = Printer() #创建实例

printer.print_document(doc)  # 输出: Printing <__main__.Document object at 0x...>
printer.print_document(printable_doc)  # 输出: Printing Printable Document: Hello World, this is a printable document.

三、静态方法

静态方法是一种不需要访问或修改类的状态的方法。

静态方法的特点：
不需要实例化：静态方法可以通过类名直接调用，无需创建类的实例。
没有 self 参数：静态方法的第一个参数不是 self 或 cls，因为它不依赖于类的状态。
装饰器语法：通常使用 @staticmethod 装饰器来声明一个静态方法。

# 示例：
class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b


# 使用静态方法
result_add = MathUtils.add(5, 3)
result_multiply = MathUtils.multiply(5, 3)

print(f"5 + 3 = {result_add}")  # 输出: 5 + 3 = 8
print(f"5 * 3 = {result_multiply}")  # 输出: 5 * 3 = 15

四、类属性

类属性是属于类本身的属性，而不是类的实例的属性。类属性由所有类的实例共享，并且可以通过类名直接访问。

类属性的特点：
共享性：类属性对于所有实例都是相同的，除非你明确地为某个实例创建了一个同名的实例属性。
访问方式：可以通过类名直接访问类属性，也可以通过类的实例访问。
命名空间：类属性位于类的命名空间中，而实例属性位于每个实例的命名空间中。

# 示例：
class Employee:
    # 类属性
    company_name = "XYZ Corp"

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

    def display_info(self):
        print(f"{self.name} works as a {self.position} at {Employee.company_name}")

# 创建 Employee 实例
employee1 = Employee("Alice", "Developer")
employee2 = Employee("Bob", "Manager")

# 访问类属性
print(Employee.company_name)  # 输出: XYZ Corp
print(employee1.company_name)  # 输出: XYZ Corp
print(employee2.company_name)  # 输出: XYZ Corp

# 修改类属性
Employee.company_name = "ABC Inc"

# 再次访问类属性
print(Employee.company_name)  # 输出: ABC Inc
print(employee1.company_name)  # 输出: ABC Inc
print(employee2.company_name)  # 输出: ABC Inc

# 修改实例的类属性
employee1.company_name = "DEF Tech"

# 再次访问类属性
print(Employee.company_name)  # 输出: ABC Inc
print(employee1.company_name)  # 输出: DEF Tech
print(employee2.company_name)  # 输出: ABC Inc

# 使用 display_info 方法
employee1.display_info()  # 输出: Alice works as a Developer at DEF Tech
employee2.display_info()  # 输出: Bob works as a Manager at ABC Inc

五、类方法

类方法是一种特殊的类型的方法，它绑定到类而不是类的实例。类方法可以访问和修改类的状态，并且通常用于替代构造函数或者执行与类相关联的操作。

类方法的特点：
类绑定：类方法绑定到类，而不是实例。这意味着你可以通过类名直接调用类方法，而无需创建类的实例。
cls 参数：类方法的第一个参数通常命名为 cls，表示该方法接收类本身作为第一个参数。这使得类方法可以访问和修改类的状态。
装饰器语法：通常使用 @classmethod 装饰器来声明一个类方法。

# 示例：
class Circle:
    pi = 3.14159  # 类属性

    def __init__(self, radius):
        self.radius = radius

    @classmethod
    def from_diameter(cls, diameter):
        """创建一个 Circle 实例，给定直径而不是半径"""
        return cls(diameter / 2)

    def area(self):
        """计算圆的面积"""
        return Circle.pi * (self.radius ** 2)

    def circumference(self):
        """计算圆的周长"""
        return 2 * Circle.pi * self.radius

# 使用类方法
circle1 = Circle.from_diameter(10)
print(f"Circle with diameter 10 has radius: {circle1.radius}")
print(f"Area: {circle1.area()}")  # 输出: Area: 78.53975
print(f"Circumference: {circle1.circumference()}")  # 输出: Circumference: 31.4159

# 直接使用类名访问类属性
print(Circle.pi)  # 输出: 3.14159

六、类对象

类对象是一个非常重要的概念，它是定义类时创建的对象，用于创建类的实例。

类对象的特点：
可实例化：你可以使用类对象创建类的实例。
可调用：类对象可以像函数一样被调用，这实际上是创建类的实例的过程。
属性和方法：类对象可以拥有自己的属性和方法，这些被称为类属性和类方法。
元编程：你可以通过操作类对象来进行元编程，例如动态创建类或修改类的行为。

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

    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 类的实例
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# 访问类属性
print(Person.species)  # 输出: Homo sapiens

# 访问实例属性
print(person1.name)  # 输出: Alice
print(person2.age)  # 输出: 30

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