工厂模式（Factory）

工厂模式：包括简单工厂模式、工厂方法模式、抽象工厂模式

工厂模式是一种创造型模式，所有的工厂模式都强调一点，就是将对象的创建和使用分离，使系统更加符合单一职责原则，也更有利于对功能的复用和系统的维护

使用工厂类还有一个额外的优点，相对于无法重命名的构造函数，使用工厂可以以一种更加可读的易懂的方式创建对象

<!--华丽的分割-->

简单工厂模式（Simple Factory）

简单工厂模式：定义一个工厂类，根据不同的参数返回不同类的实例，由于简单工厂模式用于创建实例的方法是静态的，所以简单工厂模式也叫静态工厂模式

简单工厂模式分三个角色

Factory：提供创建对象的静态工厂方法

Product：被创建的所有实例的类的抽象，使工厂类只需定义一个通用的工厂方法

ConcreteProduct：具体被创建实例的类

PS~~一般情况下，Factory与Product可以结合在一起使结构更加简洁

//Product
interface Product{
    void action();
}
//ProductA
class ProductA implements Product{
    public void action(){
        System.out.println("A");
    }
}
//ProductB
class ProductB implements Product{
    public void action(){
        System.out.println("B")
    }
}
//.....
//Factory
class Factory{
    public static Product getProduct(String type){
        Product product = null;
        if(type.equals("A")){
            product = new ProductA();
        }else if(type.equals("B")){
            product = new ProductB();
        }else{
            System.out.println("No Such Product");
        }
        return product;
    }
}

使用简单工厂模式，在工厂类的创建对象方法中判断逻辑是必须的，在所有对象的类型不多的情况下，简单工厂模式的工厂逻辑不会过于复杂，但类型多的时候，工厂类就显得不利于维护和扩展了，而且工厂类使用了静态方法，使工厂角色无法形成继承的等级结构

<!--华丽的分割-->

工厂方法模式（Factory Method）

工厂方法模式：定义一个用于创建对象的接口，让子类决定将哪一个类实例化

工厂方法模式分四个角色

Factory：具体工厂的抽象，声明工厂方法，用于返回一个产品，所有工厂都必须实现这个抽象类或接口

ConcreteFactory：工厂的具体实现

Product：具体产品的抽象，所有产品的公共父类

ConcreteProduct：产品的具体实现

//Product
interface Product{
    void action();
}
//ProductA
class ProductA implements Product{
    public void action(){
        System.out.println("A");
    }
}
//ProductB
class ProductB implements Product{
    public void action(){
        System.out.println("B")
    }
}
//.....
//Factory
interface Factory{
    //factory method
    Product getProduct();
}
//FactoryA
class FactoryA implements Factory{
    public Product getProduct(){
        return new ProductA()
    }
}
//FactoryB
class FactoryB implements Factory{
    public Product getProduct(){
        return new ProductB()
    }
}
//.....
//ClientCode
public class Client{
    public static void main(String[] args){
        Factory factoryA = new FactoryA();
        Factory factoryB = new FactoryB();
        factoryA.getProduct().action();
        factoryB.getProduct().action();
    }
}

PS：为了进一步简化客户端，可以将调用创建对象的方法再封装在Factory抽象类中，然后可以直接把调用Product的逻辑写在封装的方法中

工厂方法模式可以获得很好的扩展性，在需要添加新的Product时，只需要添加相应的Factory就可以，符合开闭原则，但在类个数增多的时候，同样也会给系统带来额外的开销

<!--华丽的分割-->

抽象工厂模式（Abstract Factory）

抽象工厂模式：提供一个创建一系列相关或相互依赖的对象的接口，而无须指定他们具体的类，抽象工厂模式也叫Kit模式

假似有如下对象：圆、三角、方块分别是三种对象，Red、Green、Blue则是三种不同的实现

若使用工厂方法模式，对于每种对象抽象一个工厂，再分别实现每个工厂以创建每个对象，这种方法很灵活，但是，每增加一种具体的实现，类的数量便成对的增加，额外增加了系统的维护成本和运行开销

使用抽象工厂需要有以下两个概念：

产品等级结构：即产品的继承结构

产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，以上面的RGB对象来说，一个产品族可以是Red列的对象

所以，若使用抽象工厂模式，只需要添加三个具体的工厂，每个工厂分别负责Red、Green、Blue族对象的创建，只有在添加产品族时才需要额外添加工厂

抽象工厂模式与工厂方法模式一样，也有四个角色

AbstractFactory：声明一组用于创建一族产品的方法，每个方法对应一种产品

ConcreteFactory：实现了具体的方法，方法中创建的对象属于同一族，每一个产品都位于某个产品等级结构中

AbstractProduct：同一类型产品的声明

ConcreteProduct：实现AbstractProduct，构成产品等级结构

以上述圆、三角形、正方形为例

AbstractFactory的客户端代码

public class ClientTest{
    public static void main(String[] args){
        Factory factory;
        Circle circle;
        Triangle triangle;
        Square square;
        //Red or Green or Blue
        factory = new RedFactory();
        circle = factory.createCircle();
        triangle = factory.createTriangle();
        square = factory.createSquare();
    }
}

PS：各种工厂模式各有特点，应按情况选择符合自身开发的模式