Java开发之设计模式--工厂方法模式(Factory Method)

工厂方法模式(Factory Method)，属于创建型模式的一种；那么，什么是创建型模式呢？

什么是创建型模式

在软件工程中，创建型模式是处理对象创建的设计模式，试图根据实际情况使用合适的方式创建对象。基本的对象创建方式可能会导致设计上的问题，或增加设计的复杂度。创建型模式通过以某种方式控制对象的创建来解决问题。

创建型模式由两个主导思想构成。一是将系统使用的具体类封装起来，二是隐藏这些具体类的实例创建和结合的方式。

创建型模式又分为对象创建型模式和类创建型模式。对象创建型模式处理对象的创建，类创建型模式处理类的创建。详细地说，对象创建型模式把对象创建的一部分推迟到另一个对象中，而类创建型模式将它对象的创建推迟到子类中。

把创建型模式，搞懂之后，现在应该是说工厂方法模式的时候勒！但是，在说工厂方法模式之前，我想和大家说一个不在23种设计模式当中的简单工厂模式。

简单工厂模式

它一般分为：普通简单工厂、多方法简单工厂、静态方法简单工厂。

普通简单工厂

什么是普通简单工厂：就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
关系图：

代码示例：（以发送邮件和短信为例）
首先，创建二者的共同接口：

public interface Sender {
    public void send();
}

然后，创建实现类：

public class MailSender implements Sender {
    public void send(){
        System.out.println("this is mailSender");
    }
}

public class SmsSender implements Sender {
    public void send(){
        System.out.println("this is SmsSender");
    }
}

最后，创建工厂类：

public class SendFractory{
    public Sender produce(String type) {
        if("mail".equals(type)) {
            return new MailSender();
        } else if ("sms".equals(type)) {  
            return new SmsSender();  
        } else {  
            System.out.println("请输入正确的类型!");  
            return null;  
        }  
    }
}

测试：

public class FactoryTest {  

    public static void main(String[] args) {  
        SendFactory factory = new SendFactory();  
        Sender sender = factory.produce("sms");  
        sender.send();  
    }  
}

Console输出:
> this is SmsSender

多方法简单工厂

是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确的创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
关系图：

代码示例：
修改上面的SendFactory类就行，如下：

public class SendFactory{
    public Sender produceMail(){
        return new MailSender();
    }

    public Sender produceSms(){
        return new SmsSender();
    }
}

测试：

public class FactoryTest{
    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produceMail();
        sender.send();
    }
}

Console输出:
> this is mailSender

静态方法简单工厂

将上面的多方法简单工厂里的方法置为静态的 ，不需要创建实例，直接调用即可。

public class SendFactory{
    public static Sender produceMail(){
        return new MailSender();
    }

    public static Sender produceSms(){
        return new SmsSedner();
    }
}

测试：

public class FactoryTest{
    public static void main(String[] args) {
        Sender sender = SenderFactory.produceMail();
        sender.send();
    }
}

Console输出：
> this is mailSender

总结：
工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种–静态方法简单工厂。

好了，以上面的简单工厂模式作为了铺垫，下面我们正式的聊聊工厂方法模式：

工厂方法模式(Factory Method)

在上面的简单工厂模式中有这么一个问题就是：类的创建依赖于工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到了工厂方法模式，创建一个工厂接口和创建多个工厂实现类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
关系图：

代码示例：
首先，创建二者的共同接口：

public interfae Sender {
    public void send();
}

然后，创建两个实现类：

public class MailSender implements Sender {
    public void send(){
        System.out.println("this is MailSender");
    }
}

public class SmsSender implements Sender {
    public void send(){
        System.out.println("this is SmsSender");
    }
}

接着，创建两个工厂类：

public class SendMailFactory implements Provider {  

    @Override  
    public Sender produce(){  
        return new MailSender();  
    }  
}

public class SendSmsFactory implements Provider{  

    @Override  
    public Sender produce() {  
        return new SmsSender();  
    }  
} 

最后，再提供一个接口：

public interface Provider {
    public Sender produce();
}

测试：

public class Test {  

    public static void main(String[] args) {  
        Provider provider = new SendMailFactory();  
        Sender sender = provider.produce();  
        sender.Send();  
    }  
}

总结：
这个模式的好处就是，如果你现在想增加一个功能：如发送及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！

工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。同时在工厂方法模式中用户只需要知道生产产品的具体工厂即可，无须关系产品的创建过程，甚至连具体的产品类名称都不需要知道。虽然他很好的符合了“开闭原则”，但是由于每新增一个新产品时就需要增加两个类，这样势必会导致系统的复杂度增加。

到目前为止，23种设计模式，已Out了工厂方法模式！让我们继续Out吧！

如果有朋友认为写得还可以，请点个赞或者转载都行，谢谢哦！