Java 设计模式之工厂模式、抽象工厂模式一篇就够了

先说设计模式，设计模式都有哪些

java的设计模式大体上分为三大类：

创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

设计模式原则

1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu
百科

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。

不知道大家在面试的时候会不会经常被问到设计模式之类的问题，比如说
- 1. 你知道Java的设计模式吗？

然后你会说，知道，设计模式分为三大类：创建型模式，结构型模式，行为型模式，细分23个小类，其中有工厂方法模式，抽象工厂模式，单例模式…但是我对其中的只了解前三个，也就是对工厂方法模式、抽象工厂模式、单例模式很了解，其他的没有自信看过

- 2. 那你主要介绍一些这三个吧

然后你就开始说：
那我先说工厂方法模式，工厂方法模式又分为普通的，多个工厂的还有静态工厂方法模式，其实他们都有一个共同点就是：多个类都要去实现相似的功能，比如说发邮件，发短信，用工厂模式来说就是去实现同一个接口，在自己的类本身去实现这个接口各种的功能，你用的时候只要去调用工厂类就好了，不用管它具体要创建什么对象，怎么去创建的对象。

然后是抽象工厂模式，其实抽象工厂模式和普通工厂模式特别想，只是他把工厂类分开了，每一个对象都有一个工厂，而且还创建了另外一个接口，这些工厂都去实现这些接口。
…单例模式

 - 3.   那你说了这么多，那工厂模式有什么好处呢，我为什么要用工厂模式呢？

工厂模式是为了解耦：把对象的创建和使用的过程分开。就是Class A 想调用Class
B,那么只是调用B的方法，而至于B的实例化，就交给工厂类。

工厂模式可以降低代码重复。如果创建B过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。可以把这些创建对象B的代码放到工厂里统一管理。既减少了重复代码，也方便以后对B的维护。

工厂模式可以减少错误，因为工厂管理了对象的创建逻辑，使用者不需要知道具体的创建过程，只管使用即可，减少了使用者因为创建逻辑导致的错误。

 - 4.    那什么时候需要用到工厂模式呢？

其实工厂模式的一个作用就是创建对象，而创建类可以使用new(底层也是通过反射创建对象的),但是在一些情况下使用工厂模式确实最合适的。比如说

情况一：如果一个对象拥有很多子类，那么创建该对象的子类使用工厂模式是最合适的，不但可以面向接口的编程，为维护以及开发带来方便。

情况二：对象的创建过程/实例化准备工作很复杂，需要很多初始化参数，查询数据库等
在平常开发的时候，比如自定义日志框架、换数据库连接源、换网站的样式主题什么的

浏览之前也可以先看一些我的代码github链接，方便和你的代码对照传送门

1. 工厂方法模式

1. 普通工厂模式，建立一个接口 Interface1

public interface SendMessageInterface {
    //发邮件或者短信
    public void send();
}

1. 建立两个类 Mail和 Phone都实现Interface1

public class Mail implements SendMessageInterface {
    @Override
    public void send() {
        System.out.println("这里是邮件发送中心");
    }
}

public class Phone implements SendMessageInterface {
    @Override
    public void send() {
        System.out.println("这里是手机短信发送中心");
    }
}

1. 建立一个工厂类，写一个public的方法，用参数的形式判断该返回什么类

public class SendFactory {
    public SendMessageInterface produce(String mes) {
        if ("mail".equals(mes)) {
            return new Mail();
        } else if ("phone".equals(mes)) {
            return new Phone();
        } else {
            System.out.println("请输入正确的类型");
            return null;
        }
    }
}

1. 写一个测试类调用一下工厂类

public class TestFactory {


    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        SendMessageInterface sendMessageInterface = factory.produce("mail");
        sendMessageInterface.send(); //    这里是邮件发送中心
        SendMessageInterface sendMessageInterface2 = factory.produce("phone");
        sendMessageInterface2.send();    //这里是手机短信发送中心
    }
}

-2 多个工厂模式

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

1. 只需要将工厂类稍微改动一下就行，如下：

public class ManyFactory {


    public Mail produceMail() {
        return new Mail();
    }


    public Phone producePhone() {
        return new Phone();
    }


}

1. 测试类如下：

public class TestManyFactory {


    public static void main(String[] args) {
        ManyFactory factory = new ManyFactory();
        Mail mail = factory.produceMail();
        mail.send();
        Phone phone = factory.producePhone();
        phone.send();
    }


}

1. 结果如下：

这里是邮件发送中心
这里是手机短信发送中心

-3 静态工厂模式

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

1. 工厂类修改如下：

public class StaticFactory {

    public static Mail produceMail() {
        return new Mail();
    }

    public static Phone producePhone() {
        return new Phone();
    }

}

1. 测试代码如下：

public class TestStaticFactory {


    public static void main(String[] args) {
        Mail mail = StaticFactory.produceMail();
        mail.send();
        Phone phone = StaticFactory.producePhone();
        phone.send();
    }
}

1. 结果如下：

这里是邮件发送中心
这里是手机短信发送中心

看完上面三个工厂模式的例子，总结一下：

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

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

既然引出了抽象工厂模式，那我们就聊一下抽象工厂模式，以及为什么要用抽象工厂模式

抽象工厂模式

与普通工厂模式中的静态工厂模式有所不同的是，抽象工厂模式，是新建一个接口AbstractFactoryInterface里面的方法去实现原来普通工厂模式的produce方法，然后每一个类或者说要生产的产品都去实现这个抽象接口，而不是在一个工厂类里面把所有的都写出来，这样每有一个产品都要有一个工厂类，便于扩展程序

1. 刚才普通工厂模式的接口代码可能忘记了，再贴一次：

public interface SendMessageInterface {
    //发邮件或者短信
    public void send();
}

1. 抽象工厂模式的接口方法

import moshi.factory.SendMessageInterface;

public interface AbstractFactoryInterface {

    public SendMessageInterface  abstractProduce();
}

1. 然后，新建两个工厂类实现抽象接口，代码如下

public class MailAbstractFactory implements AbstractFactoryInterface {

    @Override
    public SendMessageInterface abstractProduce() {
        return  new Mail();
    }
}

public class PhoneAbstractFractory implements AbstractFactoryInterface {
    @Override
    public SendMessageInterface abstractProduce() {
        return new Phone();
    }
}

1. 再写一个测试类看一下结果如何：

    public static void main(String[] args) {
        AbstractFactoryInterface mailAbstractFactory = new MailAbstractFactory();
        AbstractFactoryInterface phoneAbstractFractory = new PhoneAbstractFractory();
        SendMessageInterface mail = mailAbstractFactory.abstractProduce();
        mail.send();
        SendMessageInterface phone = mailAbstractFactory.abstractProduce();
        phone.send();
    }
}

1. 结果如下：

这里是邮件发送中心
这里是邮件发送中心

1. 其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现普通的哪个工厂模式的接口即可，同时做一个工厂类，实现抽象工厂模式的接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！

同时附上我的代码github链接传送门

但是感觉好繁琐，有没有，那么在下一篇文章中，我们讲一下单例模式


工厂模式就介绍到这里了，欢迎留言说出你的观点，有什么问题，或者有不同的见解欢迎联系我 
邮箱：[email protected]