设计模式(一)：工厂模式，抽象工厂模式

本文代码均是本人所写，文字内容部分参考以下博客，如有侵权联系本人删除：
https://blog.csdn.net/jason0539/article/details/23020989
https://blog.csdn.net/zxt0601/article/details/52798423
https://blog.csdn.net/u012156116/article/details/80857255

一.简述

1）还没有工厂时代：假如还没有工业革命，如果一个客户要一款宝马车,一般的做法是客户去创建一款宝马车，然后拿来用。
2）简单工厂模式：后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车，这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。
3）工厂方法模式时代：为了满足客户，宝马车系列越来越多，如320i，523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。
4）抽象工厂模式时代：随着客户的要求越来越高，宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。

最终是客户只要对宝马的销售员说：我要523i宝马车，销售员就直接给他523i宝马车了。而不用自己去创建523i宝马车.

这就是工厂模式。

二、分类

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式可以分为三类：

1）简单工厂模式（Simple Factory）
2）工厂方法模式（Factory Method）
3）抽象工厂模式（Abstract Factory）

这三种模式从上到下逐步抽象，并且更具一般性。
GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。

将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

三、区别

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

四、简单工厂模式

建立一个工厂（一个函数或一个类方法）来制造新的对象。
分布说明引子：从无到有。客户自己创建宝马车，然后拿来用。

public class BMW320 {
	public BMW320(){
		System.out.println("制造-->BMW320");
	}
}
 
public class BMW523 {
	public BMW523(){
		System.out.println("制造-->BMW523");
	}
}
 
public class Customer {
	public static void main(String[] args) {
		BMW320 bmw320 = new BMW320();
		BMW523 bmw523 = new BMW523();
	}
}

客户需要知道怎么去创建一款车,客户和车就紧密耦合在一起了.为了降低耦合,就出现了工厂类,把创建宝马的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的宝马车型号就行了,而不必去知道创建的细节.这就是工业革命了：简单工厂模式

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
先来看看它的组成：
1) 工厂类：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
2) 抽象产品：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

即我们建立一个工厂类方法来制造新的对象。如图：

产品类：
产品接口：
Public interface Product{

	Public void ProductBmw();

}

产品A：
Public class ProductA implements Product{

	Public ProductA()
	{
		ProductBmw();
	}

	@Override
	Public void ProductBmw()
	{
		System.out.println("Producing---ProductA:BMW330");
	}
}

产品B：
Public class ProductB implements Product{
	Public ProductB()
	{
		ProductBmw();
	}
	
	@Override
	Public void ProductBmw(){
		System.out.println("Producing---ProductB:BMW530");
	}
}

产品C:
Public class ProductC implements Product{

	Public ProductC()
	{
		ProductBmw();
	}
	
	@Override
	Public void ProductBmw(){
		System.out.println("Producing---ProductC:BMW730");
	}
}


工厂类：
Public  class Factory{

	Publi Product createProduct(inttype)
	{
		switch(type)
		{
			case330:
			Return new ProductA();
			case530:
			Return new ProductB();
			case730:
			Return new ProductC();
			default:
			break;
		}

			Return null;
	}
}

客户类：
Public class TestCustomer{

Public static void main(String[]args){
	Factory factory=new Factory();
	Product bmw330=factory.createProduct(330);
	Product bmw530=factory.createProduct(530);
	
}

}

下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当客户不再满足现有的车型号的时候，想要一种速度快的新型车，只要这种车符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createBMW(int type)方法需要新增case），这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。
我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。
于是工厂方法模式作为救世主出现了。 工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。

五、工厂方法模式

工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

工厂方法模式组成：
1)抽象工厂： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2)具体工厂：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
4)具体产品：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！
代码：

工厂类：
public interface Factory {

    public Product createProduct();

}

public class FactoryA implements Factory{
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

public class FactoryB implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

public class FactoryC implements Factory{
    @Override
    public Product createProduct() {
        return new ProductC();
    }
}
产品类：
public interface Product {

    public void Product();

}

public class ProductA implements Product{


    public ProductA()
    {
        Product();
    }

    @Override
    public void Product() {
        System.out.println("Producing---ProductA");
    }
}

public class ProductB implements Product{

    public ProductB()
    {
        Product();
    }

    @Override
    public void Product() {
        System.out.println("Producing---ProductB");
    }
}

public class ProductC implements Product{

    public ProductC()
    {
        Product();
    }

    @Override
    public void Product() {
        System.out.println("Producing---ProductC");
    }
}

客户类：
public class testCustomer {

    public static void main(String[] args) {

        Factory factoryA = new FactoryA();
        Factory factoryB = new FactoryB();
        Product productA = factoryA.createProduct();
        Product productB = factoryB.createProduct();
    }

}

工厂方法的优点/缺点：
优点：
子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。-- 加一层间接性，增加了灵活性
屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。
多态性：客户代码可以做到与特定应用无关，适用于任何实体类。
缺点：需要Creator和相应的子类作为factory method的载体，如果应用模型确实需要creator和子类存在，则很好；否则的话，需要增加一个类层次。(不过说这个缺点好像有点吹毛求疵了)
工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。

六、抽象工厂模式

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。所以抽象工厂与工厂方法模式的区别在于：抽象工厂是可以生产多个产品的。
抽象工厂模式相比工厂方法模式是更加灵活的设计模式，以桌面组件来举例，如果一个应用为一个特定的外观硬编码它的窗口组件，在应用中实例化这种风格的窗口组件之后，使得以后难以改变视觉风格，抽象工厂模式的提出解决了这个问题，它将一个个完整的产品从不同的型号，再次分离，分成一个个更细小的模块，更多的产品等级结构，使得产品和代码的灵活性更高。（这句话源自GOF的设计模式书中）

产品A类：
public interface Dough {

}

/**
 * @author Ocean
 * @date 2019/6/17 13:54
 */
public class thickDough implements Dough{

    public thickDough()
    {
        System.out.println("producing---thickDough");
    }
}

public class thinDough implements Dough{

    public thinDough()
    {
        System.out.println("producing---thinDough");

    }
}

产品B类：
public interface Condiments {
}

public class durianCondi implements Condiments{

    public durianCondi()
    {
        System.out.println("producing---durianCondi");
    }

}

public class pepperoniCondi implements Condiments{

    public pepperoniCondi()
    {
        System.out.println("producing---pepperoniCondi");
    }

}

工厂类：
public interface AbstractFactory {

    public Dough createDough();

    public Condiments createCondiments();

}

public class AmercianPizza implements AbstractFactory{

    public AmercianPizza()
    {
        System.out.println("producing---usaPizza");

    }


    @Override
    public Dough createDough() {
        return new thickDough();
    }

    @Override
    public Condiments createCondiments() {
        return new durianCondi();
    }
}

public class ItaltyPizza implements AbstractFactory{

    public ItaltyPizza()
    {
        System.out.println("producing---ItaltyPizza");
    }

    @Override
    public Dough createDough() {
        return new thinDough();
    }

    @Override
    public Condiments createCondiments() {
        return new pepperoniCondi();
    }
}

客户类：

public class testCustomer {

    public static void main(String[] args) {

        AbstractFactory italtyPizza = new ItaltyPizza();
        italtyPizza.createDough();
        italtyPizza.createCondiments();

    }

}

适用性：
• 一个系统要独立于它的产品的创建、组合和表示时
• 一个系统要有多个产品系列中的一个来配置时
• 当你要强调一系列相关产品对象的设计以便进行联合使用时
• 当你提供一个产品类库，而只想显示他们的接口而不是实现时

• 优点：
• 分离具体的类，抽象工厂模式隔离了具体类的生产，使得客户并不需要知道什么被创建。
• 利于产品一致性，当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
• 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
• 易于交换产品系列，一个具体工厂类在一个应用中只出现一次（初始化时），这时改变一个应用的具体工厂只需要使用不同的配置即可。
• 缺点：
• 难以支持新种类的产品的增加，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。