设计模式--工厂模式

1、由浅入深，先讲简单工厂模式。简单工厂模式就是说在创建对象时，将需要创建的不同对象的相关代码封装到不同的类中，这些称为具体产品类，而将他们的公共代码抽象到一个抽象产品类中，每一个具体产品类的对象都是抽象产品类的子类；然后提供一个工厂类用于创建各种产品，在工厂类中提供一个创建茶产品的工厂方法，该方法可以根据所传入的参数不同，创建不同的具体产品对象。

package SimpleFactoryPattern;

public interface Product {

    public void setProduct();
}

package SimpleFactoryPattern;

public class FactoryProduct {

    public Product getConcrectProduct(String type){
        if("A".equals(type)){
            Product a = new ConcrectProductA();
            return a;
        }
        if("B".equals(type)){
            Product b = new ConcrectProductB();
            return b;
        }
        return null;
    }
}

package SimpleFactoryPattern;

public class SimpleFactoryTest {

    public static void main(String[] args){
        FactoryProduct factoryProduct = new FactoryProduct();
        Product result = factoryProduct.getConcrectProduct("B");
        result.setProduct();
    }
}

package SimpleFactoryPattern;


public class ConcrectProductA implements Product {

    @Override
    public void setProduct() {
        System.out.println("创建A产品");
    }
}

package SimpleFactoryPattern;

public class ConcrectProductB implements Product {

    @Override
    public void setProduct() {
        System.out.println("创建B产品");
    }
}

如上代码所示，FactoryProduct类的getConcrectProduct能根据入参返回不同对象。

2、现在介绍工厂模式，又称工厂方法模式。简单工厂模式在实例化具体产品类的时候（FactoryProduct .getConcrectProduct）需要写很多if的逻辑，这样不符合开闭原则。如果现在需要新增一个ConcreteProductC的话需要写if(“c”.equals(type))…
在工厂模式下只需要新增两个类，一个是ConcreteProductC ，一个是 ConcreteFactoryC。不用修改原有代码。
工厂模式不再提供一个统一的工厂类来创建所有的产品对象，而是针对不同的产品提供不同的工厂，系统提供一个与产品等级结构相对应的工厂等级结构。定义如下：
定义一个创建类的接口，让子类决定将哪一个类实例化。该模式让一个类的实例化延迟到子类。
具体代码如下：

package FactoryPattern;

public class ConcreteProductA implements Product {

    @Override
    public Product setProduct(){
        Product a = new ConcreteProductA();
        System.out.println("创建A产品");
        return a;
    }
}

package FactoryPattern;

public class ConcreteProductB implements Product {

    @Override
    public Product setProduct(){
        Product b = new ConcreteProductB();
        System.out.println("创建B产品");
        return b;
    }
}

package FactoryPattern;

public interface Product {

    public Product setProduct();
}

package FactoryPattern;

public class ConcreteFactoryA implements Factory {

    @Override
    public Product factoryMethod(){
        return new ConcreteProductA();
    }
}

package FactoryPattern;

public class ConcreteFactoryB implements Factory {

    @Override
    public Product factoryMethod(){
        return new ConcreteProductB();
    }
}

package FactoryPattern;

public interface Factory {
    //声明工厂方法
    public Product factoryMethod();
}

package FactoryPattern;

public class FactoryPatternTest {
    public static void main(String[] args){
        //通过具体工厂方法创建A产品
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.factoryMethod();
        productA.setProduct();

        //通过具体工厂方法创建B产品
        Factory factoryB = new ConcreteFactoryB();
        factoryB.factoryMethod();
        Product productB = factoryB.factoryMethod();
        productB.setProduct();
    }
}

网上看到其他人说的工厂模式的好处，引用如下：

来说说我的看法：
工厂模式，也叫做说虚构造器，在简单工厂中间插入了一个具体产品工厂，这个工厂知道产品构造时候的具体细节，而简单工厂模式的产品具体构造细节是在一个个if/else分支，或者在switch/case分支里面的。工厂模式的好处就在于将工厂和产品之间的耦合降低，将具体产品的构造过程放在了具体工厂类里面。在以后扩展产品的时候方便很多，只需要添加一个工厂类，一个产品类，就能方便的添加产品，而不需要修改原有的代码。而在简单工厂中，如果要增加一个产品，则需要修改工厂类，增加if/else分支，或者增加一个case分支，工厂模式符合软件开发中的OCP原则（open close principle），对扩展开放，对修改关闭。
抽象工厂模式：这个模式我总是感觉和builder模式非常相似。
工厂方法模式提供的是对一个产品的等级模式，，而抽象工厂方法提供的是对多个产品的等级模式，注意，这里的多个具体产品之间是相互耦合的，也就是说这里的抽象工厂提供的产品之间是存在某种联系的。

3、抽象工厂模式
在工厂模式里面，每一个具体工厂只生产一个具体产品，导致系统中的工厂类太过庞大，因此提出抽象工厂模式。

简单看下类图