工厂模式---一个模子里刻出来

    声明：文章内容根据大牛博客的内容，自己理解后，给自己做的学习笔记，文末会附上大牛博客地址链接。有需要沟通交流的可加我QQ群：425120333
    工厂顾名思义就是进行加工生产的地方，在Java中就是创建对象的地方。工厂模式，是整个的归纳，其下又分为三个模块分别是简单工厂模式（静态工厂模式），
工厂方法模式，抽象工厂模式。这三张模式对应三种不同的场景，需要进行合理使用，没有绝对说一定要使用某种模式。
首先是简单工厂模式，为啥说简单呢，我理解的是结构简单，工厂类中有个公有的静态方法，根据参数识别创建相应的类对象。

public class StaticFactory {
    public static void main(String[] args) {
        Product product = ProductFactory.createProduct(1);
        product.function();

        System.out.println("---------我是分割线----------");

        product = ProductFactory.createProduct(2);
        product.function();
    }
}

class ProductFactory {
    public static Product createProduct(int type) {
        Product product = null;
        switch (type) {
        case 1:
            product = new ProductA();
            break;
        case 2:
            product = new ProductB();
            break;
        default:
            break;
        }
        return product;
    }
}

interface Product {
    void function();
}

class ProductA implements Product {

    @Override
    public void function() {
        System.out.println("this is a productA");
    }

}

class ProductB implements Product {

    @Override
    public void function() {
        System.out.println("this is a productB");
    }
}

控制台输出：

this is a productA
---------我是分割线----------
this is a productB

简单工厂模式，逻辑接单，不过违反了6大设计原则中的开闭原则，就是每添加一个实现了接口的类，都要在工厂类添加一种新的分支。

接着是工厂方法模式，这个模式是对简单工厂模式的改进，消除了简单工厂模式中违反了开闭原则这一点。通过将工厂类声明为抽象类，具体的创建对象在
子类中进行，以后新增一个产品的实现类时只需同时新增一个该产品的工厂类即可。

public class FactoryMethod {
    public static void main(String[] args) {
        IFactory factory = new ProductAAFactory();
        IProduct product = factory.creatProduct();
        product.function();

        System.out.println("---------我是分割线----------");

        factory = new ProductBBFactory();
        product = factory.creatProduct();
        product.function();
    }
}

interface IFactory {
    IProduct creatProduct();
}

class ProductAAFactory implements IFactory {

    @Override
    public IProduct creatProduct() {
        return new ProductAA();
    }

}

class ProductBBFactory implements IFactory {

    @Override
    public IProduct creatProduct() {
        return new ProductBB();
    }

}

interface IProduct {
    void function();
}

class ProductAA implements IProduct {

    @Override
    public void function() {
        System.out.println("this ia a productAA");
    }

}

class ProductBB implements IProduct {

    @Override
    public void function() {
        System.out.println("this ia a productBB");
    }

}

控制台输出

this ia a productAA
---------我是分割线----------
this ia a productBB

工厂方法模式相比较于简单工厂模式在结构上变得更加的复杂了，但仅仅不违反开闭原则这一点，也就体系了它的重要性，虽说要多写两个类，但总的来说
结构还是挺清晰的。
最后来说下抽象工厂模式，这个是工厂方法模式的升级版，是为了创建一组相关或者相互依赖的对象，而使用的一种设计模式

public class AbstractFactory {

    public static void main(String[] args) {

        IIFactory factory = new Factory1();
        IIProductA productA = factory.createProductA();
        IIProductB productB = factory.createProductB();
        productA.function();
        productB.function();

        System.out.println("---------我是分割线----------");

        factory = new Factory2();
        productA = factory.createProductA();
        productB = factory.createProductB();
        productA.function();
        productB.function();

    }
}

interface IIFactory {
    IIProductA createProductA();

    IIProductB createProductB();
}

class Factory1 implements IIFactory {

    @Override
    public IIProductA createProductA() {

        return new ProductAA1();
    }

    @Override
    public IIProductB createProductB() {
        // TODO Auto-generated method stub
        return new ProductBB1();
    }

}

class Factory2 implements IIFactory {

    @Override
    public IIProductA createProductA() {

        return new ProductAA2();
    }

    @Override
    public IIProductB createProductB() {
        // TODO Auto-generated method stub
        return new ProductBB2();
    }

}

interface IIProductA {
    void function();
}

class ProductAA1 implements IIProductA {

    @Override
    public void function() {
        System.out.println("this is implements IIProductA interface ,class name is ProductAA1");

    }

}

class ProductAA2 implements IIProductA {

    @Override
    public void function() {
        System.out.println("this is implements IIProductA interface ,class name is ProductAA2");

    }
}

interface IIProductB {
    void function();
}

class ProductBB1 implements IIProductB {

    @Override
    public void function() {
        System.out.println("this is implements IIProductB interface ,class name is ProductBB1");

    }

}

class ProductBB2 implements IIProductB {

    @Override
    public void function() {
        System.out.println("this is implements IIProductB interface ,class name is ProductBB2");

    }
}

控制台输出

this is implements IIProductA interface ,class name is ProductAA1
this is implements IIProductB interface ,class name is ProductBB1
---------我是分割线----------
this is implements IIProductA interface ,class name is ProductAA2
this is implements IIProductB interface ,class name is ProductBB2

从结果中能够发现通过工厂一次创建了2个（多个）对象，而不是像工厂方法模式中的那样一个实现了工厂接口的工厂类仅仅是为了创建一个类对象，
如果能理解工厂方法模式，理解抽象工厂模式其实也是较为简单的。

参考大牛博客链接：http://www.cnblogs.com/zuoxiaolong/p/pattern4.html