1. 简单工厂模式

核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离，降低系统的耦合度，使得两个修改起来相对容易些，当以后实现改变时，只需要修改工厂类即可。该模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象，其UML类图如下：

AbstractProduct

/** 产品接口 **/
public interface AbstractProduct {
    void doSomething();
}

Product1

public class ProductA implements AbstractProduct {
    @Override
    public void doSomething() {
        System.out.println("i am productA");
    }
}

Product2 

public class ProductB implements AbstractProduct {
    @Override
    public void doSomething() {
        System.out.println("i am productB");
    }
}

Factory 

/** 简单工厂 **/
public class SimpleFactory {
    public static AbstractProduct createProduct(String productName){
        AbstractProduct instance = null;
        switch (productName){
            case "A":
                instance = new ProductA();
                break;
            case "B":
                instance = new ProductB();
                break;
        }
        return instance;
    }
}

测试 

public class SimpleFactoryTest {
    public static void main(String[] args) {
        AbstractProduct productA = SimpleFactory.createProduct("A");
        productA.doSomething();
        AbstractProduct productB = SimpleFactory.createProduct("B");
        productB.doSomething();
    }
}

2. 工厂方法模式 

        和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂，其UML类图如下：

AbstractProduct 

/** 产品接口 **/
public interface AbstractProduct {
    void doSomething();
}

Product1

/**  具体产品实现 **/
public class ProductA implements AbstractProduct {
    @Override
    public void doSomething() {
        System.out.println("i am productA");
    }
}

Product2 

/**  具体产品实现 **/
public class ProductB implements AbstractProduct {
    @Override
    public void doSomething() {
        System.out.println("i am productB");
    }
}

ConcreateFactory1 

/**  具体工厂实现 **/
public class FactoryA implements AbstractFactory {
    @Override
    public AbstractProduct createProduct() {
        return new ProductA();
    }
}

ConcreateFactory2 

/**  具体工厂实现 **/
public class FactoryB implements AbstractFactory{
    @Override
    public AbstractProduct createProduct() {
        return new ProductB();
    }
}

AbstractFactory 

/**  工厂接口 **/
public interface AbstractFactory {
    public AbstractProduct createProduct();
}

测试 

public class AbstractFactoryTest {
    public static void main(String[] args) {
        AbstractFactory factoryA = new FactoryA();
        AbstractProduct abstractProductA = factoryA.createProduct();
        abstractProductA.doSomething();
        AbstractFactory factoryB = new FactoryB();
        AbstractProduct abstractProductB = factoryB.createProduct();
        abstractProductB.doSomething();
    }
}