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(底层也是通过反射创建对象的),但是在一些情况下使用工厂模式确实最合适的。 比如说

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

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

工厂模式

1简单工厂模式

• 1先新建一个接口

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

• mail实现

@Service
public class  MailSendImpl implements SendMessageInterface {
    @Override
    public void send() {
        System.out.println("mail send");
    }
}

• phone实现

@Service
public class PhoneSendImpl implements SendMessageInterface {
    @Override
    public void send() {
        System.out.println("phone send");
    }
}

简单工厂模式核心工厂

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

• 测试和结果

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

    }
//mail send
//phone send

2多个工厂模式

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

多个工厂模式核心工厂

public class MyManyFactory {
  public  MailSendImpl produceMail() {
        return new MailSendImpl();
    }

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

• 测试和结果

    public static void main(String[] args) {
        MyManyFactory myManyFactory=new MyManyFactory();
        MailSendImpl mailSend=myManyFactory.produceMail();
        PhoneSendImpl phoneSend=myManyFactory.producePhone();
        mailSend.send();
        phoneSend.send();
    }
//mail send
//phone send

3静态工厂模式

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

/**
 * @author xiyou
 * @version 1.0
 * xiyou-todo 静态工厂模式核心工厂
 * @date 2020/5/10 11:51
 */
public class MyStaticFactory {
    public static MailSendImpl produceMail() {
        return new MailSendImpl();
    }

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

    public static void main(String[] args) {
        MailSendImpl mailSend = MyStaticFactory.produceMail();
        PhoneSendImpl phoneSend = MyStaticFactory.producePhone();
        mailSend.send();
        phoneSend.send();
    }
}
//mail send
//phone send

工厂模式总结

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

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

4抽象工厂模式

这里我们直接用接口的方式创建抽象工厂，但是也可以用抽象类，下面我们先用接口方式实现抽象工程模型

接口方式实现抽象工厂模式

public interface AbstractFactoryInterface {
    /**
     * 抽象工厂模式核心工厂接口
     *
     * @return
     */
    SendMessageInterface absFactoryProduce();
}

• mail实现

public class MailAbstractFactory  implements AbstractFactoryInterface{
    @Override
    public SendMessageInterface absFactoryProduce() {
        return new MailSendImpl();
    }
}

• phone实现

public class PhoneAbstractFractory implements AbstractFactoryInterface {
    @Override
    public SendMessageInterface absFactoryProduce() {
        return new PhoneSendImpl();
    }
}

• 测试

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

抽象类实现抽象工厂模式

public abstract class AbstractFactoryClass {
    /**
     * 抽象工厂类
     *
     * @return
     */
    public abstract SendMessageInterface absFactoryProduce();
}

public class MailAbstractFactoryClass  extends AbstractFactoryClass {
    @Override
    public SendMessageInterface absFactoryProduce() {
        return new MailSendImpl();
    }
}

public class PhoneAbstractFractoryClass extends AbstractFactoryClass {
    @Override
    public SendMessageInterface absFactoryProduce() {
        return new PhoneSendImpl();
    }
}

public class TestAbstractFactoryClass {
    public static void main(String[] args) {

        MailAbstractFactoryClass mail = new MailAbstractFactoryClass();

        MailAbstractFactoryClass phone = new MailAbstractFactoryClass();

        mail.absFactoryProduce().send();
        phone.absFactoryProduce().send();
    }
}

接口和抽象类实现抽象工厂模式的区别是什么？

其实就是接口和抽象类的区别

解答地址

如果上面没有，可以看这个：传送门

传送门里面的Java基础里面有说

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

工厂模式总结

一、工厂模式其实也包含三种：
A:简单的：一个工厂里面只有一个方法，用的时候需要传入参数，
根据参数判断来创建哪个类
B：一个工厂里面多个方法，实现不同的功能，使用的时候调用不同的接口即可
C: 静态工厂： 和B的区别就是工厂里面的N个方法都被static修饰了，使用的时候不需要创建实例
可以直接调用
对于上面的选用C最好，但是无论是ABC都不太好，因为每次新增一个功能都要修改工厂类。
所以：引入抽象工厂模式
二、抽象工厂模式：
就是每次增加一个功能只需要添加一个类去实现即可