设计模式四(工厂模式)

工厂方法模式：主要包含相关的简单工厂、工厂、抽象工厂方法模式，这几种模式，他们是一次进阶的关系，从初级到终极。
定义：由工厂来决定创建哪个产品的实例。(将创建实例和业务逻辑分开，提高代码的扩展性、健壮性)

一：简单工厂模式：

UML类图：对于新手来说，根据类图来学习是一个很好的选择，不了解的类图的同学，请自行百度学习。小四这里就不浪费时间去介绍了。

可以看出一共有三个类一个接口，creator类是工厂类，iproduct是产品接口，product_A和product_B是两个具体产品，虚线+三角形表示实现接口，实线箭头表示继承，所以可以写出该类图的代码：
产品接口：

public interface IProduct {  

    public void method();  
} 

具体的产品：

public class ProductA implements IProduct{  

    public void method() {  
        System.out.println("产品A方法");  
    }  

} 

public class ProductB implements IProduct{  

    public void method() {  
        System.out.println("产品B方法");  
    }  

}  

工厂类：

public class Creator {  

    private Creator(){}  

    public static IProduct createProduct(String productName){  
        if (productName == null) {  
            return null;  
        }  
        if (productName.equals("A")) {  
            return new ProductA();  
        }else if (productName.equals("B")) {  
            return new ProductB();  
        }else {  
            return null;  
        }  
    }  
}  

客户端：

public class Client {  

    public static void main(String[] args) {  
        IProduct product1 = Creator.createProduct("A");  
        product1.method();  

        IProduct product2 = Creator.createProduct("B");  
        product2.method();  
    }  
}  

结果：
输出：
产品A的方法
产品B的方法
上面便是整个类图转换为JAVA代码的简单例子，将上面标准的简单工厂模式的类图和代码给出，是为了一些新手先熟悉一下这个设计模式的大体框架，方便我们下面使用实际的例子去阐述的时候更加容易理解。
总结起来就是一个工厂类，一个产品接口（其实也可以是一个抽象类，甚至一个普通的父类，但通常我们觉得接口是最稳定的，所以基本不需要考虑普通父类的情况），和一群实现了产品接口的具体产品，而这个工厂类，根据传入的参数去创造一个具体的实现类，并向上转型为接口作为结果返回。

二 工厂模式：

定义：工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
优点：和简单工厂模式相比，工厂模式没有了工厂类，不在工厂类中实现对象的创建，而是抽象成接口，具体创建工作推迟到子类中去，可以在不修改具体工厂角色的情况下实现改变。
UML类图：

抽象产品接口：

public interface Light {  

    public void turnOn();  

    public void turnOff();  

} 

具体的产品：

public class BuldLight implements Light{  

    public void turnOn() {  
        System.out.println("BuldLight On");   
    }  

    public void turnOff() {  
        System.out.println("BuldLight Off");      
    }  

}

public class TubeLight implements Light{  

    public void turnOn() {  
        System.out.println("TubeLight On");   
    }  

    public void turnOff() {  
        System.out.println("TubeLight Off");      
    }  

}

抽象的工厂接口：

public interface Creator {  

    public Light createLight();  
}  

创建指定产品的具体工厂：

public class BuldCreator implements Creator{  

    public Light createLight() {  
        return new BuldLight();  
    }  

}

public class TubeCreator implements Creator{  

    public Light createLight() {  
        return new TubeLight();  
    }  

} 

测试类：

public class Client {  

    public static void main(String[] args) {  
        Creator creator = new BuldCreator();  
        Light light = creator.createLight();  
        light.turnOn();  
        light.turnOff();  

        creator = new TubeCreator();  
        light = creator.createLight();  
        light.turnOn();  
        light.turnOff();  
    }  
} 

结果：
BuldLight On
BuldLight Off
TubeLight On
TubeLight Off
#### 三 抽象工厂模式
抽象工厂模式是最终的阶段，避免了简单工厂模式和传统工厂模式的弊端。是他们的进阶版，和工厂模式唯一的区别就是，工厂抽象中是一系列的抽象方法，不在是一个了。
定义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
类图：

我们对比下刚才的定义，LZ给各位分析下上面的类图，首先刚才说了，我们要创建一个接口，这个接口就是指的Creator，而一组相关或者相互依赖的对象，就是指的ProductA和ProductB以及它们具体的实现类，而上面又提到说不是返回的具体的类，所以我们返回的应该是接口或者抽象类，那么在上述类图当中，则是指的ProductA和ProductB接口。

interface ProductA {  

    void methodA();  
}  

interface ProductB {  

    void methodB();  
}  

class ProductA1 implements ProductA{  

    public void methodA() {  
        System.out.println("产品A系列中1型号产品的方法");  
    }  

}  

class ProductA2 implements ProductA{  

    public void methodA() {  
        System.out.println("产品A系列中2型号产品的方法");  
    }  

}  

class ProductB1 implements ProductB{  

    public void methodB() {  
        System.out.println("产品B系列中1型号产品的方法");  
    }  

}  

class ProductB2 implements ProductB{  

    public void methodB() {  
        System.out.println("产品B系列中2型号产品的方法");  
    }  

}  

工厂接口：

public interface Creator {  

    ProductA createProductA();  

    ProductB createProductB();  

}  

两个具体的工厂实现类：

public class ConcreteCreator1 implements Creator{  

    public ProductA createProductA() {  
        return new ProductA1();  
    }  

    public ProductB createProductB() {  
        return new ProductB1();  
    }  

}  

public class ConcreteCreator2 implements Creator{  

    public ProductA createProductA() {  
        return new ProductA2();  
    }  

    public ProductB createProductB() {  
        return new ProductB2();  
    }  

}  

客户端：

public class Client {  

    public static void main(String[] args) throws Exception {  
        Creator creator = new ConcreteCreator1();  
        ProductA productA = creator.createProductA();  
        ProductB productB = creator.createProductB();  
        productA.methodA();  
        productB.methodB();  

        creator = new ConcreteCreator2();  
        productA = creator.createProductA();  
        productB = creator.createProductB();  
        productA.methodA();  
        productB.methodB();  
    }  
} 

结果：

有关工厂的三个模式到这里就全部介绍完了，三者有着很大的关联和明显的关系，要想灵活运用这三种设计模式，还是要彻底理解它们所针对的问题以及三者的关系。下面罗列下这三种设计模式依次进化的原因。
1，首先从简单工厂进化到工厂方法，是因为工厂方法弥补了简单工厂对修改开放的弊端，即简单工厂违背了开闭原则。
2，从工厂方法进化到抽象工厂，是因为抽象工厂弥补了工厂方法只能创造一个系列的产品的弊端。