设计模式之工厂模式

写在前面
①. 工厂模式分为三类:

简单工厂模式(Simple Factory)
工厂方法模式(Factory Method)
抽象工厂模式(Abstract Factory)
②. 这三种模式从上到下逐步抽象，并且更具一般性。还有一种分类方法，就是将简单工厂模式看为工厂方法模式的一种特例，两个归为一类。

(1) 简单工厂模式
简单工厂模式又叫静态工厂模式，在工厂模式中状态中结构最为简单。主要有一个静态方法，用来接受参数，并根据参数来决定返回实现同一接口的不同类的实例。

简单工厂模式包含简单工厂角色、抽象产品角色和具体产品角色，三个角色。
(a) 简单工厂角色(Creator) ：这是简单工厂模式的核心，他拥有必要的逻辑判断能力和所有产品的创建权利，由一个具体类实现；
(b) 抽象产品角色(Product) ：简单工厂模式所创建的所有对象的父类，注意，这里的父类可以是接口也可以是抽象类，它负责描述所有实例所共有的公共接口，由接口或者抽象类来实现；
© 具体产品角色(Concrete Product) ：简单工厂所创建的对象就是此角色的实例，这些具体的产品往往都拥有共同的父类，由一个具体类实现。

举例说明简单工厂模式的缺点：只要我们将"订单"传给简单工厂角色，就能得到我们想要的产品。但是，如果想要增加一种新产品的时候，都必须修改"简单工厂角色"的原代码，其次，当我们拥有很多很多产品的时候，而且产品之间又存在复杂的层次关系的时候，这个类必须拥有复杂的逻辑判断能力，其代码量也将不断地激增。

示例代码：

抽象产品角色，Car.java
package com.rocky.learn.l004.t1;
//抽象产品角色
public interface Car {
public void run();
}

具体产品角色1，Benz.java
package com.rocky.learn.l004.t1;
//具体产品角色1
public class Benz implements Car {
@Override
public void run() {
System.out.println(“BENZ.”);
}
}

具体产品角色2，Audi.java
package com.rocky.learn.l004.t1;
//具体产品角色2
public class Audi implements Car {
@Override
public void run() {
System.out.println(“AUDI.”);
}
}

具体产品角色3，Bmw.java
package com.rocky.learn.l004.t1;
//具体产品角色3
public class Bmw implements Car {
@Override
public void run() {
System.out.println(“BMW…”);
}
}

抽象工厂角色，SimpleFactory.java
package com.rocky.learn.l004.t1;
//抽象工厂角色
public class SimpleFactory {
public static Car getCar(String name) throws Exception{
if(name.equals(“Audi”)){
return new Audi();
}else if(name.equals(“Benz”)){
return new Benz();
}else if(name.equals(“Bmw”)){
return new Bmw();
}else{
throw new Exception(“NOTHING”);
}
}
}

客户端，用于调用和测试，Test.java
package com.rocky.learn.l004.t1;
//客户端，用于调用和测试
public class Test {
public static void main(String[] args) {
try {
Car audi = SimpleFactory.getCar(“Audi”);
Car benz = SimpleFactory.getCar(“Benz”);
Car bmw = SimpleFactory.getCar(“Bmw”);
audi. run();
benz. run();
bmw. run();
} catch (Exception e) {
e.printStackTrace();
}
}
}

(2) 工厂方法模式
工厂方法模式和简单工厂模式的主要区别是，简单工厂模式是把创建产品的职能都放在一个类里面，而工厂方法模式则把不同的产品放在实现了工厂接口的不同工厂类里面，这样就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响，以后增加新产品，也只需要新增一个实现工厂接口工厂类，就能达到，不用修改已有的代码。

工厂方法模式包含抽象工厂角色、具体工厂角色、抽象产品角色和具体产品角色，四个实体。
(a) 抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现；
(b) 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现；
© 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现；
(d) 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

一个抽象产品角色，可以派生出多个具体产品角色；一个抽象工厂角色，可以派生出多个具体工厂角色；每个具体工厂角色只能创建一个具体产品角色的实例。

举例说明工厂方法模式的缺点：可以看出工厂方法模式的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合。

示例代码：

抽象工厂角色，DefaultFactory.java
package com.rocky.learn.l004.t2;
//抽象工厂角色
public interface DefaultFactory {
public Car create();
}

抽象产品角色，Car.java
package com.rocky.learn.l004.t1;
//抽象产品角色
public interface Car {
public void run();
}

具体产品角色1，Benz.java
package com.rocky.learn.l004.t1;
//具体产品角色1
public class Benz implements Car {
@Override
public void run() {
System.out.println(“BENZ.”);
}
}

具体产品角色2，Audi.java
package com.rocky.learn.l004.t1;
//具体产品角色2
public class Audi implements Car {
@Override
public void run() {
System.out.println(“AUDI.”);
}
}

具体产品角色3，Bmw.java
package com.rocky.learn.l004.t1;
//具体产品角色3
public class Bmw implements Car {
@Override
public void run() {
System.out.println(“BMW…”);
}
}

具体产品角色1，BenzCreate.java
package com.rocky.learn.l004.t2;
public class BenzCreate implements DefaultFactory {
@Override
public Car create() {
return new Benz();
}
}

具体产品角色2，AudiCreate.java
package com.rocky.learn.l004.t2;
public class AudiCreate implements DefaultFactory {
@Override
public Car create() {
return new Audi();
}
}

具体产品角色3，BmwCreate.java
package com.rocky.learn.l004.t2;
public class BmwCreate implements DefaultFactory {
@Override
public Car create() {
return new Bmw();
}
}

客户端，用于调用和测试，Test.java
package com.rocky.learn.l004.t2;
//客户端，用于调用和测试
public class Test {
public static void main(String[] args) {
DefaultFactory factory1 = new AudiCreate();
Car audi = factory1.create();
audi.run();
DefaultFactory factory2 = new BenzCreate();
Car benz = factory2.create();
benz.run();
DefaultFactory factory3 = new BmwCreate();
Car bmw = factory3.create();
bmw.run();
}
}

(3) 抽象工厂模式
目的是在于创建一系列互相关联或互相依赖的对象。
在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。
抽象工厂是在工厂方法的基础上引进了分类管理的概念，工厂方法用来创建一个产品，它没有分类的概念，而抽象工厂则用于创建一系列产品，所以产品分类成了抽象工厂的重点。
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类；一个抽象工厂类，可以派生出多个具体工厂类；每个具体工厂类可以创建多个具体产品类的实例。
与工厂方法模式的区别：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个；工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个