目录
一、对象的关联
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.