Java Factory pattern

　　Factory大概是最简单的设计模式了，用了一些，也该理一理了。我们先看看它的模式模式图：

                     

   

　　简单的说，工厂模式就是把“产品”与“产品生产”分离，然后对“产品”进行抽象。这样就形成了一个简单工厂模式。如果你再对“产品生产”这个环节进行抽象，那么就得到方法工厂模式。如果你在方法工厂模式里有多个产品足，那么就形成了抽象工厂。

　　那就分别对以上三种举例吧：

　　1.简单工厂

　　

//client
public class SimpleFactoryTest {
    public static void main(String[] args) throws NoThisProduct {
        Product productA = SimpleFactory.createProduct(SimpleFactory.PRODUCT_A);
        Product productB = SimpleFactory.createProduct(SimpleFactory.PRODUCT_B);
        productA.work();
        productB.work();
    }
}
//定义抽象产品
abstract class Product {
    public abstract void work();
}
//具体产品A
class ProductA extends Product{
    @Override
    public void work() {
        System.out.println("ProductA is working !");
    }
}
//具体产品B
class ProductB extends Product{
    @Override
    public void work() {
        System.out.println("ProductB is working !");
    }
}
//定义一个异常，当找不到该类型产品时候抛出这个异常
class NoThisProduct extends Exception {
    public NoThisProduct(String aName) {
        super(aName);
    }
}
//定义工厂类
class SimpleFactory{
    public static final int PRODUCT_A = 0;
    public static final int PRODUCT_B = 1;
    public static Product createProduct(int type) throws NoThisProduct{
        if(PRODUCT_A == type)
            return new ProductA();
        else if(PRODUCT_B == type)
            return new ProductB();
        else
            throw new NoThisProduct("it has no this type ："+type+" product ...");
    }    
}

　　2.方法工厂

/**
 * 简单工厂模式把所有的重心放到工厂类上，一旦向系统增加新的产品，就必须修改
 * 工厂类，不满足开闭原则(对修改关闭，对扩展开放)；工厂方法模式提供一个抽象
 * 的工厂接口，在不同的产品结构上实现不同的产品工厂具体类来创建该层次中的产
 * 品，通常一个具体工厂创建一个具体产品。在新增产品的时候，只需要实现新的对
 * 应工厂就可以满足需要，是符合开闭原则的
 */
//client
public class MethodFactoryTest {
    public static void main(String[] args) {
        Product productA = new FactoryA().createProduct();
        Product productB = new FactoryB().createProduct();
        productA.work();
        productB.work();
    }
}
//定义抽象产品
abstract class Product {
    public abstract void work();
}
//具体产品A
class ProductA extends Product{
    @Override
    public void work() {
        System.out.println("ProductA is working !");
    }
}
//具体产品B
class ProductB extends Product{
    @Override
    public void work() {
        System.out.println("ProductB is working !");
    }
}

//定义工厂接口，产生产品的接口
abstract class Factory{
    abstract Product createProduct();
}
//生常产品A的工厂
class FactoryA extends Factory{
    @Override
    Product createProduct() {
        return new ProductA();
    }
}
//生常产品B的工厂
class FactoryB extends Factory{
    @Override
    Product createProduct() {
        return new ProductB();
    }
}

　　3.抽象工厂

//client
public class AbstractFactoryTest {

    public static void main(String[] args) {

    }
}
//定义抽象产品A
abstract class ProductA {
    public abstract void work();
}
//具体产品One
class ProductAOne extends ProductA{
    @Override
    public void work() {
        System.out.println("ProductA is working !");
    }
}
//具体产品Two
class ProductATwo extends ProductA{
    @Override
    public void work() {
        System.out.println("ProductB is working !");
    }
}

//定义抽象产品B
abstract class ProductB {
    public abstract void work();
}
//具体产品One
class ProductBOne extends ProductB{
    @Override
    public void work() {
        System.out.println("ProductA is working !");
    }
}
//具体产品Two
class ProductBTwo extends ProductB{
    @Override
    public void work() {
        System.out.println("ProductB is working !");
    }
}

//定义工厂接口，产生产品的接口
abstract class Factory{
    abstract ProductA createProductA();
    abstract ProductB createProductB();
}
class FactoryA extends Factory{
    @Override
    public ProductA createProductA() {
        return new ProductAOne();
    }
    @Override
    public ProductB createProductB() {
        return new ProductBOne();
    }
}
class FactoryB extends Factory{
    @Override
    public ProductA createProductA() {
        return new ProductATwo();
    }
    @Override
    public ProductB createProductB() {
        return new ProductBTwo();
    }
}