黄山网站建设找哪家,做网站域名的成本,吴川市规划建设局网站,广告人网站创建型模式与对象的创建有关。 创建型模式抽象了对象实例化的过程#xff0c;这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式#xff0c;而不是使用 new 运算符直接实例化对象。创建型模式有以下
工厂模式#xff08;Factory Method#xff09;
意图#xf…创建型模式与对象的创建有关。 创建型模式抽象了对象实例化的过程这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式而不是使用 new 运算符直接实例化对象。创建型模式有以下
工厂模式Factory Method
意图定义一个用于创建对象的接口 让子类决定实例化哪一个类 代码示例
# 抽象产品类 - Shape
class Shape:def draw(self):pass# 具体产品类 - Circle
class Circle(Shape):def draw(self):print(Drawing a circle)# 具体产品类 - Rectangle
class Rectangle(Shape):def draw(self):print(Drawing a rectangle)# 工厂类 - ShapeFactory
class ShapeFactory:def create_shape(self, shape_type):if shape_type.lower() circle:return Circle()elif shape_type.lower() rectangle:return Rectangle()return None# 客户端代码
shape_factory ShapeFactory()# 创建一个圆形对象
circle shape_factory.create_shape(circle)
circle.draw() # 输出Drawing a circle# 创建一个矩形对象
rectangle shape_factory.create_shape(rectangle)
rectangle.draw() # 输出Drawing a rectangle
在这个示例中Shape是抽象产品类Circle和Rectangle是具体产品类。ShapeFactory是工厂类其中的create_shape方法根据传入的参数决定实例化哪个具体产品类来创建对象。客户端代码通过调用工厂类的方法来创建具体的产品对象并调用其draw方法进行绘制。
抽象工厂模式Abstract Factory
意图提供一个创建一系列相互依赖对象的接口而无需指定他们具体的类 基于工厂模式的改良工厂模式包括抽象产品类、具体产品类、工厂类 抽象工厂模式的包括 抽象产品类、具体产品类、抽象工厂类、具体工厂类
# 抽象工厂接口
class AbstractFactory:def create_engine(self):passdef create_tire(self):pass# 具体工厂实现类 - 奔驰工厂
class BenzFactory(AbstractFactory):def create_engine(self):return BenzEngine()def create_tire(self):return BenzTire()# 具体工厂实现类 - 宝马工厂
class BMWFactory(AbstractFactory):def create_engine(self):return BMWEngine()def create_tire(self):return BMWTire()# 抽象产品接口 - 引擎
class Engine:def description(self):pass# 具体产品类 - 奔驰引擎
class BenzEngine(Engine):def description(self):return This is a Benz engine.# 具体产品类 - 宝马引擎
class BMWEngine(Engine):def description(self):return This is a BMW engine.# 抽象产品接口 - 轮胎
class Tire:def description(self):pass# 具体产品类 - 奔驰轮胎
class BenzTire(Tire):def description(self):return This is a Benz tire.# 具体产品类 - 宝马轮胎
class BMWTire(Tire):def description(self):return This is a BMW tire.# 客户端代码
def client(factory):engine factory.create_engine()tire factory.create_tire()print(engine.description())print(tire.description())# 使用奔驰工厂创建产品
benz_factory BenzFactory()
client(benz_factory)# 使用宝马工厂创建产品
bmw_factory BMWFactory()
client(bmw_factory)
在上面的示例中AbstractFactory 是抽象工厂接口定义了创建产品的方法。BenzFactory 和 BMWFactory 是具体工厂实现类分别负责创建奔驰和宝马汽车的引擎和轮胎。Engine 和 Tire 是抽象产品接口定义了产品的方法。BenzEngine、BMWEngine、BenzTire 和 BMWTire 是具体产品类分别实现了奔驰和宝马汽车的引擎和轮胎。
客户端代码可以通过传入不同的具体工厂实例来创建不同品牌的汽车引擎和轮胎并使用它们的方法。
抽象工厂方法模式可以方便地扩展产品系列例如添加奥迪工厂和奥迪产品类只需要新增对应的工厂和产品类即可。
单例模式Singleton
意图保证一个类仅只有一个实例并提供一个他的全局访问点
# 单例类 - Logger
class Logger:_instance Nonedef __init__(self):# 私有构造函数防止外部实例化passclassmethoddef get_instance(cls):if not cls._instance:cls._instance Logger()return cls._instancedef log(self, message):print(Logging:, message)# 客户端代码
logger1 Logger.get_instance()
logger1.log(Message 1) # 输出Logging: Message 1logger2 Logger.get_instance()
logger2.log(Message 2) # 输出Logging: Message 2print(logger1 is logger2) # 输出True两个实例是同一个对象
在这个示例中Logger是单例类它的构造函数被声明为私有以防止外部实例化。通过get_instance方法获取该类的唯一实例。客户端代码通过调用get_instance方法来获取日志记录器的实例并调用其log方法记录日志。由于单例模式的特性无论多少次调用get_instance方法都会返回同一个实例。
构建器模式Builder
意图将对象的构建过程与其表示分离使得同样的构建过程可以创建不同的表示。
# 产品类 - 电脑
class Computer:def __init__(self):self.cpu Noneself.memory Noneself.storage Nonedef set_cpu(self, cpu):self.cpu cpudef set_memory(self, memory):self.memory memorydef set_storage(self, storage):self.storage storagedef display(self):print(fCPU: {self.cpu})print(fMemory: {self.memory})print(fStorage: {self.storage})# 建造者接口
class Builder:def build_cpu(self):passdef build_memory(self):passdef build_storage(self):passdef get_computer(self):pass# 具体建造者类 - 游戏电脑建造者
class GamingComputerBuilder(Builder):def __init__(self):self.computer Computer()def build_cpu(self):self.computer.set_cpu(Intel i7)def build_memory(self):self.computer.set_memory(16GB DDR4)def build_storage(self):self.computer.set_storage(1TB SSD)def get_computer(self):return self.computer# 具体建造者类 - 办公电脑建造者
class OfficeComputerBuilder(Builder):def __init__(self):self.computer Computer()def build_cpu(self):self.computer.set_cpu(Intel i5)def build_memory(self):self.computer.set_memory(8GB DDR4)def build_storage(self):self.computer.set_storage(500GB HDD)def get_computer(self):return self.computer# 指挥者类
class Director:def __init__(self, builder):self.builder builderdef construct(self):self.builder.build_cpu()self.builder.build_memory()self.builder.build_storage()# 客户端代码
gaming_builder GamingComputerBuilder()
director Director(gaming_builder)
director.construct()
gaming_computer gaming_builder.get_computer()
gaming_computer.display()office_builder OfficeComputerBuilder()
director Director(office_builder)
director.construct()
office_computer office_builder.get_computer()
office_computer.display()
在上面的示例中Computer 是产品类表示电脑对象。Builder 是建造者接口定义了构建电脑的方法。GamingComputerBuilder 和 OfficeComputerBuilder 是具体建造者类分别负责构建游戏电脑和办公电脑。Director 是指挥者类负责控制建造过程。
客户端代码可以通过创建不同的具体建造者实例并通过指挥者来构建不同类型的电脑对象。使用建造者模式可以方便地构建具有不同配置的电脑对象而无需直接调用产品类的构造函数或者繁琐地设置每个属性。
原型模式Prototype
意图原型实例指定创建对象的种类并且通过复制这些原型创建新的对象
import copy# 原型接口
class Prototype:def clone(self):pass# 具体原型类 - 矩形
class Rectangle(Prototype):def __init__(self, width, height):self.width widthself.height heightdef set_width(self, width):self.width widthdef set_height(self, height):self.height heightdef clone(self):return copy.deepcopy(self)def __str__(self):return fRectangle [width{self.width}, height{self.height}]# 客户端代码
if __name__ __main__:# 创建原型对象rectangle Rectangle(10, 20)# 克隆原型对象cloned_rectangle rectangle.clone()print(Cloned Rectangle:, cloned_rectangle)# 修改克隆对象的属性cloned_rectangle.set_width(15)cloned_rectangle.set_height(25)print(Modified Cloned Rectangle:, cloned_rectangle)
在 Python 中我们使用 copy 模块的 deepcopy() 函数来实现对象的深拷贝以克隆原型对象。然后我们可以通过调用克隆对象的方法来修改其属性。
需要注意的是Python 中的类不需要显式地实现接口因此我们只需定义一个基类 Prototype然后在具体原型类 Rectangle 中重写 clone() 方法即可。
附加知识
1. python中classmethod是什么有什么作用
使用方式等同于Java中的静态方法 在 Python 中classmethod 是一个装饰器Decorator用于定义一个类方法。类方法是与类相关联的方法而不是与类的实例相关联的方法。
类方法使用装饰器 classmethod 来标识并且第一个参数通常被命名为 cls表示类本身。与实例方法不同类方法可以直接通过类名调用而不需要创建类的实例。
classmethod 的作用主要有以下几点
允许在不创建类的实例的情况下调用方法。这对于执行与类相关的操作非常有用例如创建类级别的工厂方法。允许在类方法内部访问类的属性和其他类方法而无需使用实例。提供一种约定使得代码更易读和理解因为它明确指示该方法是一个类方法。 下面是一个使用 classmethod 定义类方法的示例
class MyClass:count 0def __init__(self):MyClass.count 1classmethoddef get_instance_count(cls):return cls.count在上面的示例中get_instance_count() 是一个类方法它返回创建的 MyClass 实例的数量。你可以通过类名直接调用该方法而不需要创建类的实例
print(MyClass.get_instance_count()) # 输出: 0obj1 MyClass()
print(MyClass.get_instance_count()) # 输出: 1obj2 MyClass()
print(MyClass.get_instance_count()) # 输出: 22. python中类中的__init__ 和其他方法执行顺序
在 Python 中类的方法执行顺序主要取决于方法的调用方式和继承关系。下面是一般情况下常见的执行顺序
定义类时会先执行类体中的代码包括属性和方法的定义。 当创建类的实例时会自动调用__init__方法作为构造函数用于初始化对象的属性。 在实例化过程中如果类定义了父类则会先执行父类的 __init__ 方法然后再执行子类的 __init__ 方法。 在实例化后可以通过实例调用类的其他方法。 以下是一个示例来说明执行顺序
class Parent:def __init__(self):print(Parents __init__)def method(self):print(Parents method)class Child(Parent):def __init__(self):super().__init__() # 先执行父类的 __init__print(Childs __init__)def method(self):super().method() # 调用父类的 methodprint(Childs method)child Child()
输出结果
Parents __init__
Childs __init__在上面的示例中首先创建了 Child 类的实例 child。在实例化过程中由于 Child 类继承自 Parent 类因此会先执行父类 Parent 的__init__方法然后再执行子类 Child 的__init__方法。最终输出结果中可以看到先打印了 “Parent’s init”然后才打印了 “Child’s init”。
深拷贝Deep Copy和浅拷贝Shallow Copy
浅拷贝是指创建一个新对象然后将原始对象的非静态字段的值复制到新对象中。如果字段是基本类型则复制其值如果字段是引用类型则复制引用而不是实际对象。这意味着原始对象和浅拷贝对象会共享相同的引用对象。如果修改了引用对象的属性则原始对象和浅拷贝对象都会受到影响。
深拷贝是指创建一个新对象并递归地复制原始对象及其所有引用对象的内容。这意味着原始对象和深拷贝对象拥有相同的值但是它们引用的是不同的对象实例。修改深拷贝对象或其引用对象的属性不会影响原始对象。
下面是一个示例来说明浅拷贝和深拷贝的区别
import copyclass Person:def __init__(self, name, address):self.name nameself.address addressdef setAddress(self, address):self.address addressdef getAddress(self):return self.addressdef __str__(self):return fPerson [name{self.name}, address{self.address}]class Address:def __init__(self, city):self.city citydef setCity(self, city):self.city citydef __str__(self):return fAddress [city{self.city}]# 客户端代码
if __name__ __main__:address Address(New York)person1 Person(John, address)# 浅拷贝person2 copy.copy(person1)print(Shallow Copy:)print(person1:, person1)print(person2:, person2)# 修改引用对象的属性person2.getAddress().setCity(London)print(After modifying reference object:)print(person1:, person1)print(person2:, person2)print()# 深拷贝deepCopiedAddress Address(address.getCity())person3 Person(person1.name, deepCopiedAddress)print(Deep Copy:)print(person1:, person1)print(person3:, person3)# 修改引用对象的属性person3.getAddress().setCity(Paris)print(After modifying reference object:)print(person1:, person1)print(person3:, person3)
在上述代码中我们定义了一个 Person 类和一个 Address 类。Person 类包含一个引用类型字段 address它引用了 Address 对象。
首先我们创建了一个原始对象 person1然后通过浅拷贝创建了一个新对象 person2。可以看到person1 和 person2 的引用字段 address 指向同一个 Address 对象。因此当我们修改 person2 的引用对象的属性时person1 的引用对象也会受到影响。
接下来我们使用深拷贝创建了 person3 对象。通过 copy.copy() 函数复制 person1 对象时只是创建了一个新的 Person 对象但仍然共享相同的 Address 对象。而通过 copy.deepcopy() 函数进行深拷贝时会递归地复制所有引用对象的内容因此 person3 的引用对象是一个新的 Address 对象。
最后我们修改了 person3 的引用对象的属性并打印出原始对象 person1 和深拷贝对象 person3可以看到它们的引用对象不再共享相同的值。
