工厂方法模式和简单工厂模式
Python中的工厂模式
Python中的工厂模式工厂模式（Factory Pattern）是一种常用的设计模式，用于创建对象。
它属于创建型模式，通过定义一个工厂类负责创建其他对象的实例，而不必直接使用new关键字来创建对象。
工厂模式使得代码的可拓展性和复用性更好，同时也隐藏了对象的创建和实现细节，简化了客户端的操作。
工厂模式的核心思想是将对象的实例化操作封装起来，让客户端只需调用工厂方法即可创建所需的对象。
从而达到降低系统耦合度的目的。
工厂模式的实现方式有两种：一种是通过一个单独的工厂类来创建所需的对象，另一种是通过将工厂方法定义在需要创建对象的类中。
其中，单独的工厂类又可以分为简单工厂和工厂方法两种模式。
1.简单工厂模式简单工厂模式（Simple Factory Pattern），也叫静态工厂模式，由一个工厂类负责创建所有需要的产品类的实例。
客户端只需向该工厂类传递相应的参数，即可获取所需的对象。
该模式下，工厂类通常是一个静态类或者包含一个静态方法的类。
简单工厂模式的代码结构如下：```class Product:def __init__(self):passclass ProductA(Product):def __init__(self):print("Product A")class ProductB(Product):def __init__(self):print("Product B")class SimpleFactory:def create_product(self, product_type):if product_type == "A":return ProductA()elif product_type == "B":return ProductB()factory = SimpleFactory()productA = factory.create_product("A")productB = factory.create_product("B")```该代码中，类Product、ProductA、ProductB分别为抽象产品类、具体产品类。
工厂模式分类
⼯⼚模式分类
⼯⼚模式实现了创建者和调⽤者分离，⼯⼚模式分为简单⼯⼚、⼯⼚⽅法、抽象⼯⼚模式。
⼯⼚模式好处
⼯⼚模式是我们最常⽤的实例化对象模式了，是⽤⼯⼚⽅法代替new操作的⼀种模式。
利⽤⼯⼚模式可以降低程序的耦合性，为后期的维护修改提供了很⼤的便利。
将选择实现类、创建对象统⼀管理和控制。
从⽽将调⽤者跟我们的实现类解耦。
简单⼯⼚模式
简单⼯⼚设计模式相当于是⼀个⼯⼚中有各种不同的产品，创建在⼀个类中，调⽤者⽆需知道具体产品的名称，只需要知道产品类所对应的参数即可。
但是⼯⼚的职责过重，⽽且当类型过多时不利于系统的扩展维护。
（⽐如：汽车⼚不管什么牌⼦的汽车都创造，利⽤简单⼯⼚模式实现，我需要⼀辆车⼦）。
分别创造⽐亚迪和哈佛汽车
简单⼯⼚模式应⽤场景
优点：⼯⼚类含有必要的判断逻辑，调⽤者给出信息后通过⼯⼚类来决定在什么时候创建哪⼀个产品类的实例，客户端可以免除直接创建产品对象的责任，⽽仅仅“消费”产品；简单⼯⼚模式通过这种做法实现了对责任的分割，它提供了专门的⼯⼚类⽤于创建对象，有利于整个软件体系结构的优化。
缺点：由于⼯⼚类集中了所有实例的创建逻辑，违反了⾼内聚责任分配原则，将全部创建逻辑集中到了⼀个⼯⼚类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变⼯⼚类了。
当系统中的具体产品类不断增多时候，可能会出现要求⼯⼚类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在⼀起，很难避免模块功能的蔓延，对系统的维护和扩展⾮常不利；
⼯⼚⽅法：。
软件开发几种设计模式
抽象工厂 ：
用来生产不同产品族的全部固定产品； 可以增加新产品族（不同产品的组合），但不能增加新产品； 不同产品族通过不同的工厂类生成，一个类中有多个成员函数去
生成不同具体产品。
简单工厂
特点：
简单工厂模式的工厂类一般使用静态方法生成产品对象，通过输 入参数的不同来返回不同对象实例。
个工厂就生产一个品牌的所有轿车、货车和客车。 增加新的产品线（已有产品的组合）很容易，但是无法增加新的产品。
工厂模式
工厂模式中，重要的是工厂类，而不是产品类。
产品类可以是多种形式。 但要明确，工厂模式的接口只会返回一种类型的实
例。 所以在设计产品类时要注意，一般是返回父类或者
共同实现的接口。
单例模式
特点：
通过静态函数来生成唯一实例。 构造函数是私有的。
其主要功能都是帮助我们把对象的实例化部分 抽取出来，优化系统架构，增强系统扩展性。
工厂模式
主要作用
抽象了对象的构造过程，即生成对象的过程。
使得具有
可以具有一个共同的
或者统一的生成方法。避免了总是写几乎完全
重复的构造函数，生成功能差不多的对象。
注意：
类似功能的对象并不是完全相同的对象。它们 虽然大体类似，但是确有具体差别。
使用工厂模式，返回的实例一定是工厂创建的， 而不是从其它对象中获取的。
工厂模式返回的实例可以不是新创建的，返回 由工厂创建好的实例也可以。
单例模式 （Singleton Pattern）
单例模式
主要作用
保证一个类仅有一个实例，并提供一个访问它 的全局访问点。
简单地说，就是代替全局对象。
几种设计模式
工厂业务逻辑
工厂业务逻辑
工厂模式是一种设计模式，它在软件开发中的“业务逻辑”主要体现在对象创建的过程中。
在复杂的系统中，通常会有多个类可以实现同一接口或者继承自同一个抽象类，具体使用哪个类来实例化对象需要根据运行时的条件决定。
这时，我们可以定义一个工厂类（或方法）来封装这个创建过程，隐藏了创建逻辑的复杂性，并使得代码更加灵活、易于扩展和维护。
以工厂业务逻辑为例：
1. 简单工厂模式：
- 定义一个工厂类，提供一个静态方法（或实例方法），接收参数并根据参数返回不同的产品实例。
- 例如，有一个`AnimalFactory`，通过传入字符串类型参数如"dog"或"cat"，返回对应的`Dog`或`Cat`对象实例。
2. 工厂方法模式：
- 定义一个抽象工厂类，其中声明一个创建产品的抽象方法，由其子类来实现具体的创建逻辑。
- 如有`AnimalFactory`抽象类，其中包含`createAnimal()`抽象方法，然后分别创建`DogFactory`和`CatFactory`子类，它们各自重写`createAnimal()`方法，返回相应的`Dog`或`Cat`对象实例。
3. 抽象工厂模式：
- 提供一个接口用于创建相关或依赖对象家族的多个对象，而无需指定具体的产品类。
- 假设存在不同类型的动物及其对应的食物，可以创建一个`PetFactory`抽象工厂，它能生产出某一特定种类的宠物及其专属食物。
工厂模式的业务逻辑就是围绕如何根据需求动态选择和创建合适对象来进行组织和设计，从而降低耦合度，提高代码的灵活性和可扩展性。
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别简单工厂、工厂方法、抽象工厂以及策略模式在软件开发中都是常用的设计模式，它们都是为了解决不同对象的创建和使用问题。
下面将对它们进行详细的介绍，并比较它们之间的区别。
1. 简单工厂模式（Simple Factory Pattern）：简单工厂模式是由一个工厂类根据传入的参数决定创建哪种产品的设计模式。
它包含三个角色：工厂类负责创建产品，产品类定义产品的具体实现，客户端通过工厂类获取产品对象。
简单工厂模式将对象的创建与使用进行了分离，增加了灵活性，但是违反了开闭原则，因为每次新增产品都需要修改工厂类。
2. 工厂方法模式（Factory Method Pattern）：工厂方法模式是指定义一个创建产品对象的接口，但是由子类决定实例化哪个类。
这样可以将产品的实例化延迟到子类中进行，满足了开闭原则。
工厂方法模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
具体工厂类负责创建具体产品类的实例，抽象产品类定义了产品的接口。
客户端通过抽象工厂类获取产品对象。
工厂方法模式解决了简单工厂模式的缺点，但是增加了类的个数。
3. 抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式是指提供一个创建一系列相关或互相依赖对象的接口，而无需指定具体的类。
抽象工厂模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
抽象工厂类定义了创建产品的接口，具体工厂类负责创建具体产品。
抽象产品类定义了产品的接口，具体产品类实现了产品的具体实现。
客户端通过抽象工厂类获取产品对象。
抽象工厂模式提供了一种创建一系列产品对象的方法，但是增加新产品时需要修改所有的工厂类。
4. 策略模式（Strategy Pattern）：策略模式是指定义了一系列的算法，并将每个算法封装起来，使得它们可以互相替换，使得算法的选择和使用可以独立于客户端。
策略模式由抽象策略类、具体策略类和环境类组成。
简单工厂模式,工厂方法模式和抽象工厂模式的异同
简单工厂模式，工厂方法模式和抽象工厂模式的异同简单工厂模式，工厂方法模式和抽象工厂模式都是属于创建型设计模式，这三种创建型模式都不需要知道具体类。
我们掌握一种思想，就是在创建一个对象时，需要把容易发生变化的地方给封装起来，来控制变化（哪里变化，封装哪里），以适应客户的变动，项目的扩展。
用这三种设计模式都可以实现，那究竟这三种设计模式有什么异同呢？下面根据这三者之间的特点，优点，缺点，适用范围进行比较。
一．特点简单工厂模式：专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
它又称为静态工厂方法模式。
它的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。
简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。
在这个模式中，工厂类是整个模式的关键所在。
它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。
用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。
有利于整个软件体系结构的优化。
工厂方法模式：工厂方法是粒度很小的设计模式，因为模式的表现只是一个抽象的方法。
提前定义用于创建对象的接口，让子类决定实例化具体的某一个类，即在工厂和产品中间增加接口，工厂不再负责产品的创建，由接口针对不同条件返回具体的类实例，由具体类实例去实现。
工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。
首先完全实现‘开－闭原则’，实现了可扩展。
其次实现更复杂的层次结构，可以应用于产品结果复杂的场合。
工厂方法模式是对简单工厂模式进行了抽象。
有一个抽象的Factory类（可以是抽象类和接口），这个类将不在负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。
在这个模式中，工厂类和产品类往往可以依次对应。
即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。
面向对象设计的23个设计模式详解
面向对象设计的23个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。
在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。
本文将对23种常见的设计模式进行详解。
一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。
在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。
简单工厂模式适合于对象创建过程较为简单的情况。
2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。
工厂方法模式适合于对象创建过程较为复杂的情况。
它可以为工厂类添加新的产品类型，而不会影响原有的代码。
3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。
在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。
4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。
在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。
5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。
在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。
原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。
二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。
在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。
7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。
Spring中的八大设计模式
Spring中的⼋⼤设计模式⼀、简单⼯⼚模式 ⼜叫做静态⼯⼚⽅法(StaticFactory Method)模式，但不属于23种GOF设计模式之⼀。
简单⼯⼚模式的实质是由⼀个⼯⼚类根据传⼊的参数，动态决定应该创建哪⼀个产品类。
spring中的BeanFactory就是简单⼯⼚模式的体现，根据传⼊⼀个唯⼀的标识来获得bean对象，但是否是在传⼊参数后创建还是传⼊参数前创建这个要根据具体情况来定。
⼆、⼯⼚⽅法模式 通常由应⽤程序直接使⽤new创建新的对象，为了将对象的创建和使⽤相分离，采⽤⼯⼚模式,即应⽤程序将对象的创建及初始化职责交给⼯⼚对象。
⼀般情况下,应⽤程序有⾃⼰的⼯⼚对象来创建bean.如果将应⽤程序⾃⼰的⼯⼚对象交给Spring管理,那么Spring管理的就不是普通的bean,⽽是⼯⼚Bean。
三、单例模式 保证⼀个类仅有⼀个实例，并提供⼀个访问它的全局访问点。
spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。
但没有从构造器级别去控制单例，这是因为spring管理的是是任意的java对象。
四、适配器模式 在Spring的Aop中，使⽤的Advice(通知)来增强被代理类的功能。
Spring实现这⼀AOP功能的原理就使⽤代理模式对类进⾏⽅法级别的切⾯增强，即，⽣成被代理类的代理类，并在代理类的⽅法前，设置拦截器，通过执⾏拦截器重的内容增强了代理⽅法的功能，实现的⾯向切⾯编程。
五、包装器模式 spring中⽤到的包装器模式在类名上有两种表现：⼀种是类名中含有Wrapper，另⼀种是类名中含有Decorator。
基本上都是动态地给⼀个对象添加⼀些额外的职责。
六、代理模式 为其他对象提供⼀种代理以控制对这个对象的访问。
从结构上来看和Decorator模式类似，但Proxy是控制，更像是⼀种对功能的限制，⽽Decorator是增加职责。
七、观察者模式 定义对象间的⼀种⼀对多的依赖关系，当⼀个对象的状态发⽣改变时，所有依赖于它的对象都得到通知并被⾃动更新。
设计模式-创建型模式的优缺点比较
比较几种创建型模式的优缺点，仔细考察这几种模式的区别和相关性。
第一类是工厂模式，工厂模式专门负责将大量有共同接口的类实例化。
工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。
工厂模式有三种形态：简单工厂模式；工厂方法模式；抽象工厂模式是。
前两者是类的创建模式，后者是对象的创建模式。
简单工厂：简单工厂模式是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例，涉及工厂角色(Creator)、抽象产品(Product)角色及具体产品(Concrete Product)角色等三个角色。
优点：模式的核心是工厂类，该类中含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅负责“消费”产品。
简单工厂模式实现了对责任的分割。
缺点：当产品类有复杂的多层次等级结构时，工厂类只有它自己。
模式中工厂类集中了所有的产品创建逻辑，形成一个无所不知的全能类。
将多个创建逻辑放在一个类中，当产品类有不同接口种类时，工厂类需要判断在什么时候创建某种产品，使得系统在将来进行功能扩展时较为困难。
该模式采用静态方法作为工厂方法，而静态方法无法由子类继承，因此工厂角色无法形成基于继承的等级结构。
简单工厂模式只在有限的程度上符合“开-闭”原则。
工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
Factory Method使一个类的实例化延迟到其子类。
工厂方法模式是简单工厂模式的进一步抽象和推广，其基本思想是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
优点：多态性：客户代码可以做到与特定应用无关，适用于任何实体类子类可以重写新的实现，也可以继承父类的实现。
加一层间接性，增加了灵活性。
良好的封装性，代码结构清晰。
扩展性好，在增加产品类的情况下，只需要适当修改具体的工厂类或扩展一个工厂类，就可“拥抱变化”屏蔽产品类。
产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
设计模式实验报告-工厂模式
实验二：工厂模式实验内容简单工厂方法模式：利用简单工厂方法模式创建pad, phone, watch的对象，并使用这些对象娱乐。
工厂模式：利用工厂模式创建pad, phone, watch的对象，并使用这些对象娱乐。
抽象工厂模式：利用抽象工厂模式创建华为、小米、苹果的pad, phone, watch的对象，并使用这些对象娱乐。
简单工厂方法模式设计图1简单工厂模式类图核心代码ConsumerElectronics.java核心代码Pad.java核心代码Watch.java核心代码Phone.java核心代码ConsumerElectronicsFactory.java核心代码实现效果图 2 简单工厂模式实现效果图工厂模式设计图 3 工厂模式类图核心代码ConsumerElectronicsFactory.java核心代码PadFactory.java核心代码WatchFactory.java核心代码PhoneFactory.java核心代码实现效果图4 工厂模式实现效果图抽象工厂模式设计图5抽象工厂模式类图核心代码AbstractFactory.java核心代码AppleFactory.java核心代码HuaweiFactory.java核心代码MiFactory.java核心代码实现效果图 6 抽象工厂模式实现效果图实验体会做完这次试验，下面是我的一些体会：首先，工厂模式是为了解耦：把对象的创建和使用的过程分开。
其次，工厂模式可以降低代码重复。
如果创建对象的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。
我们可以这些创建对象的代码放到工厂里统一管理。
既减少了重复代码，也方便以后对该对象的创建过程的修改维护。
由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要逐个修正，只需要在工厂里修改即可，降低维护成本。
另外，因为工厂管理了对象的创建逻辑，使用者并不需要知道具体的创建过程，只管使用即可，减少了使用者因为创建逻辑导致的错误。
简单工厂 工厂方法
简单工厂工厂方法
简单工厂模式和工厂方法模式是两种不同的设计模式，它们在实现方式和适用场景上有所区别。
简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。
简单工厂模式适用于工厂负责的对象比较少，且客户只关心传入工厂的参数，而不关心如何创建对象的情况。
工厂方法模式定义了一个创建产品对象的工厂接口，将实际创建工作推迟到子类中。
这种模式的优点是核心类成为抽象工厂角色，不再负责产品的创建，仅负责具体工厂子类必须实现的接口，使得系统在不修改具体工厂角色的情况下引进新的产品。
工厂方法模式适用于具体工厂角色和抽象工厂角色分离的情况，使得系统更加灵活和可扩展。
总的来说，简单工厂和工厂方法都是创建型设计模式，用于处理对象的创建问题。
但简单工厂模式是一种更简单、直接的对象创建方式，而工厂方法模式则更加强调抽象和多态的应用，使系统更加灵活和可扩展。
在实际应用中，可以根据需要选择合适的设计模式。
工厂模式简介和应用场景
⼯⼚模式简介和应⽤场景⼀、简介⼯⼚模式主要是为创建对象提供了接⼝。
⼯⼚模式按照《Java与模式》中的提法分为三类：1. 简单⼯⼚模式(Simple Factory)2. ⼯⼚⽅法模式(Factory Method)3. 抽象⼯⼚模式(Abstract Factory)⼆、简单⼯⼚模式我喜欢吃⾯条，抽象⼀个⾯条基类，(接⼝也可以)，这是产品的抽象类。
public abstract class INoodles {/*** 描述每种⾯条啥样的*/public abstract void desc();}先来⼀份兰州拉⾯（具体的产品类）：public class LzNoodles extends INoodles {@Overridepublic void desc() {System.out.println("兰州拉⾯上海的好贵家⾥才5 6块钱⼀碗");}}程序员加班必备也要吃泡⾯（具体的产品类）：public class PaoNoodles extends INoodles {@Overridepublic void desc() {System.out.println("泡⾯好吃可不要贪杯");}}还有我最爱吃的家乡的⼲扣⾯（具体的产品类）：public class GankouNoodles extends INoodles {@Overridepublic void desc() {System.out.println("还是家⾥的⼲扣⾯好吃 6块⼀碗");}}准备⼯作做完了，我们来到⼀家“简单⾯馆”（简单⼯⼚类），菜单如下：public class SimpleNoodlesFactory {public static final int TYPE_LZ = 1;//兰州拉⾯public static final int TYPE_PM = 2;//泡⾯public static final int TYPE_GK = 3;//⼲扣⾯public static INoodles createNoodles(int type) {switch (type) {case TYPE_LZ:return new LzNoodles();case TYPE_PM:return new PaoNoodles();case TYPE_GK:default:return new GankouNoodles();}}}简单⾯馆就提供三种⾯条（产品），你说你要啥，他就给你啥。
软件体系结构—设计模式3.1—简单工厂模式
要提出BadShapeException 异常。
（2）请给出上一题的源代码。 （3）请简单举例说明描图员系统怎样使用。
消费角色无需知道它得到的是哪一个产品；换言之，产品消费角色无需修改 就可以接纳新的产品。
对于工厂角色来说，增加新的产品是一个痛苦的过程。工厂角色必须知道每
一种产品，如何创建它们，以及何时向客户端提供它们。换言之，接纳新的 产品意味着修改这个工厂角色的源代码。
综合本节的讨论，简单工厂角色只在有限的程度上支持“开–闭”原则。
3、多个工厂方法 每个工厂类可以有多于一个的工厂方法，分别负责创建不同的产品对象。 4、抽象产品角色的省略 如果系统仅有一个具体产品角色的话，那么就可以省略掉抽象产品角色。省 略掉抽象产品类后的简略类图如下图所示。
仍然以前面给出的示意性系统为例，这时候系统的类图就变成如下所示。
下面是工厂类的源代码。显然，这个类提供一个工厂方法，返还一个具体产 品类的实例。
简单工厂模式所创建的对象往往属于一个产品等级结构，这个等级结构可以
是MVC模式中的视图（View）；而工厂角色本身可以是控制器
（Controller）。一个MVC 模式可以有一个控制器和多个视图，如下图所示。
换言之，控制器端可以创建合适的视图端，就如同工厂角色创建合适的对象
角色一样；而模型端则可以充当这个创建过程的客户端。 如果系统需要有多个控制器参与这个过程的话，简单工厂模式就不适用了，
简单的情况下，可以简化为一个标识接口。所谓标识接口，就是没有声明任 何方法的空接口。
具体产品类的示意性源代码如下。
2.3简单工厂模式的实现
1、多层次的产品结构 在真实的系统中，产品可以形成复杂的等级结构，比如下图所示的树状结构 上就有多个抽象产品类和具体产品类。
设计模式之工厂模式（3种）详解及代码示例
设计模式之⼯⼚模式（3种）详解及代码⽰例 ⼯⼚模式划分来说总共有三类：简单⼯⼚模式、⼯⼚⽅法模式和抽象⼯⼚模式。
其中简单⼯⼚模式不输⼊23种设计模式之⼀，但他们⼜都属于创建型模式。
我们依次讲解这三种⼯⼚模式。
⼀、简单⼯⼚ 1、什么是简单⼯⼚模式？ ⾸先来说简单⼯⼚，简单⼯⼚模式，⼜叫做静态⼯⼚模式（Static Factory Method），由⼀个⼯⼚对象决定创建出哪⼀种产品类的实例，简单⼯⼚模式的实质是由⼀个⼯⼚类根据传⼊的参数，动态决定应该创建哪⼀个产品类。
属于创建型模式，但不属于GOF23设计模式。
2、简单⼯⼚适⽤场景 ⼯⼚类负责创建的对象⽐较少；客户端（应⽤层）只需要知道传⼊⼯⼚类的参数，对于如何创建对象（逻辑）不关⼼。
3、简单⼯⼚优缺点优点：只需要传⼊⼀个正确的参数，就可以获取你所需要的对象，⽽⽆需知道其细节创建。
缺点：⼯⼚类的职责相对过重，增加新的产品，需要修改⼯⼚类的判断逻辑，违背了开闭原则。
4、简单⼯⼚实现 ⾸先来看类图： 代码实现：public class ShapeFactory {public Shape getShape(String shapeType){if(shapeType.equalsIgnoreCase("circle")){return new Circle();}else if(shapeType.equalsIgnoreCase("rectangle")){return new Rectangle();}else if(shapeType.equalsIgnoreCase("squere")){return new Squere();}return null;}public Shape getShape(Class clazz) throws Exception{return (Shape) clazz.newInstance();}}⼆、⼯⼚⽅法模式 1、什么是⼯⼚⽅法 ⼯⼚⽅法模式（Factory Method），⼜称多态性⼯⼚模式，属于设计模式三⼤分类中的创建型模式，作为抽象⼯⼚模式的孪⽣兄弟，⼯⼚⽅法模式定义了⼀个创建对象的接⼝，但由⼦类决定要实例化的类是哪⼀个，也就是说⼯⼚模式让实例化推迟到⼦类。
常用的设计模式具体实现和相关扩展的方法
常用的设计模式具体实现和相关扩展的方法设计模式是软件开发中经典的解决方案，它们提供了一种可复用的解决方案，以解决常见的软件设计问题。
常用的设计模式包括工厂模式、单例模式、观察者模式等。
本文将介绍这些常用的设计模式的具体实现和相关扩展的方法。
1. 工厂模式工厂模式是一种创建对象的模式，它为客户端提供了一个接口以创建对象，但是具体的类名称并不是在客户端决定的。
工厂模式分为三种类型：简单工厂、工厂方法和抽象工厂。
简单工厂：简单工厂是最基本、最简单的工厂模式，它由一个工厂类根据传入的参数返回不同类的实例。
其优点在于客户端无需关心对象的创建过程，只需知道创建对象的名称即可。
其缺点在于对于新增的类需要修改工厂类的代码，违反了开闭原则。
工厂方法：工厂方法模式通过定义一个创建对象的接口，让子类决定实例化哪一个类。
在工厂方法模式中，客户端不再需要知道所需对象的名称，而是由工厂类负责创建相应的对象。
其优点在于支持新增的类而无需修改工厂类的代码，符合开闭原则。
抽象工厂：抽象工厂模式是一个由多个工厂方法组成的工厂类，它用于创建一系列相关或相互依赖的对象。
抽象工厂模式在工厂方法模式的基础上，增加了对产品族的支持。
其优点在于支持新增的产品族而无需修改工厂类的代码，符合开闭原则。
2. 单例模式单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个访问该实例的全局节点。
单例模式常见的实现方式有懒汉式和饿汉式。
懒汉式：懒汉式是指在需要时才创建单例实例，它的优点在于节省了资源，但是需要考虑线程安全问题。
饿汉式：饿汉式是指在类加载时就创建单例实例，它的优点在于不需要考虑线程安全问题，但是可能会浪费资源。
3. 观察者模式观察者模式是一种行为型模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
当主题对象发生改变时，它的所有依赖者（观察者）都会收到通知并自动更新。
观察者模式的实现方式包括：基于Java内置观察者模式实现、基于自定义接口实现、基于注解实现等。
软件开发中常见的设计模式介绍
软件开发中常见的设计模式介绍在软件开发过程中，设计模式是一种被广泛应用的解决问题的方法。
设计模式可以提供在特定情境中重复使用的可行解决方案，有助于提高代码的可读性、可维护性和重用性。
本文将介绍几种常见的设计模式，包括工厂模式、观察者模式、单例模式和策略模式。
一、工厂模式工厂模式是一种常见的创建型设计模式，用于将对象的实例化过程封装起来。
它通过定义一个共同的接口来创建对象实例，使得客户端调用代码与具体的实现逻辑解耦。
工厂模式可以分为简单工厂模式、工厂方法模式和抽象工厂模式。
简单工厂模式通过一个工厂类来根据传入的参数决定创建哪个具体对象。
它的优点是实现简单，适用于对象类型较少且变化频率低的场景。
但是，当需要添加新的对象类型时，需要修改工厂类的代码，不符合开闭原则。
工厂方法模式通过定义一个抽象的工厂接口，由子类具体实现工厂方法来创建对象。
这种方式实现了对象的创建和使用的解耦，也符合开闭原则。
同时，工厂方法模式也可以在运行时动态地切换具体的子类工厂。
抽象工厂模式通过定义一个抽象的工厂接口，可以创建一组相关的对象。
它可以创建多个产品族的对象，且具有良好的扩展性。
但是，抽象工厂模式也增加了系统的复杂度和理解难度。
二、观察者模式观察者模式是一种常见的行为型设计模式，用于定义对象之间的一对多的依赖关系，使得当一个对象的状态发生变化时，其所依赖的对象都会得到通知并自动更新。
观察者模式分为被观察者和观察者两个角色。
被观察者维护一个观察者列表，并提供注册、移除和通知观察者的方法。
当被观察者的状态发生改变时，会遍历观察者列表，调用每个观察者的更新方法。
观察者接收到通知后，可以进行相应的处理。
观察者模式能够实现对象之间的松耦合，使得被观察者和观察者之间的依赖关系可以动态地建立和解除。
它也符合开闭原则，因为可以在运行时增加新的观察者。
三、单例模式单例模式是一种创建型设计模式，用于限制一个类只能创建一个实例。
它保证在整个应用程序中，只有一个实例存在，并提供了一个全局访问点。
简单工厂、工厂方法、抽象工厂模式实验报告
+
"
=
"
+
图 2 简单计算器使用简单工厂方法
三、将类图修改为如图 3 所示，然后修改程序。
图 1 简单计算器
二、将类图修改为如图 2 所示，然后修改程序。
图 3 简单计算器使用工厂方法模式
实验步骤： （算法描述、源程序、操作步骤和方法）
实验目的与要求：初步了解模式的含义，掌握模式的模型图，弄清模式的适
用条件和优点。达到逐步灵活应用的目的。
签名：某某某 2012 年 3 月 24 日
实验内容：
一、 阅读如下计算器程序， 将实现加减乘除计算功能的四个语句改为调用类实例 来实现。类图如图 1 所示。 import java.util.Scanner; public class Application { public static void main(String[] args) { int numberA,numberB; char oper = '+'; double result=0; Scanner sc = new Scanner(System.in); System.out.println("请输入第一个参与运算的数 numberA=："); numberA = sc.nextInt(); System.out.println("请输入第二个参与运算的数 numberB=："); numberB = sc.nextInt();
实验步骤： （算法描述、源程序、操作步骤和方法）
简单工厂工厂方法抽象工厂模式实验报告模式工厂方法简单工厂工厂方法抽象工厂工厂方法工厂模式简单工厂
工厂设计模式实验报告
一、实验背景工厂设计模式是一种常用的创建型设计模式，其主要目的是将对象的创建和使用分离，使得客户端代码无需关心具体对象的创建过程，只需关注对象的接口和使用方法。
通过工厂设计模式，可以降低系统之间的耦合度，提高代码的可扩展性和可维护性。
本次实验旨在通过实现工厂设计模式，加深对设计模式的理解，并掌握其应用方法。
二、实验目的1. 理解工厂设计模式的基本概念和原理。
2. 掌握工厂设计模式的三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。
3. 学会使用工厂设计模式解决实际问题。
三、实验内容1. 简单工厂模式简单工厂模式由一个工厂类负责创建所有产品的实例。
客户端只需传递一个参数，工厂类即可根据参数创建相应的产品实例。
（1）创建产品接口```javapublic interface Product {void operation();}```（2）创建具体产品类```javapublic class ConcreteProductA implements Product {@Overridepublic void operation() {System.out.println("执行产品A的操作");}}public class ConcreteProductB implements Product {@Overridepublic void operation() {System.out.println("执行产品B的操作");}}```（3）创建简单工厂类```javapublic class SimpleFactory {public static Product createProduct(String type) { if ("A".equals(type)) {return new ConcreteProductA();} else if ("B".equals(type)) {return new ConcreteProductB();}return null;}}```（4）客户端代码```javapublic class Client {public static void main(String[] args) {Product productA = SimpleFactory.createProduct("A");productA.operation();Product productB = SimpleFactory.createProduct("B");productB.operation();}}```2. 工厂方法模式工厂方法模式在简单工厂模式的基础上增加了一个抽象工厂类，具体工厂类继承自抽象工厂类，并实现具体产品的创建。
简单工厂与工厂方法模式的区别
简单工厂与工厂方法模式的区别软件开发中的设计模式是一种特定的解决方案，它可以用来解决一种在软件开发中普遍存在的问题。
在这些模式中，工厂模式是最为广泛使用的模式之一。
在工厂模式中，有两种基本的类型——简单工厂和工厂方法模式。
虽然这两种方法本质上是相同的，但它们之间也存在着一些关键的区别。
## 简单工厂模式简单工厂模式是一种创建型模式，它允许用户根据需要创建一个对象，而不必知道对象的具体类。
这个模式可以有效地将对象创建的过程抽象出来，并把它们放在一个工厂类中，这个工厂类根据用户的输入信息决定应该创建哪个具体的对象。
简单工厂模式的核心是工厂类，它是一个包含多个静态方法的类，这些静态方法根据用户的需求创建不同类型的对象。
例如，在一个汽车制造工厂中，简单工厂模式可以用来创建不同类型的车辆，例如轿车、跑车或 SUV。
用户只需提供所需类型的参数，简单工厂就可以根据当前需求返回相应的实例对象。
以下是简单工厂的实现示例：```class CarFactory {public static Car getCar(String carType) {if (carType == null) {return null;}if (carType.equalsIgnoreCase("SUV")) {return new SUV();}else if (carType.equalsIgnoreCase("sedan")) {return new Sedan();}else if (carType.equalsIgnoreCase("SportsCar")) { return new SportsCar();}return null;}class SUV implements Car {public void drive() {System.out.println("Driving SUV");}}class Sedan implements Car {public void drive() {System.out.println("Driving Sedan");}}class SportsCar implements Car {public void drive() {System.out.println("Driving Sports Car"); }interface Car {void drive();}```在上面的示例中，接口 Car 定义了一个 drive 方法，这个方法用来描述不同的车辆如何行驶。
软件设计模式中的工厂模式
软件设计模式中的工厂模式在软件设计和开发中，模式是一种重要的技术手段，它可以用来解决不同的问题，提高代码的可重用性和可维护性。
工厂模式是一种常用的设计模式，它可以将对象的创建和使用分离开来，使得程序可以更加灵活地处理对象的生成和管理。
本文将介绍工厂模式的相关知识，包括其基本概念、实现方法和应用场景等。
一、基本概念工厂模式是一种创建型模式，其核心思想是将对象的创建过程封装起来，让客户端通过调用工厂类来获取所需的对象。
工厂模式分为三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。
其中，简单工厂模式只有一个工厂类，它根据客户端传递的参数来生成不同的对象；工厂方法模式中，每个对象都有一个对应的工厂类，由客户端决定使用哪个工厂类来创建对象；抽象工厂模式中，一个工厂类可以生成多个产品族的对象，即一组相关的对象。
二、实现方法实现工厂模式需要注意以下几点：1.定义一个工厂接口，用于描述工厂的功能。
2.定义一个工厂类，该类实现工厂接口，并提供一个可以生成对象的方法。
3.定义一个产品接口，用于规范不同类型的产品。
4.定义多个具体产品类，它们都实现产品接口。
5.客户端使用工厂类来生成所需的对象，而不是直接创建对象。
三、应用场景工厂模式适用于以下场景：1.需要大量创建相似对象的情况。
2.需要在不同的环境下生成不同的对象时。
3.需要封装对象的创建过程，提高代码的可维护性和可重用性。
4.需要对客户端隐藏具体的实现细节，从而降低客户端和产品的耦合度。
四、总结工厂模式是一种常用的设计模式，它可以将对象的创建和使用分离开来，使得程序可以更加灵活地处理对象的生成和管理。
工厂模式分为三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。
实现工厂模式需要定义工厂接口、工厂类、产品接口和具体产品类等。
工厂模式适用于需要大量创建相似对象、需要封装对象创建过程或需要隐藏具体实现细节的情况下。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程设计报告设计题目：简单设计模式及应用学院：计算机科学与信息学院专业：软件工程班级：学号：学生姓名：指导教师：年月日一、实训目的及要求∙什么是设计模式∙了解抽象工厂设计模式∙应用简单工厂模式和工厂设计模式二、实训环境windows7操作系统，配置Vc#2010运行环境，安装SQL Server2010数据库管理系统三、实训内容不同的图形具有不同的计算面积和周长的方法，通过选择图行类别获得不同图形面积和周长的计算方法，从而得到图形的面积。
用简单工厂模式和工厂方法模式分别编写程序计算不同图形的面积和周长四、算法描述及实训步骤A简单工厂模式1算法描述定义一个图形基类shaped，从Shaped派生出具体图形类Circle、Rectangular、Triangle、Square。
定义一个产生图形工厂ShapeFactory UML图如下所示2.实训步骤（1）创建一个控制台应用程序，名为GetShaped。
（2）添加一个基类shaped，代码如下public abstract class Shaped{protected string Color;public Shaped(){ ;}public Shaped(string Color){this.Color = Color;}public string GetColor(){return Color;}public abstract double GetArea();public abstract double Getperimeter();}（3）添加一个派生类Circle如下:public class Circle : Shaped{private double Radius;public Circle(string Color, double Radius){this.Color = Color;this.Radius = Radius;}public override double GetArea(){return System.Math.PI * Radius * Radius;}public override double Getperimeter(){return 2.0 * System.Math.PI * Radius;}}(4)添加一个派生类Rectangular如下：public class Rectangular : Shaped{private double Length, Width;public Rectangular(string Color, double Length, double Width){this.Color = Color;this.Length = Length;this.Width = Width;}public override double GetArea(){return Length * Width;}public override double Getperimeter(){return 2.0 * Length + 2.0 * Width;}}（5）添加一个派生类Triangle如下：public class Triangle : Shaped{private double Ed1, Ed2, Ed3;public Triangle(string Color, double Ed1, double Ed2, double Ed3){this.Color = Color;this.Ed1 = Ed1;this.Ed2 = Ed2;this.Ed3 = Ed3;}public override double GetArea(){double p = (Ed1 + Ed2 + Ed3) / 2;return System.Math.Sqrt(p * (p - Ed1) * (p - Ed2) * (p - Ed3));}public override double Getperimeter(){return Ed1 + Ed2 + Ed3;}}（6）添加一个派生类Square如下:public class Square : Shaped{private double Ed0;public Square(string Color, double Ed0){this.Color = Color;this.Ed0 = Ed0;}public override double GetArea(){return Ed0 * Ed0;}public override double Getperimeter(){return Ed0 * 4;}}（7）添加一个图形工厂类ShapeFactory,代码如下：public class ShapeFactory{public static Shaped CreateShape(string shaped){Shaped shap=null;switch(shaped){case"circle":Console.WriteLine("请输入圆的颜色");string Col = Console.ReadLine();Console.WriteLine("请输入圆的半径");Double Rad= Convert.ToDouble ( Console.ReadLine());shap=new Circle(Col,Rad );break;case"rectangular":Console.WriteLine("请输入矩形的颜色");string col = Console.ReadLine();Console.WriteLine("请输入矩形的长和宽");double Len = Convert.ToDouble(Console.ReadLine());double Wid = Convert.ToDouble(Console.ReadLine());shap= new Rectangular(col,Len,Wid);break;case"triangle":Console.WriteLine("请输入三角形的颜色");string Col1 = Console.ReadLine();Console.WriteLine("请输入三角形的三边长"); double Ed1 = Convert.ToDouble(Console.ReadLine());double Ed2 = Convert.ToDouble(Console.ReadLine());double Ed3 = Convert.ToDouble(Console.ReadLine());shap=new Triangle(Col1,Ed1,Ed2,Ed3);break;case"square":Console.WriteLine("请输入正方形的颜色");string Col2 = Console.ReadLine();Console.WriteLine("请输入正方形的边长");double Ed0 = Convert.ToDouble(Console.ReadLine());shap= new Square(Col2,Ed0);break;}return shap;}}（8）创建客户端实类对象。
（9）通过从菜单中选择“生成”→“生成解决方案”，来生成该解决方案。
通过从菜单中选择“调试”→“开始执行（不调试）”选项来执行此应用程序。
B工厂方法模式1.算法描述定义一个抽象图形类Shaped，它拥有计算面积和周长的抽象方法GetArea和GetPerimeter，从Shaped派生出具体类Circle、Rectangular、Triangle、Square。
定义一个抽象图形工厂接口ShapeFactory，用圆形工厂CircleFactory、矩形工厂RectangularFactory、三角形工厂TriangleFactory和正方形工厂SquareFactory具体化抽象图形工厂接口，用来生产具体图形。
UML图如下所示。
2.实训步骤（1）创建一个控制台应用程序，名为GetShaped。
（2）添加一个基类shaped和由它派生出的具体类Circle、Rectangular、Triangle、Square，代码和简单工厂模式相同。
（3）创建一个抽象图形工厂ShapeFactory；（4）分别添加具体图形工厂CircleFactory类、RectangularFactory类、TriangleFactory类、SquareFactory类。
（5）创建客户端实类对象。
（6）通过从菜单中选择“生成”→“生成解决方案”，来生成该解决方案。
通过从菜单中选择“调试”→“开始执行（不调试）”选项来执行此应用程序。
五、调试过程及实训结果1．调试过程中的问题及解决办法（1）无法设置各种图形的边长及颜色。
解决方法:在具体化图形工厂CreateShape中添加输入语句，将输入的值作为参数，传递给构造函数。
（2）在实例化不同图形类的对象时，语句重复繁琐。
解决方法:使用foraech遍历语句进行访问。
2．调试运行结果：两种模式结果相同如下六、总结七、附录程序完整源代码如下//A简单工厂模式using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace uu{class Program{//定义基类Shapepublic abstract class Shaped{protected string Color;public Shaped(){ ;}public Shaped(string Color){this.Color = Color;}public string GetColor(){return Color;}public abstract double GetArea();public abstract double Getperimeter();}//定义Circle类，从Shape类中派生public class Circle : Shaped{private double Radius;public Circle(string Color, double Radius){this.Color = Color;this.Radius = Radius;}public override double GetArea(){return System.Math.PI * Radius * Radius;}public override double Getperimeter(){return 2.0 * System.Math.PI * Radius;}}//定义Rectangular类，从Shape类中派生public class Rectangular : Shaped{private double Length, Width;public Rectangular(string Color, double Length, double Width){this.Color = Color;this.Length = Length;this.Width = Width;}public override double GetArea(){return Length * Width;}public override double Getperimeter(){return 2.0 * Length + 2 * Width;}}//定义Triangle类，从Shape类中派生public class Triangle : Shaped{private double Ed1, Ed2, Ed3;public Triangle(string Color, double Ed1, double Ed2, double Ed3){this.Color = Color;this.Ed1 = Ed1;this.Ed2 = Ed2;this.Ed3 = Ed3;}public override double GetArea(){double p = (Ed1 + Ed2 + Ed3) / 2;return System.Math.Sqrt(p * (p - Ed1) * (p - Ed2) * (p - Ed3));}public override double Getperimeter(){return Ed1 + Ed2 + Ed3;}}//定义Square类，从Shape类中派生public class Square : Shaped{private double Ed0;public Square(string Color, double Ed0){this.Color = Color;this.Ed0 = Ed0;}public override double GetArea(){return Ed0 * Ed0;}public override double Getperimeter(){return Ed0 * 4;}}public class ShapeFactory{public static Shaped CreateShape(string shaped){Shaped shap=null;switch(shaped){case"circle":Console.WriteLine("请输入圆的颜色");string Col = Console.ReadLine();Console.WriteLine("请输入圆的半径");double Rad= Convert.ToDouble ( Console.ReadLine());shap=new Circle(Col,Rad );break;case"rectangular":Console.WriteLine("请输入矩形的颜色");string col = Console.ReadLine();Console.WriteLine("请输入矩形的长和宽");double Len = Convert.ToDouble(Console.ReadLine());double Wid = Convert.ToDouble(Console.ReadLine());shap= new Rectangular(col,Len,Wid);break;case"triangle":Console.WriteLine("请输入三角形的颜色");string Col1 = Console.ReadLine();Console.WriteLine("请输入三角形的三边长"); double Ed1 = Convert.ToDouble(Console.ReadLine());double Ed2 = Convert.ToDouble(Console.ReadLine());double Ed3 = Convert.ToDouble(Console.ReadLine());shap=new Triangle(Col1,Ed1,Ed2,Ed3);break;case"square":Console.WriteLine("请输入正方形的颜色");string Col2 = Console.ReadLine();Console.WriteLine("请输入正方形的边长");double Ed0 = Convert.ToDouble(Console.ReadLine());shap= new Square(Col2,Ed0);break;}return shap;}}static void Main(string[] args){string[] shapefactory = new string[4];shapefactory[0] = "circle";shapefactory[1] = "rectangular";shapefactory[2] = "triangle";shapefactory[3] = "square";foreach (string SF in shapefactory){Shaped shaped = ShapeFactory.CreateShape(SF);Console.WriteLine("shaped Color is {0},shaped Area is {1},shaped Perimeter is{2}",shaped.GetColor(),shaped.GetArea(), shaped.Getperimeter());}}}}//B工厂方法模式using System;using System.Collections.Generic;using System.Linq;using System.Text;namespace ConsoleApplication1{//定义基类Shapepublic abstract class Shaped{protected string Color;public Shaped(){ ;}public Shaped(string Color){this.Color = Color;}public string GetColor(){return Color;}public abstract double GetArea();public abstract double Getperimeter();}//定义Circle类，从Shape类中派生public class Circle : Shaped{private double Radius;public Circle(string Color, double Radius) {this.Color = Color;this.Radius = Radius;}public override double GetArea(){return System.Math.PI * Radius * Radius; }public override double Getperimeter(){return 2.0 * System.Math.PI * Radius;}}//定义Rectangular类，从Shape类中派生public class Rectangular : Shaped{private double Length, Width;public Rectangular(string Color, double Length, double Width){this.Color = Color;this.Length = Length;this.Width = Width;}public override double GetArea(){return Length * Width;}public override double Getperimeter(){return 2.0 * Length + 2 .0* Width;}}//定义Triangle类，从Shape类中派生public class Triangle : Shaped{private double Ed1, Ed2, Ed3;public Triangle(string Color, double Ed1, double Ed2, double Ed3){this.Color = Color;this.Ed1 = Ed1;this.Ed2 = Ed2;this.Ed3 = Ed3;}public override double GetArea(){double p = (Ed1 + Ed2 + Ed3) / 2;return System.Math.Sqrt(p * (p - Ed1) * (p - Ed2) * (p - Ed3));}public override double Getperimeter(){return Ed1 +Ed2 + Ed3;}}//定义Square类，从Shape类中派生public class Square : Shaped{private double Ed0;public Square(string Color, double Ed0){this.Color = Color;this.Ed0 = Ed0;}public override double GetArea(){return Ed0 * Ed0;}public override double Getperimeter(){return Ed0 * 4;}}//创建抽象图形工厂ShapeFactoryinterface ShapeFactory{Shaped CreateShape();}//定义圆形工厂CircleFactory类，class CircleFactory : ShapeFactory{public Shaped CreateShape(){Console.WriteLine("请输入圆的颜色");string Col = Console.ReadLine();Console.WriteLine("请输入圆的半径");double Rad= Convert.ToDouble ( Console.ReadLine()); return new Circle(Col,Rad );}}//定义矩形工厂RectangularFactory类class RectangularFactory : ShapeFactory{public Shaped CreateShape(){Console.WriteLine("请输入矩形的颜色");string Col = Console.ReadLine();Console.WriteLine("请输入矩形的长和宽");double Len = Convert.ToDouble(Console.ReadLine()); double Wid = Convert.ToDouble(Console.ReadLine()); return new Rectangular(Col,Len,Wid);}}//定义三角形工厂TriangleFactory类class TriangleFactory : ShapeFactory{public Shaped CreateShape(){Console.WriteLine("请输入三角形的颜色");string Col = Console.ReadLine();Console.WriteLine("请输入三角形的三边长");double Ed1 = Convert.ToDouble(Console.ReadLine()); double Ed2 = Convert.ToDouble(Console.ReadLine()); double Ed3 = Convert.ToDouble(Console.ReadLine()); return new Triangle(Col,Ed1,Ed2,Ed3);}}//定义正方形工厂SquareFactory类class SquareFactory : ShapeFactory{public Shaped CreateShape(){Console.WriteLine("请输入正方形的颜色");string Col = Console.ReadLine();Console.WriteLine("请输入正方形的边长");double Ed0 = Convert.ToDouble(Console.ReadLine()); return new Square(Col,Ed0);}}class Program{static void Main(string[] args){//客户端实例化对象ShapeFactory[] shapeFactory = new ShapeFactory[4]; shapeFactory[0] = new CircleFactory();shapeFactory[1] = new RectangularFactory();shapeFactory[2] = new TriangleFactory ();shapeFactory[3] = new SquareFactory();foreach (ShapeFactory SF in shapeFactory){Shaped shaped = SF.CreateShape();Console.WriteLine("shaped Color is {0},shaped Area is {1},shaped Perimeter is{2}",shaped.GetColor(),shaped.GetArea(), shaped.Getperimeter()); }}}}。