工厂方法模式（Factory Method）

亦凉 2022-04-15 00:40 166阅读 0赞

**设计模式的六大原则**

**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）**

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

工厂方法模式分为三种：

***普通工厂模式***，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。首先看下关系图：

![421a1a3f-6777-3bca-85d7-00fc60c1ae8b.png][]

举例如下：（我们举一个发送邮件和短信的例子）

首先，创建二者的共同接口：

**\[java\]** [view plain][] [copy][view plain]

1.  public interface Sender \{  
2.      public void Send();  
3.  \}

其次，创建实现类：

**\[java\]** [view plain][][copy][view plain]

1.  public class MailSender implements Sender \{  
2.      @Override  
3.      public void Send() \{  
4.          System.out.println("this is mailsender!");  
5.      \}  
6.  \}

**\[java\]** [view plain][][copy][view plain]

1.  public class SmsSender implements Sender \{  
2.    
3.      @Override  
4.      public void Send() \{  
5.          System.out.println("this is sms sender!");  
6.      \}  
7.  \}

最后，建工厂类：

**\[java\]** [view plain][][copy][view plain]

1.  public class SendFactory \{  
2.    
3.      public Sender produce(String type) \{  
4.          if ("mail".equals(type)) \{  
5.              return new MailSender();  
6.          \} else if ("sms".equals(type)) \{  
7.              return new SmsSender();  
8.          \} else \{  
9.              System.out.println("请输入正确的类型!");  
10.             return null;  
11.         \}  
12.     \}  
13. \}

我们来测试下：

1.  public class FactoryTest \{  
2.    
3.      public static void main(String\[\] args) \{  
4.          SendFactory factory = new SendFactory();  
5.          Sender sender = factory.produce("sms");  
6.          sender.Send();  
7.      \}  
8.  \}

输出：this is sms sender!

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

![84673ccf-ef89-3774-b5cf-6d2523cd03e5.jpg][]

将上面的代码做下修改，改动下SendFactory类就行，如下：

**\[java\]** [view plain][][copy][view plain]public class SendFactory \{

public Sender produceMail()\{

1.          return new MailSender();  
2.      \}  
3.        
4.      public Sender produceSms()\{  
5.          return new SmsSender();  
6.      \}  
7.  \}

测试类如下：

**\[java\]** [view plain][][copy][view plain]

1.  public class FactoryTest \{  
2.    
3.      public static void main(String\[\] args) \{  
4.          SendFactory factory = new SendFactory();  
5.          Sender sender = factory.produceMail();  
6.          sender.Send();  
7.      \}  
8.  \}

输出：this is mailsender!

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

**\[java\]** [view plain][][copy][view plain]

1.  public class SendFactory \{  
2.        
3.      public static Sender produceMail()\{  
4.          return new MailSender();  
5.      \}  
6.        
7.      public static Sender produceSms()\{  
8.          return new SmsSender();  
9.      \}  
10. \}

**\[java\]** [view plain][][copy][view plain]

1.  public class FactoryTest \{  
2.    
3.      public static void main(String\[\] args) \{      
4.          Sender sender = SendFactory.produceMail();  
5.          sender.Send();  
6.      \}  
7.  \}

输出：this is mailsender!

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

**抽象工厂模式（Abstract Factory）**

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

![34a0f8de-16e0-3cd5-9f69-257fcb2be742.jpg][]

请看例子：

**\[java\]** [view plain][][copy][view plain]

1.  public interface Sender \{  
2.      public void Send();  
3.  \}

两个实现类：

**\[java\]** [view plain][][copy][view plain]

两个工厂类：

**\[java\]** [view plain][][copy][view plain]

1.  public class SendMailFactory implements Provider \{  
2.        
3.      @Override  
4.      public Sender produce()\{  
5.          return new MailSender();  
6.      \}  
7.  \}

**\[java\]** [view plain][][copy][view plain]

1.  public class SendSmsFactory implements Provider\{  
2.    
3.      @Override  
4.      public Sender produce() \{  
5.          return new SmsSender();  
6.      \}  
7.  \}

在提供一个接口：

**\[java\]** [view plain][][copy][view plain]

1.  public interface Provider \{  
2.      public Sender produce();  
3.  \}

测试类：

**\[java\]** [view plain][][copy][view plain]

1.  public class Test \{  
2.    
3.      public static void main(String\[\] args) \{  
4.          Provider provider = new SendMailFactory();  
5.          Sender sender = provider.produce();  
6.          sender.Send();  
7.      \}  
8.  \}

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

原文链接：**http://blog.csdn.net/zhangerqing**

[421a1a3f-6777-3bca-85d7-00fc60c1ae8b.png]: /images/20220415/230f8fa713e1455f893db11b6a715670.png
[view plain]: http://blog.csdn.net/zhangerqing/article/details/8194653
[84673ccf-ef89-3774-b5cf-6d2523cd03e5.jpg]: /images/20220415/583a4bc618b54395ad5a79564d389584.png
[34a0f8de-16e0-3cd5-9f69-257fcb2be742.jpg]: /images/20220415/34d6a630c78c401ebe8c00ca9bcb6101.png