做网上竞猜网站合法吗,安徽网站开发推荐,上海市工程建设检测网,装修公司做网站好做吗Concept-概念前置
设计模式#xff1a;软件设计中普遍存在#xff08;反复出现#xff09;的各种问题#xff0c;所提出的解决方案。
面向对象三大特性#xff1a;封装、继承、多态。 面向对象设计的SOLID原则#xff1a; #xff08;1#xff09;开放封闭原则#…Concept-概念前置
设计模式软件设计中普遍存在反复出现的各种问题所提出的解决方案。
面向对象三大特性封装、继承、多态。 面向对象设计的SOLID原则 1开放封闭原则一个软件实体如类、模块和函数应该对扩展开放对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。
2里氏替换原则所有引用父类的地方必须能透明地使用其子类的对象。
3依赖倒置原则高层模块不应该依赖低层模块二者都应该依赖其抽象 抽象不应该依赖细节细节应该依赖抽象。
4接囗隔离原则使用多个专门的接口而不使用单一的总接口即客户端不应该依赖那些它不需要的接口。 5单一职责原则不要存在多于一个导致类变更的原因即一个类只负责一项职责。 举个例子可能有不止一块代码调用到该实体这时候去修改实体里的代码就很可能引起其他模块会出现问题当模块关联较多时就会引起不必要的工作量这是1
原方法支持父类当我们在基础上加或修改功能而衍生的子类也应当符合这是2
要针对接口编程 而不是针对实现编程实现上也就是对底层的依赖按接口格式去写再实现而不是随意修改参数格式即3。 创建型模式
简单工厂模式工厂方法模式抽象工厂模式创建者模式原型模式单例模式。 创建型模式Creational Pattern一种用于 创建对象 的设计模式。它们包含一些通用的方法更加灵活地创建对象且 封装 了对象的实例化过程工厂模式Factory Pattern 用于根据 客户端需求动态创建 对象。 包括简单工厂模式工厂方法模式抽象工厂模式 单例模式Singleton Pattern 用于确保一个类 只有一个 实例并提供对该实例的全局访问点。它通常被用于管理共享资源或者限制系统中某些类的实例数量。 建造者模式Builder Pattern 用于将一个复杂对象的 构建过程分离 成多个简单的步骤从而可以灵活地组合和构建不同的对象。它通常被用于创建复杂的对象比如包含多个组件或者配置项的对象。 原型模式Prototype Pattern用于 复制或克隆 已有的对象从而创建新的对象。它通过克隆现有对象来创建新对象从而避免了昂贵的初始化操作。 工厂模式
Factory Pattern
简单工厂模式Simple Factory Pattern简单工厂模式是一种基本的工厂模式通常由一个工厂类根据传入的参数动态决定创建哪种产品类的实例。简单而言一个工厂类根据传入参数创建哪个类实例场景适用于对象较少且产品等级结构稳定的情况。 Characters: 工厂角色Factory 抽象产品角色Product 具体产品角色Concrete Productclass Product:def use(self):passclass ConcreteProductA(Product):def use(self):print(Using product A.)class ConcreteProductB(Product):def use(self):print(Using product B.)class Factory:staticmethoddef create_product(product_type):if product_type A:return ConcreteProductA()elif product_type B:return ConcreteProductB()product_a Factory.create_product(A)
product_a.use() # 输出Using product A.product_b Factory.create_product(B)
product_b.use() # 输出Using product B.
工厂方法模式Factory Method Pattern将实际创建对象的工作推迟到子类中完成。可以在不修改工厂类的情况下增加新的产品系列和产品等级结构。简单而言工厂类抽象化将增改操作下发给子类场景: 工厂方法模式适用于对象数量较多且产品等级结构较为复杂的情况。Characters: 工厂角色Factory 具体工厂角色Concrete Factory 抽象产品角色Product 具体产品角色Concrete Product
class Product:def use(self):passclass ConcreteProductA(Product):def use(self):print(Using product A.)class ConcreteProductB(Product):def use(self):print(Using product B.)class Factory:def create_product(self):passclass ConcreteFactoryA(Factory):def create_product(self):return ConcreteProductA()class ConcreteFactoryB(Factory):def create_product(self):return ConcreteProductB()factory_a ConcreteFactoryA()
product_a factory_a.create_product()
product_a.use() # 输出Using product A.factory_b ConcreteFactoryB()
product_b factory_b.create_product()
product_b.use() # 输出Using product B.
抽象工厂模式Abstract Factory Pattern是一种将工厂类进行抽象化的进一步改进它使用了对象组合的方式来构建不同的产品族。工厂抽象化组合各种产品有点像工厂方法模式的不同类方法组合
场景: 抽象工厂模式可以同时创建多个不同的产品且这些产品之间存在着一定的关联性。
Characters: 工厂角色Factory 具体工厂角色Concrete Factory 抽象产品角色Product 具体产品角色Concrete Product 客户端Client
class ProductA:def use(self):passclass ConcreteProductA1(ProductA):def use(self):print(Using product A1.)class ConcreteProductA2(ProductA):def use(self):print(Using product A2.)class ProductB:def operate(self):passclass ConcreteProductB1(ProductB):def operate(self):print(Operating product B1.)class ConcreteProductB2(ProductB):def operate(self):print(Operating product B2.)class Factory:def create_product_a(self):passdef create_product_b(self):passclass ConcreteFactory1(Factory):def create_product_a(self):return ConcreteProductA1()def create_product_b(self):return ConcreteProductB1()class ConcreteFactory2(Factory):def create_product_a(self):return ConcreteProductA2()def create_product_b(self):return ConcreteProductB2()factory_1 ConcreteFactory1()
product_a1 factory_1.create_product_a()
product_a1.use() # 输出Using product A1.
product_b1 factory_1.create_product_b()
product_b1.operate() # 输出Operating product B1.factory_2 ConcreteFactory2()
product_a2 factory_2.create_product_a()
product_a2.use() # 输出Using product A2.
product_b2 factory_2.create_product_b()
product_b2.operate() # 输出Operating product B2. 单例模式
Singleton Pattern
保证一个类仅有一个实例并提供访问该实例的全局访问点。
class Singleton:__instance Nonedef __new__(cls):if cls.__instance is None:cls.__instance object.__new__(cls)return cls.__instances1 Singleton()
s2 Singleton()
print(s1 is s2) # 输出True 》 说明唯一性 建造者模式
Builder Pattern
将一个复杂对象的构建过程分离成多个简单的步骤
场景: 灵活地组合和构建不同的对象。Characters:产品类Product 抽象建造者类Builder具体建造者类ConcreteBuilder 指挥者类Director
class Product:def __init__(self):self.part_a Noneself.part_b Noneclass Builder:def build_part_a(self):passdef build_part_b(self):passdef get_result(self):passclass ConcreteBuilder1(Builder):def __init__(self):self.product Product()def build_part_a(self):self.product.part_a Part A1def build_part_b(self):self.product.part_b Part B1def get_result(self):return self.productclass ConcreteBuilder2(Builder):def __init__(self):self.product Product()def build_part_a(self):self.product.part_a Part A2def build_part_b(self):self.product.part_b Part B2def get_result(self):return self.productclass Director:def __init__(self, builder):self.builder builderdef construct(self):self.builder.build_part_a()self.builder.build_part_b()return self.builder.get_result()builder_1 ConcreteBuilder1()
director_1 Director(builder_1)
product_1 director_1.construct()
print(fProduct 1: {product_1.part_a}, {product_1.part_b}) # 输出Product 1: Part A1, Part B1builder_2 ConcreteBuilder2()
director_2 Director(builder_2)
product_2 director_2.construct()
print(fProduct 2: {product_2.part_a}, {product_2.part_b}) # 输出Product 2: Part A2, Part B2 原型模式
Prototype Pattern
允许通过复制现有对象来创建新的对象而无需重新实例化。Think: 定义一个抽象原型类包含了用于复制自身的抽象方法 clone()。然后定义具体的原型类。在客户端代码中可以通过调用具体对象 clone() 方法来创建新的对象而无需重新实例化。注意深浅拷贝问题
import copyclass Prototype:def clone(self):return copy.deepcopy(self)class ConcretePrototype1(Prototype):def __init__(self, attr):self.attr attrclass ConcretePrototype2(Prototype):def __init__(self, attr):self.attr attrif __name__ __main__:prototype_1 ConcretePrototype1(attr_1)prototype_2 ConcretePrototype2(attr_2)clone_1 prototype_1.clone()clone_2 prototype_2.clone()print(fOriginal: ({prototype_1.attr}, {prototype_2.attr})) # 输出Original: (attr_1, attr_2)print(fClone: ({clone_1.attr}, {clone_2.attr})) # 输出Clone: (attr_1, attr_2)
