设计模式简单工厂
简单工厂模式的使用场景与示例
简单工厂模式的使用场景与示例简单工厂模式是一种常见的设计模式，它是一种创建型模式，可以帮助我们根据客户端的需求动态地生成不同的对象。
本文将介绍简单工厂模式的使用场景与示例，以便读者更好地理解和应用该模式。
一、简单工厂模式的基本原理在介绍简单工厂模式的使用场景之前，我们先来了解一下它的基本原理。
简单工厂模式由三个角色组成：工厂类、抽象产品类和具体产品类。
工厂类根据客户端的需求，决定创建哪一种具体产品类的对象，并返回给客户端使用。
二、简单工厂模式的使用场景1. 创建对象时只需要知道其类别，而不需要知道具体的实现。
简单工厂模式可以隐藏具体产品类的创建细节，客户端只需要调用工厂类的方法即可获取所需的对象。
2. 客户端不关心对象的创建过程。
通过简单工厂模式，我们可以将对象的创建逻辑封装在工厂类中，使得客户端完全不需要关心对象的创建过程，只需要关心获取到所需对象即可。
3. 需要一组相关的对象被统一创建。
在某些场景下，我们可能需要一组相关的对象被统一创建，简单工厂模式可以灵活地满足这种需求。
三、简单工厂模式的示例下面通过一个示例来具体介绍简单工厂模式的应用。
假设我们有一个游戏场景中的角色类，包括玩家角色和敌人角色。
我们需要根据不同的角色类型创建对应的角色对象。
首先，我们定义一个抽象角色类（Role），用于表示玩家角色和敌人角色的共有属性和方法，包括姓名（name）和攻击力（attack）。
```javapublic abstract class Role {protected String name;protected int attack;public Role(String name, int attack) { = name;this.attack = attack;}public abstract void display();public abstract void attack();}```接下来，我们定义具体的玩家角色类（PlayerRole）和敌人角色类（EnemyRole），它们分别继承自抽象角色类（Role）。
23种设计模式（一）---简单工厂设计模式
23种设计模式（⼀）---简单⼯⼚设计模式简单⼯⼚设计模式---透彻讲解⼀. 什么是⼯⼚理解简单⼯⼚设计模式, ⾸先要理解什么是⼯⼚. 我们⾝边有很多⼯⼚. 酿酒的酒⼚, 制⾐的⾐⼚, 加⼯⾁类的⾁加⼯⼚等等. 这些⼯⼚他们到底是怎么酿酒的? 怎么制⾐的?怎么加⼯⾁的? 我们并不知道, 也不需要知道. 不知道并不影响我们喝酒, 穿⾐, 吃⾁. 这就是⼯⼚的特点之⼀: 客户不需要知道怎么做的, 但是不影响使⽤再来看看⼯⼚的第⼆个特点: ⽐如⾁加⼯⼚---双汇. ⽜⾁进去出来⽜⾁⽕腿肠, ⽺⾁进去出来⽺⾁⽕腿肠, 猪⾁进去出来猪⾁⽕腿肠. 我不需要知道怎么加⼯的, 我只需要把材料扔进去, 然后对应的⽕腿肠就出来了. 这就是第⼆个特点: 给你材料, 你去制造出我想要的东西, ⾄于怎么做,我并不关⼼.程序中的⼯⼚也是⼀样的思想. **⼯⼚的作⽤就是创造对象. **⼆. 简单⼯⼚设计模式2.1. 设计模式我们基本都知道设计模式有23种, 说到这, 我们先来说说设计模式。
设计模式不是语法, ⽽是⼀种巧妙的写法, 能够把程序变得更加灵活的写法.设计模式有三种: 创建型, ⾏为型, 结构型. 简单⼯⼚设计模式属于创建型. 但简单⼯⼚设计模式不属于23种设计模式范围内, 属于23种设计模式中⼯⼚设计模式⾥最简单的⼀种.2.2. 简单⼯⼚设计模式简单⼯⼚设计模式, ⼜叫做静态⼯⼚设计模式. 简单⼯⼚设计模式提供⼀个创建对象实例的功能，⽽⽆需关系其具体实现，被创建实例的类型可以是接⼝、抽象类，也可以是具体的类。
2.3. 简单⼯⼚设计模式的4要素这个很重要, 这也是创建⼀个简单⼯⼚的步骤1. API接⼝: 创建⼀个API接⼝或抽象类2. Impl实现类: ⼀个或多个实现API接⼝/抽象类的类3. ⼯⼚: 定义⼀个⼯⼚, ⽤来创建API接⼝类对象4. 客户端: ⽤来调⽤⼯⼚创建API接⼝或抽象类的客户端2.4 简单⼯⼚结构类型及说明以上类型就描述了⼀个简单⼯⼚创建的整个过程第⼀步: 定义API接⼝或抽象类, 并定义⼀个operate操作⽅法第⼆步: 定义API的实现类, 每个实现类单独实现operate⽅法第三步: 定义⼯⼚类. ⼯⼚类依赖API接⼝和API的实现类, 简单⼯⼚设计模式是创建型的, 通常是⽤来创建实体类. 因此我们定义⼀个create⽅法, 来创建实例对象,⼊参通常是⼀个指定的类型第四步: 定义客户端. 客户端传⼊⼀个指定的类型给⼯⼚, ⼯⼚就会创建出对应的实现类.2.5 简单⼯⼚模板代码第⼀步: 制⾐⼚API接⼝package com.lxl.www.designPatterns.simpleFactory.demo;public interface IClothes {void operate();}第⼆步: 制⾐⼚API实现类ManClothes: 制作男⼠⾐服package com.lxl.www.designPatterns.simpleFactory.demo;public class ManClothes implements IClothes{@Overridepublic void operate() {System.out.println("制作男⼈的⾐服");}}WomenClothes: 制作⼥⼠⾐服package com.lxl.www.designPatterns.simpleFactory.demo;public class WomenClothes implements IClothes{@Overridepublic void operate() {System.out.println("制作⼥⼈的⾐服");}}ChildClothes: 制作⼉童⾐服package com.lxl.www.designPatterns.simpleFactory.demo;public class ChildClothes implements IClothes{@Overridepublic void operate() {System.out.println("制作⼉童的⾐服");}}第三步: 定义⼯⼚, 并创建⾐服类接⼝package com.lxl.www.designPatterns.simpleFactory.demo;/*** 制⾐⼯⼚*/public class ClothesFactory {public static IClothes createClothes(String type) {if (type.equals("男⼈")) {return new ManClothes();} else if (type .equals("⼥⼈")) {return new WomenClothes();} else {return new ChildClothes();}}}第四步: 定义客户端, 指定制⾐类别, 制⾐.public static void main(String[] args) {IClothes manClothes = ClothesFactory.createClothes("男⼈");manClothes.operate();}2.6 简单⼯⼚命名建议类命名建议为“模块名称+Factory”,⽐如，⽤户模块的⼯⼚就称为UserFactory, 制⾐⼯⼚: ClothesFactory⽅法名称通常为“get+接⼝名称”或者是“create+接⼝名称”。
03 C#设计模式-简单工厂模式
简单工厂模式的结构与实现
class Factory 简单工厂模式实现 { //静态工厂方法 典型的工厂类代码： public static Product GetProduct(string arg) { Product product = null; if (arg.Equals("A")) { product = new ConcreteProductA(); //初始化设置product } else if (arg.Equals("B")) { product = new ConcreteProductB(); //初始化设置product } return product; } }
简单工厂模式概述
简单工厂模式定义
在简单工厂模式中用于创建实例的方法通常是静态 (static)方法，因此又被称为静态工厂方法(Static Factory Method)模式 要点：如果需要什么，只需要传入一个正确的参数， 就可以获取所需要的对象，而无须知道其创建细节
<<use>>
udao.FindUserById();
引入工厂类UserDAOFactory
UserDAOFactory + CreateUserDAO (int arg) : UserDAO ...
Login - udao : UserDAO + Login (int arg) + Execute () : void ...
创建对象与使用对象
C#语言创建对象的几种方式
使用new关键字直接创建对象 通过反射机制创建对象 通过克隆方法创建对象 通过工厂类创建对象
www.CBiblioteka
设计模式之简单工厂模式
为什么使用工厂模式？ 为什么使用工厂模式？
因为工厂模式就相当于创建实例对象的new， 因为工厂模式就相当于创建实例对象的new， 我们经常要根据类Class生成实例对象，如A 我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象 的，所以以后new时就要多个心眼，是否可 的，所以以后new时就要多个心眼，是否可 以考虑实用工厂模式，虽然这样做，可能 多做一些工作，但会给你系统带来更大的 可扩展性和尽量少的修改量。
根据参数返回不同的对象
类x为一个基类，类XY和XZ派生自类x， XFactory类根据你提 供给它的值来决定返回那个子类的实例，我们定义了getClass 方法，接受一些值，并根据这个值返回x类的其中一个实例。 返回它们当中的哪一个与程序员无关。因为它们都含有相同的 方法，但是不同的实现，它可能是很复杂的功能，但通常都很 简单。
其中的角色
工厂类（Creator）角色：该角色是简单工厂模式的核心，含有按照 一定商业逻辑创建产品。工厂类在客户端的直接调用下创建产品对 象，它往往由一个具体类实现。 抽象产品（Product）角色： 担任这个角色的类是工厂 方法模式所创建的对象的 父类，或它们共同拥有的 接口。抽象产品角色可以 用一个接口或者抽象类实 现。 具体产品（Concrete Product） 角色：工厂方法模式所创建 的任何对象都是这个角色的 实例，具体产品角色由一个 具体类实现。
工厂模式分类
工厂方法模式 ----- 生产具体产品 抽象工厂模式 ----- 生产工厂
简单工厂模式可理解成静态的工厂方法模式
设计模式之简单工厂模式
金桥软件公司
孟波
简单工厂模式定义
简单工厂模式：根据提供给它的数据，返回几 简单工厂模式：根据提供给它的数据，返回几 个可能类中的一个类的实例。通常它返回的类 都有一个共同的父类和共同的方法，但每个方 法执行的过程不同，而且根据不同的数据进行 了优化。简单工厂模式可以作为工厂方法模式 了优化。简单工厂模式可以作为工厂方法模式 的一个Sa实例的工厂
策略模式简单工厂模式抽象工厂模式
策略模式简单工厂模式抽象工厂模式策略模式、简单工厂模式和抽象工厂模式是常见的设计模式，用于解决不同的问题和满足不同的设计需求。
下面将分别介绍这三种模式，并进行详细的比较。
策略模式策略模式是一种行为型模式，它将一组特定的算法封装成一个独立的类，使得它们可以相互替换。
应用策略模式的主要目的是让算法的变化独立于使用算法的客户端。
策略模式将算法的定义与算法的使用分离开来，这样可以让算法的定义更加灵活，能够根据需要动态地改变。
简单工厂模式简单工厂模式是一种创建型模式，它由一个工厂类负责创建不同类型的对象。
简单工厂模式的核心思想是将对象的创建过程封装起来，客户端只需要通过一个工厂类的方法来获取所需的对象，而不需要了解创建对象的细节。
简单工厂模式常常使用静态方法来创建对象，这样客户端可以直接通过类名来调用工厂方法。
抽象工厂模式也是一种创建型模式，它提供了一种创建一族相关或相互依赖对象的接口，而不需要指定具体的类。
抽象工厂模式的核心思想是将对象的创建过程封装到一个工厂接口中，具体的工厂类实现这个接口来创建不同的对象。
抽象工厂模式可以用于创建一系列的产品对象，这些产品对象有一定的关联关系。
比较1.目的不同：-策略模式的目的是将一组算法封装起来，使得它们可以相互替换。
-简单工厂模式的目的是封装对象的创建过程，使得客户端只需要通过一个工厂类的方法来获取所需的对象。
-抽象工厂模式的目的是提供一种创建一族相关或相互依赖对象的接口。
2.使用场景不同：-策略模式适用于一组特定的算法需要进行动态切换或扩展的场景。
-简单工厂模式适用于需要根据输入参数来决定创建具体对象的场景。
-抽象工厂模式适用于需要创建一系列相关或相互依赖的对象的场景。
3.灵活性不同：-策略模式的算法可以灵活地添加、删除或替换，客户端可以根据需要动态地选择所需的算法。
-简单工厂模式的创建过程在工厂类中，所以客户端只能通过修改工厂类代码来实现创建对象的变化，不够灵活。
23种设计模式简单实例
23种设计模式简单实例设计模式是解决软件设计中常见问题的经典解决方案，它们被广泛应用于软件工程中。
本文将介绍23种设计模式，并提供每种模式的简单实例来帮助读者更好地理解和应用这些模式。
1. 创建型模式（Creational Patterns）1.1 简单工厂模式（Simple Factory Pattern）：一个工厂类根据传入的参数决定创建哪一种产品类的实例。
例如，一个汽车工厂根据参数创建不同型号的汽车。
1.2 工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。
例如，一个汽车品牌父类提供创建具体汽车型号的方法，由子类决定具体型号。
1.3 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。
例如，一个汽车制造工厂提供创建汽车引擎和轮胎的方法。
1.4 建造者模式（Builder Pattern）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
例如，一个套餐包括饮料、主食和甜品等多个组件，可以通过建造者模式逐步构建套餐。
1.5 单例模式（Singleton Pattern）：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
例如，一个日志管理器只能有一个实例，可以通过单例模式实现。
2. 结构型模式（Structural Patterns）2.1 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口。
例如，将一个新的USB设备适配到旧的电脑接口上。
2.2 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。
例如，一个画图软件可以通过装饰器模式给图形对象添加边框或阴影等功能。
2.3 代理模式（Proxy Pattern）：为其他对象提供一个代理以控制对这个对象的访问。
C#设计模式（1）——简单工厂模式
C#设计模式（1）——简单⼯⼚模式1.什么是简单⼯⼚ 现实中的⼯⼚负责⽣产产品，顾名思义，编程中的简单⼯⼚就是⼀个⽣产对象的类，它的主要作⽤是创建具体的产品类实例。
我们以⼀个⽣产⿏标为例来分析简单⼯⼚的作⽤，⿏标有两种：戴尔⿏标和惠普⿏标，代码如下：//⿏标抽象类public abstract class Mouse{public abstract void Print();}//戴尔⿏标public class DellMouse : Mouse{public override void Print(){Console.WriteLine("⽣产了⼀个Dell⿏标！");}}//惠普⿏标public class HpMouse : Mouse{public override void Print(){Console.WriteLine("⽣产了⼀个惠普⿏标！");}}客户端代码：class Program{static void Main(string[] args){Mouse mouse1 = new DellMouse();Mouse mouse2 = new DellMouse();Mouse mouse3 = new DellMouse();Mouse mouse4 = new DellMouse();Mouse mouse5 = new DellMouse();mouse1.Print();}}程序运⾏如下： 我们可以看到程序运⾏没有问题，通过new⼀个DellMouse我们可以创建⼀个戴尔的⿏标，这时有⼀个问题，如果我们不想要戴尔⿏标了，要全部⽣产惠普⿏标怎么办呢？最简单直接的⽅法就是把new DellMouse全部替换成new HpMouse 。
如果我们的软件中new了100个DellMouse实例呢？⼀个⼀个地去替换会是⼀个巨⼤的⼯作量，同时通过new的⽅式来创建戴尔⿏标的实例,会让DellMouse类和客户端产⽣强耦合关系，这时候使⽤简单⼯⼚就可以帮助我们降低耦合，减少⼯作量了。
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别
简单工厂工厂方法抽象工厂策略模式策略与工厂的区别简单工厂、工厂方法、抽象工厂以及策略模式在软件开发中都是常用的设计模式，它们都是为了解决不同对象的创建和使用问题。
下面将对它们进行详细的介绍，并比较它们之间的区别。
1. 简单工厂模式（Simple Factory Pattern）：简单工厂模式是由一个工厂类根据传入的参数决定创建哪种产品的设计模式。
它包含三个角色：工厂类负责创建产品，产品类定义产品的具体实现，客户端通过工厂类获取产品对象。
简单工厂模式将对象的创建与使用进行了分离，增加了灵活性，但是违反了开闭原则，因为每次新增产品都需要修改工厂类。
2. 工厂方法模式（Factory Method Pattern）：工厂方法模式是指定义一个创建产品对象的接口，但是由子类决定实例化哪个类。
这样可以将产品的实例化延迟到子类中进行，满足了开闭原则。
工厂方法模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
具体工厂类负责创建具体产品类的实例，抽象产品类定义了产品的接口。
客户端通过抽象工厂类获取产品对象。
工厂方法模式解决了简单工厂模式的缺点，但是增加了类的个数。
3. 抽象工厂模式（Abstract Factory Pattern）：抽象工厂模式是指提供一个创建一系列相关或互相依赖对象的接口，而无需指定具体的类。
抽象工厂模式由抽象工厂类、具体工厂类和抽象产品类、具体产品类组成。
抽象工厂类定义了创建产品的接口，具体工厂类负责创建具体产品。
抽象产品类定义了产品的接口，具体产品类实现了产品的具体实现。
客户端通过抽象工厂类获取产品对象。
抽象工厂模式提供了一种创建一系列产品对象的方法，但是增加新产品时需要修改所有的工厂类。
4. 策略模式（Strategy Pattern）：策略模式是指定义了一系列的算法，并将每个算法封装起来，使得它们可以互相替换，使得算法的选择和使用可以独立于客户端。
策略模式由抽象策略类、具体策略类和环境类组成。
面向对象设计的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是增加职责。
七、观察者模式 定义对象间的⼀种⼀对多的依赖关系，当⼀个对象的状态发⽣改变时，所有依赖于它的对象都得到通知并被⾃动更新。
简单工厂（SimplePattern）模式
简单⼯⼚（SimplePattern）模式⼀、简单⼯⼚（Simple Factory）模式Simple Factory 模式根据提供给它的数据，返回⼏个可能类中的⼀个类的实例。
通常它返回的类都有⼀个公共的⽗类和公共的⽅法。
Simple Factory 模式实际上不是 Gof 23个设计模式中的⼀员。
⼆、简单⼯⼚（Simple Factory）模式⾓⾊与结构⼯⼚类⾓⾊Creator (LightSimpleFactory）：⼯⼚类在客户端的直接控制下（Create⽅法）创建产品对象。
抽象产品⾓⾊Product (Light)：定义简单⼯⼚创建的对象的⽗类或它们共同拥有的接⼝。
可以是⼀个类、抽象类或接⼝。
具体产品⾓⾊ ConcreteProduct (BulbLight, TubeLight)：定义⼯⼚具体加⼯出的对象。
三、简单⼯⼚（Simple Factory）模式演化1) Simple Factory 模式演化（⼀）除了上⾯的⽤法外，在有些情况下Simple Factory可以有抽象产品⾓⾊扮演，⼀个抽象产品类同时是⼦类的⼯⼚。
2) Simple Factory 模式演化（⼆）三个⾓⾊全部合并：与单例模式（Singleton）相近，但是有区别。
四、有点与缺点优点： ⼯⼚类含有必要的判断逻辑，可以决定什么时候创建哪⼀个产品类的实例，客户端可以免除直接创建产品对象的责任，⽽仅仅“消费”产品。
简单⼯⼚模式通过这种做法实现了对责任的分割。
缺点： 当产品有复杂的多层等级结构时，⼯⼚类只有⾃⼰，以不变应万变，就是模式的缺点。
因为⼯⼚类集中了所有产品创建逻辑，⼀旦不能正常⼯作，整个系统都要受到影响。
同时，系统扩展困难，⼀旦添加新产品就不得不修改⼯⼚逻辑，有可能造成⼯⼚逻辑过于复杂。
另外，简单⼯⼚模式通常使⽤静态⼯⼚⽅法，这使得⽆法有⼦类继承，造成⼯⼚⾓⾊⽆法形成基于继承的等级结构。
设计模式(简单工厂,工厂方法,抽象工厂)区别
第一种表述简单工厂，工厂方法，抽象工厂都属于设计模式中的创建型模式。
其主要功能都是帮助我们把对象的实例化部分抽取了出来，优化了系统的架构，并且增强了系统的扩展性。
本文是本人对这三种模式学习后的一个小结以及对他们之间的区别的理解。
简单工厂简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。
不修改代码的话，是无法扩展的。
工厂方法工厂方法是针对每一种产品提供一个工厂类。
通过不同的工厂实例来创建不同的产品实例。
在同一等级结构中，支持增加任意产品。
抽象工厂抽象工厂是应对产品族概念的。
比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。
小结★工厂模式中，重要的是工厂类，而不是产品类。
产品类可以是多种形式，多层继承或者是单个类都是可以的。
但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。
★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。
★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。
区别简单工厂：用来生产同一等级结构中的任意产品。
（对于增加新的产品，无能为力）工厂模式：用来生产同一等级结构中的固定产品。
（支持增加任意产品）抽象工厂：用来生产不同产品族的全部产品。
（对于增加新的产品，无能为力；支持增加产品族）以上三种工厂方法在等级结构和产品族这两个方向上的支持程度不同。
所以要根据情况考虑应该使用哪种方法。
第二种表述简单工厂、工厂方法和抽象工厂都是创建型的设计模式。
三者的共同点是：1、都有两种作用不同的类：产品类和工厂类。
其中，工厂类在自己的方法中实例化产品类（即使用new命令生成产品类的对象），并将生成的产品类的对象提供给外部使用。
2、创建的过程，都是类似的：工厂类得到一个标志（可以由程序输入，也可以读取配置文件中的内容），返回一个产品对象。
软件体系结构—设计模式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），⼜称多态性⼯⼚模式，属于设计模式三⼤分类中的创建型模式，作为抽象⼯⼚模式的孪⽣兄弟，⼯⼚⽅法模式定义了⼀个创建对象的接⼝，但由⼦类决定要实例化的类是哪⼀个，也就是说⼯⼚模式让实例化推迟到⼦类。
设计模式——简单工厂模式
设计模式——简单⼯⼚模式⽬录shanzm-2020年4⽉1⽇ 22:18:49 1. 简介简单⼯⼚模式（Simple Factory Pattern）：定义⼀个⼯⼚类，根据不同的参数，创建并返回不同的类。
其中这些类具有⼀个公共的⽗类或是⼀个接⼝。
简单⼯⼚模式不属于GoF四⼈组提出的23种设计模式，它是最简单的⼯⼚模式。
简单⼯⼚模式包含类：Factory：⼯⼚类，内部有是个精通的⽅法，根据参数选择创建的对象Product：抽象产品类，其作为具体产品的⽗类，负责定义产品的公共接⼝ConcreteProduct：具体产品类，有多个，都是继承与抽象产品类，⼯⼚就是创建该类对象2. ⽰例⽰例源于《⼤话设计模式》，通过⼀个简单的四则计算器来逐步的重构，最终通过简单⼯⼚实现⼀个简单的四则计算器。
⾸先创建⼀个简单的控制台项⽬，实现⼀个简单的四则运算计算器功能当提⽰⽤户输⼊两个数字，并输⼊⼀个四则运算符，实现计算功能2.1 计算器V1.0namespace Calculator{public class Operation{public static double GetResult(double numA, double numB, string oper){double result = 0;switch (oper){case "+":result = numA + numB;break;case "-":result = numA - numB;break;case "*":result = numA * numB;break;case "/":result = numB != 0 ? numA / numB : 0;break;}return result;}}//让业务逻辑和界⾯逻辑分离class Program{static void Main(string[] args){try{Console.WriteLine("enter a number");double numA = Convert.ToDouble(Console.ReadLine());Console.WriteLine("enter another number");double numB = Convert.ToDouble(Console.ReadLine());Console.WriteLine("enter operation");string oper = Console.ReadLine();Console.WriteLine(Operation.GetResult(numA, numB, oper).ToString());Console.ReadKey();}catch (Exception e){Console.WriteLine("error:" + e.Message);Console.ReadKey();}}}}2.2 计算器V2.0计算器V1.0中使⽤类对业务逻辑进⾏封装了但是你若是要是想要添加⼀个新的运算符则要对Operation类进⾏修改其实这样是不安全的，万⼀你添加新的运算符的时候把原来的运算符的操作代码修改错了这样岂不是对项⽬代码很不安全！所以你可以把所有的运算符分别单独定义⼀个类，这样你就可以随意添加和修改某⼀个新的运算符但是这时候问题⼜来了，主程序怎么判断要建哪⼀个运算符的对象所以需要⼀个Factory类来判断建什么对象在⼯⼚类中，我们使⽤⾥⽒原则（⼦类对象赋值给⽗类变量）。
工厂设计模式（三种）详解
⼯⼚设计模式（三种）详解什么是⼯⼚设计模式？⼯⼚设计模式，顾名思义，就是⽤来⽣产对象的，在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地⽅都需要修改⼀遍，这显然违背了软件设计的开闭原则，如果我们使⽤⼯⼚来⽣产对象，我们就只和⼯⼚打交道就可以了，彻底和对象解耦，如果要更换对象，直接在⼯⼚⾥更换该对象即可，达到了与对象解耦的⽬的；所以说，⼯⼚模式最⼤的优点就是：解耦本篇主要介绍三种⼯⼚设计模式的使⽤：1、简单⼯⼚2、⼯⼚⽅法3、抽象⼯⼚简单⼯⼚设计模式定义：⼀个⼯⼚⽅法，依据传⼊的参数，⽣成对应的产品对象；⾓⾊：1、抽象产品2、具体产品3、具体⼯⼚4、产品使⽤者使⽤说明：先将产品类抽象出来，⽐如，苹果和梨都属于⽔果，抽象出来⼀个⽔果类Fruit，苹果和梨就是具体的产品类，然后创建⼀个⽔果⼯⼚，分别⽤来创建苹果和梨；代码如下：⽔果接⼝public interface Fruit {void whatIm();}具体类苹果public class Apple implements Fruit {@Overridepublic void whatIm() {//苹果}}具体类梨public class Pear implements Fruit {@Overridepublic void whatIm() {//梨}}具体⼯⼚⽔果⼯⼚public class FruitFactory {public Fruit createFruit(String type) {if (type.equals("apple")) {//⽣产苹果return new Apple();} else if (type.equals("pear")) {//⽣产梨return new Pear();}return null;}}产品使⽤FruitFactory mFactory = new FruitFactory();Apple apple = (Apple) mFactory.createFruit("apple");//获得苹果Pear pear = (Pear) mFactory.createFruit("pear");//获得梨就这样，⼀个⾮常简单的⼯⼚设计模式就完成了，但是有没有发现什么问题呢？对，那就是如果我想吃⾹蕉，想吃橘⼦呢，我万⼀什么都想吃呢？？所以，以上的这种⽅式，每当我想添加⼀种⽔果，就必然要修改⼯⼚类，这显然违反了开闭原则，亦不可取；所以简单⼯⼚只适合于产品对象较少，且产品固定的需求，对于产品变化⽆常的需求来说显然不合适；所以我们来看下⼀种⽅式；⼯⼚⽅法设计模式定义：将⼯⼚提取成⼀个接⼝或抽象类，具体⽣产什么产品由⼦类决定；⾓⾊：抽象产品类具体产品类抽象⼯⼚类具体⼯⼚类使⽤说明：和上例中⼀样，产品类抽象出来，这次我们把⼯⼚类也抽象出来，⽣产什么样的产品由⼦类来决定；代码如下：⽔果接⼝苹果类和梨类代码和上例⼀样⼯⼚接⼝public interface FruitFactory {Fruit createFruit();//⽣产⽔果}苹果⼯⼚public class AppleFactory implements FruitFactory {@Overridepublic Fruit createFruit() {return new Apple();}}梨⼯⼚public class PearFactory implements FruitFactory {@Overridepublic Fruit createFruit() {return new Pear();}}使⽤AppleFactory appleFactory = new AppleFactory();PearFactory pearFactory = new PearFactory();Apple apple = (Apple) appleFactory.createFruit();//获得苹果Pear pear = (Pear) pearFactory.createFruit();//获得梨以上这种⽅式，虽然解耦了，也遵循了开闭原则，但是问题根本还是没有解决啊，换汤没换药，如果我需要的产品很多的话，需要创建⾮常多的⼯⼚，所以这种⽅式的缺点也很明显；抽象⼯⼚设计模式定义：为创建⼀组相关或者是相互依赖的对象提供的⼀个接⼝，⽽不需要指定它们的具体类。
Spring中的常见的9种设计模式
Spring中的常见的9种设计模式1.简单⼯⼚(⾮23种设计模式中的⼀种)2.⼯⼚⽅法3.单例模式4.适配器模式5.装饰器模式6.代理模式7.观察者模式8.策略模式9.模版⽅法模式Spring中涉及的设计模式总结1.简单⼯⼚(⾮23种设计模式中的⼀种)实现⽅式：BeanFactory。
Spring中的BeanFactory就是简单⼯⼚模式的体现，根据传⼊⼀个唯⼀的标识来获得Bean对象，但是否是在传⼊参数后创建还是传⼊参数前创建这个要根据具体情况来定。
实质：由⼀个⼯⼚类根据传⼊的参数，动态决定应该创建哪⼀个产品类。
实现原理：bean容器的启动阶段：读取bean的xml配置⽂件,将bean元素分别转换成⼀个BeanDefinition对象。
然后通过BeanDefinitionRegistry将这些bean注册到beanFactory中，保存在它的⼀个ConcurrentHashMap中。
将BeanDefinition注册到了beanFactory之后，在这⾥Spring为我们提供了⼀个扩展的切⼝，允许我们通过实现接⼝BeanFactoryPostProcessor 在此处来插⼊我们定义的代码。
典型的例⼦就是：PropertyPlaceholderConfigurer，我们⼀般在配置数据库的dataSource时使⽤到的占位符的值，就是它注⼊进去的。
容器中bean的实例化阶段：实例化阶段主要是通过反射或者CGLIB对bean进⾏实例化，在这个阶段Spring⼜给我们暴露了很多的扩展点：各种的Aware接⼝，⽐如 BeanFactoryAware，对于实现了这些Aware接⼝的bean，在实例化bean时Spring会帮我们注⼊对应的BeanFactory的实例。
BeanPostProcessor接⼝，实现了BeanPostProcessor接⼝的bean，在实例化bean时Spring会帮我们调⽤接⼝中的⽅法。
简单工厂与工厂方法模式的区别
简单工厂与工厂方法模式的区别软件开发中的设计模式是一种特定的解决方案，它可以用来解决一种在软件开发中普遍存在的问题。
在这些模式中，工厂模式是最为广泛使用的模式之一。
在工厂模式中，有两种基本的类型——简单工厂和工厂方法模式。
虽然这两种方法本质上是相同的，但它们之间也存在着一些关键的区别。
## 简单工厂模式简单工厂模式是一种创建型模式，它允许用户根据需要创建一个对象，而不必知道对象的具体类。
这个模式可以有效地将对象创建的过程抽象出来，并把它们放在一个工厂类中，这个工厂类根据用户的输入信息决定应该创建哪个具体的对象。
简单工厂模式的核心是工厂类，它是一个包含多个静态方法的类，这些静态方法根据用户的需求创建不同类型的对象。
例如，在一个汽车制造工厂中，简单工厂模式可以用来创建不同类型的车辆，例如轿车、跑车或 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 方法，这个方法用来描述不同的车辆如何行驶。
C#设计模式——简单工厂模式、工厂模式和抽象工厂模式
C#设计模式——简单⼯⼚模式、⼯⼚模式和抽象⼯⼚模式⼀：简单⼯⼚模式 1：描述：简单⼯⼚模式是由⼀个⼯⼚对象根据接收到的消息决定要创建哪⼀个类的对象事例。
2：优点：⼯⼚类中有相关逻辑判断，可以根据需要动态创建相关的对象事例，⽽客户端只需要告诉⼯⼚类创建什么对象事例，⽽不关⼼怎么创建，当需要引⼊新产品就不需要修改客户端的代码，只需要添加相应的产品类并修改⼯⼚类就可以，所以从产品的⾓度上简单⼯⼚模式是符合“开-闭”原则的。
3：缺点：很容易违反⾼内聚低耦合的原则，⼀旦添加新产品就不得不修改⼯⼚逻辑，当产品类型较多时，有可能造成⼯⼚逻辑⽐较复杂，不利于系统的扩展和维护，所以从⼯⼚的⾓度来说简单⼯⼚模式是不符合“开-闭”原则的。
4：例⼦：namespace SimpleFactoryDemo{class Program{static void Main(string[] args){ShapeFactory shapeFactory = new ShapeFactory();shapeFactory.getShape("circle").draw();shapeFactory.getShape("rectangle").draw();shapeFactory.getShape("square").draw();Console.ReadKey();}}public interface IShape{void draw();//默认公共⽅法}public class Circle : IShape{public void draw(){Console.WriteLine("画个圆");}}public class Rectangle : IShape{public void draw(){Console.WriteLine("画个长⽅形");}}public class Square : IShape{public void draw(){Console.WriteLine("画个正⽅形");}}public class ShapeFactory//形状⼯⼚{public IShape getShape(string type){if ("circle".Equals(type)){return new Circle();}else if ("rectangle".Equals(type)){return new Rectangle();}else if ("square".Equals(type)){return new Square();}else{return null;}}}}⼆：⼯⼚模式 1：描述：定义⼀个创建对象的⼯⼚接⼝，让⼦类决定实例化哪个类，将实际创建⼯作推迟到⼦类中。
设计模式之简单工厂模式（SimpleFactoryPattern）
设计模式之简单⼯⼚模式（SimpleFactoryPattern）⼀、简单⼯⼚模式的由来 所有设计模式都是为解决某类问题⽽产⽣的，那么简单⼯⼚模式是为解决什么问题呢？我们假设有以下业务场景: 在⼀个学⽣选课系统中，⽂科⽣⽤户选课时，我们要获得⽂科⽣的所有课程列表；理科⽣⽤户选课时，获得理科⽣的所有课程列表；体育⽣⽤户选课时，获得体育⽣的所有课程列表；那我们的逻辑怎么写呢？很简单，我们⽤伪代码实现如下:if(userType is ⽂科⽣){return ⽂科⽣课程;}else if(userType is 理科⽣){return 理科⽣课程;}else if(userType is 体育⽣){return 体育⽣课程;} 这时我们发现，不光在学⽣选课时需要这段逻辑，在学⽣查询课程时，也需要这段代码，于是我们理所应当的将这段代码复制到了查询课程的⽅法中，如果⽼师查询课程的⽅法中也要这段代码，那继续复制到⽼师查看课程的⽅法中。
这就造成了重复性代码，如何让这段代码只写⼀遍，多处可以复⽤呢？我们可以将这段代码抽取成公共⽅法，将学⽣类型定义成参数。
在调⽤的地⽅，通过传⼊不同的参数类型，返回不同的课程列表。
这样就实现了⼀次代码，多次复⽤的效果。
以上的这种优化过程，其实就是简单⼯⼚模式的⽣成过程。
⼆、什么是简单⼯⼚模式？ 在简单⼯⼚模式中，程序员创建或者获得对象，不再⽤new Object()的⽅式进⾏，⽽是给⼯⼚类传⼊参数，⼯⼚类根据程序员传⼊参数的不同，返回不同的对象。
三、简单⼯⼚模式的⾓⾊ 简单⼯⼚模式中，有以下⼏种⾓⾊，这些⾓⾊撑起了简单⼯程模式的实现: 产品规范:提供规范，供其它产品⼦类来实现这些规范；可以是接⼝，抽象类或者⽗类； 产品实现:产品规范的具体实现类；实现或者继承产品规范的接⼝，抽象类或⽗类； 调度类(⼯⼚类):有了产品规范，也有了产品实现，那⽤哪个产品呢，由调度类来调度决定。
产品使⽤者:使⽤产品的地⽅，传⼊想使⽤的产品参数，通过调度类给产品使⽤者返回产品。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
简单工厂设计模式目录1.1摘要 (2)2.1关键字 (2)3.1开发工具 (2)4.1简单工厂模式动机与定义： (2)4.1.1模式动机 (2)4.1.2模式定义 (2)5.1简单工厂模式结构 (3)6.1简单工厂模式实例： (4)6.1.1代码分析 (4)6.1.1.1Product（Shape抽象类）代码： (4)6.1.1.2ConcreteProduct（Juxing,YuanXing,SanJiao具体产品类）代码：5JuXing类： (5)YuanXing类： (6)SanJiao类： (6)6.1.1.3Factory(Factory类)代码： (7)6.1.1.4 (main类)： (7)6.1.1.5运行结果： (10)7.1结论 (10)8.1参考文献： (10)1.1摘要本文从面向对象的角度对java接口的概念、作用以及使用它的好处做分析，讲解面向接口编程的方法，结合初步接触软件开发的人员习惯，从简单工厂设计模式的概念和其结构以及用途进行解析，重点讲解简单工厂设计模式在软件开发过程中的作用和好处，通过一些实例来说明简单工厂设计模式的特点。
2.1关键字面向对象；java接口；接口编程；简单工厂设计模式。
3.1开发工具Eclipse java语言开发4.1简单工厂模式动机与定义：在实际的软件开发过程中有时需要创建一些来自于相同父类的类的实例，为此可以专门定义一个类来负责创建这些类的实例，这些被创建的实例具有共同的父类。
在这种情况下，可以通过传入不同的参数从而获取不同的对象，理由Java语言的特征，习惯上将创建其他类实例的方法定义为static方法，外部不需要实例化这个类就可以直接调用该方法来获得需要的对象，该方法也成为静态工厂方法。
4.1.1模式动机考虑一个简单的软件应用场景，一个软件系统可以提供多个外观不同的按钮（如圆形按钮，矩形按钮等），这些按钮都源自同一个基类，不过在继承基类之后不同的子类修改了部分属性从而使得它们可以呈现不同的外观，如果我们希望在使用这些按钮时，不需要知道这些具体按钮类的名字，只需要知道表示该按钮的一个参数，并提供一个调用方便的方法，把该参数传入方法即可返回一个相应的按钮对象，此时，就可以使用简单工厂模式。
4.1.2模式定义简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常具有共同的父类。
5.1简单工厂模式结构a、Factory（工厂角色）是简单工厂模式的核心，它负责实现创建所有具体产品类的实例。
工厂类可以被外界直接调用，创建所需的产品对象。
b、Product（抽象产品角色）是所有具体产品角色的父类，它负责描述所有实例所共有的公共接口。
c、ConcreteProduct（具体产品角色）继承自抽象产品角色，一般为多个，是简单工厂模式的创建目标。
工厂类返回的都是该角色的某一具体产品。
6.1简单工厂模式实例：使用简单工厂模式设计一个可以创建不同几何形状（如圆形、方形和三角形等）的绘图工具，每个几何图形都要绘制draw（）和擦除erase（）两个方法，要求在绘制不支持的几何图形时，提示一个UnSupportedShapeException。
6.1.1代码分析6.1.1.1Product（Shape抽象类）代码：import java.awt.Graphics;import javax.swing.JPanel;public abstract class AbstractShape {static Graphics g;public abstract void draw(JPanel p);public abstract JPanel erase(JPanel p);}分析：创建draw()和erase()方法供子类继承调用；6.1.1.2ConcreteProduct（Juxing,YuanXing,SanJiao具体产品类）代码：//各个产品类代码类似、需要添加产品类时只需要另外创建一个类然后再修改工厂类少量代码即可JuXing类：import javax.swing.JPanel;//绘制矩形public class JuXing extends AbstractShape {private JPanel p;Overridepublic void draw(JPanel p) {// TODO Auto-generated method stubthis.p=p;//g.drawrect(50, 50, 100, 50);}Overridepublic JPanel erase(JPanel p) {p.repaint();// TODO Auto-generated method stubreturn p;}}YuanXing类：import javax.swing.JPanel;//绘制圆形public class YuanXing extends AbstractShape { private JPanel p;Overridepublic void draw(JPanel p) {// TODO Auto-generated method stubthis.p=p;//g.drawOval(50, 50, 50, 50);}Overridepublic JPanel erase(JPanel p) {p.repaint();// TODO Auto-generated method stubreturn p;}}SanJiao类：import javax.swing.JPanel;//绘制三角形public class SanJiao extends AbstractShape { private JPanel p;Overridepublic void draw(JPanel p) {// TODO Auto-generated method stubthis.p=p;//int x[]={130,100,200}int y[]={130,200,200};g.drawPolygon(x, y, 3); }Overridepublic JPanel erase(JPanel p) {p.repaint();// TODO Auto-generated method stubreturn p;}}6.1.1.3Factory(Factory类)代码：public class Factory {public static AbstractShape creatShape(String s) throws Exception{ if(s.equalsIgnoreCase("矩形")){return new JuXing();}else if(s.equalsIgnoreCase("圆形")){return new YuanXing();}else if(s.equalsIgnoreCase("三角形")){return new SanJiao();}else {throw new Exception("UnSupportedShapeException");}}}//注释：用于创建各个具体产品角色的对象；6.1.1.4 (main类)：创建一个窗体，添加控件和监听代码如下：import javax.swing.*;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;public class ShapeFrame extends JFrame implements ActionListener { JPanel contentPane = new JPanel();JPanel upPane = new JPanel();JPanel centerPane = new JPanel();String shapeStr[] = {"圆形","矩形","三角形"};JComboBox cmb = new JComboBox(shapeStr);JLabel lab = new JLabel("选择目标图形：");JButton drawBtu = new JButton("绘制");JButton eraseBtu = new JButton("擦除");Shape shape;ShapeFrame(String title) {super(title);setSize(800,600);setLocationRelativeTo(null);addPane();setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}void addPane() {setContentPane(contentPane);contentPane.setLayout(new BorderLayout());contentPane.setBackground(Color.white);upPane.setBackground(Color.white);centerPane.setBackground(Color.white);contentPane.add(upPane,BorderLayout.NORTH);contentPane.add(centerPane,BorderLayout.CENTER);initWidget();upPane.add(lab);upPane.add(cmb);upPane.add(drawBtu);upPane.add(eraseBtu);}void initWidget() {drawBtu.addActionListener(this);eraseBtu.addActionListener(this);}//关键代码Overridepublic void actionPerformed(ActionEvent e) {Object object = e.getSource();if (object.equals(drawBtu)) {String shapeName = cmb.getSelectedItem().toString();try{shape = ShapeFactory.creatShape(shapeName);shape.draw(centerPane);}catch (Exception error){error.printStackTrace();}} else if (object.equals(eraseBtu)) {if (shape != null) {JPanel newPanel = shape.erase(centerPane);contentPane.add(newPanel, BorderLayout.CENTER); repaint();shape = null;}}}}6.1.1.5运行结果：7.1结论简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类的实例。