1 简单工厂模式

工厂1

1.1简单工厂模式的定义

简单工厂模式是由有一个工厂类去创建同一类型的实例，不同的实例通过类型去控制。怎么理解了，这就好比一家代工电视机的工厂，这个工厂只能代工 小米 电视，这个工厂可以生产40寸、55寸、60寸、80寸的电视，假如小米需要60寸的电视，这个工厂的流水线就把60寸的电视生产出来，只需要一个类型指令就可以了。这样说只是一个简化，实际生产过程中相当的复杂，设计供应链、订单、交付等各个环节，只是打个比方。

简单工厂模式也称之为静态工厂模式，一个工厂类提供一个 静态方法 ，生成同一系列的产品。简单工厂之所以称之为简单，是由于写法上简单，工厂生产的类型单一。

1.2 简单工厂模式解决的问题

• 遵循单一职能设计原则， 创建与使用分离，使用者无需关注创建的细节，只需要遵循公共的定义即可。

• 是工厂方法与抽象工厂模式的简单实现，对业务场景变化很少的场景很适用。

1.3简单工厂模式存在的问题

• 违背开闭原则，新增业务场景，需要修改工厂类

• 由于是静态方法，没有办法继承扩展

1.4 简单工厂的实例

1). 创建流程

①定义创建实例的 抽象类 或接口

②实现抽象类或接口

③实现工厂类创建实例对象

简单工厂创建流程

2） . 简单工厂示例，一个简单的例子说明简单工厂的用法

①．定义抽象类

public 
abstract class Employee {

 private int id;

 private String name;
 //抽象行为，所有示例的公有行为
 public abstract void action();

 public int getId() {
 return id;
 }

 public void setId(int id) {
 this.id = id;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }
} 

② 实现抽象类

A. 程序员实现类

public
class Programmer 
 extends Employee {
 @ Override 
 public void action() {
 System.out.println(getName() + "苦逼的程序员正在写bug~");
 }
} 

B. 销售的实现类

public class Saler extends Employee {
 @Override
 public void action() {
 System.out.println(getName() + "我正在与客户沟通~~");
 }
} 

③实现简单工厂

public class Simple factory  {
 /**
 * 通过参数，控制创建的具体的实例对象，返回的是抽象的类
 * @param type
 * @return
 */ public static Employee createEmployee(String type){
 if(type.equals("programmer")){
 return new Programmer();
 }
 else if(type.equals("saler")){
 return new Saler();
 }
 return null;
 }
} 

这样我们的简单工厂就实现完成了， 当然写法上根据自身的实际情况而定，但是主要的思想是不变的。

2.抽象工厂模式

2.1抽象工厂模式的定义

抽象工厂模式是提供一组创建相关联的产品簇的一种方法模式。是对工厂方法模式的一种改进，工厂方法模式中一个具体工厂只能创建一种产品，在有些场景下显得比较繁琐，抽象工厂模式为解决这一问题而存在。

2.2抽象工厂模式的实现

抽象工厂模式的实现过程与工厂方法模式很相似，不同的是工厂中提供了多种创建方法

创建的步骤请参照工厂方法模式，在此给一个实例说明；

① 定义抽象工厂

public interface Factory {
/**
* 创建销售
* @return
*/
Employee createSaler();
/**
* 创建程序员
* @return
*/
public Employee createProgrammer();
}

② 实现抽象工厂

public class AbstratoryFactory implements Factory{

 private AbstratoryFactory(){}
 /**
 * 创建销售
 * @return
 */ @Override
 public Employee createSaler(){
 return new Saler();
 }

 /**
 * 创建程序员
 * @return
 */ @Override
 public Employee createProgrammer(){
 //也是初始化一些参数
 return new Programmer();
 }
} 

③ 定义抽象实例

public abstract class Employee {
 private int id;
 private String name;
 public abstract void action();
 public int getId() {
 return id;
 }
 
 public void setId(int id) {
 this.id = id;
 }
 
 public String getName() {
 return name;
 }
 
 public void setName(String name) {
 this.name = name;
 }
} 

④ 实现抽象实例

 public class Programmer 
 extends Employee {
 
 @Override
 public void action() {
 System.out.println(getName() + "苦逼的程序员正在写bug~");
 }
} 

public class Saler 
 extends Employee {
 
 @Override
 public void action() {
 System.out.println(getName() + "我正在与客户沟通~~");
 }
} 

3.工厂方法模式

3.1、工厂方法模式的定义

工厂方法模式是定义一个创建实例的接口，真实创建实例由子工厂类去做。工厂方法摸式是对简单工厂模式的扩展与改进，弥补了简单工厂模式扩展不足的问题。

工厂方式模式与简单工厂模式一样，只能创建同一类型的产品，因为工厂实现类遵循同一的接口。

3.2、工厂方法模式的有点

• 什么产品用什么工厂创建，非常明确，只需要知道是要创建什么样的产品，也就明白了需要用什么工厂去创建，通过名称约定去实现，遵循同一的规则

• 系统增加新的产品，只需要增加具体的产品类与具体的子工厂，而无需对原工厂修改，这解决了简单工厂中违背“开闭原则“的问题

3.3、工厂方法模式的缺点

每增加一种产品，必须得增加这类型的工厂，增加了系统的复杂度，如果产品很多，会有很多的工厂，很多的类，管理维护差。

3.4、工厂方法模式示例

1）. 结构示例图

① 定义抽象工厂；提供所有子工厂的同一定义接口，对象提供一个创建的方法

② 具体工厂；对每个产品的生产的具体工厂，继承抽象工厂

③ 抽象产品；同一的产品类定义

④ 具体的产品

工厂方法模式结构

说明：图片来自

2). 工厂方法模式示例

① 抽象工厂的定义

public interface AbstractFactory { 
 /** * 创建对象 
 * @return */ 
 Employee create();
} 

②具体工厂的定义

public class PragrammerFactory 
 implements AbstractFactory {
 @Override
 public Employee create() {
 return new Programmer();
 }
} 

public class SalerFactory 
 implements AbstractFactory {
 @Override
 public Employee create() {
 return new Saler();
 }
} 

③抽象产品的定义

public abstract class Employee {
 private int id;
 private String name;
 public abstract void action();
 public int getId() {
 return id;
 }
 public void setId(int id) {
 this.id = id;
 }
 public String getName() {
 return name;

 }
 public void setName(String name) {
 this.name = name;
 }
} 

④具体产品的实现

public class Programmer extends Employee {
 @Override
 public void action() {
 System.out.println(getName() + "苦逼的程序员正在写bug~");
 }
} 

public class Saler extends Employee {
 @Override
 public void action() {
 System.out.println(getName() + "我正在与客户沟通~~");
 }
} 

工厂方法模式到这儿就完成了，是不是很简单，怎么用的话，有各种变形，我在这个举一个例子，看看

public class Factory 
 implements AbstractFactory {
 private AbstractFactory factory;
 public Factory(AbstractFactory factory){
 this.factory = factory;
 }
 @Override
 public Employee create() {
 System.out.println("这是一个装饰模式的factory，可用性更强");
 return factory.create();
 }
} 

以统一工厂去创建，具体工厂作为参数，这利用装饰模式去实现，我觉得这样用还不错。

4 结语

工厂模式是为创建对象而存在，对于反复的创建形同类型的对象，提供一种统一的创建模式，减少代码的重复，提高抽象性与可维护性。