女娲造人？工厂模式？

╰+哭是因爲堅強的太久メ 2021-07-31 19:49 314阅读 0赞

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg]

阅读文本大概需要 8 分钟。

**前言**

明天就是元旦了，久一祝读者朋友元旦快乐呀。元旦假期，久一打算把Vue.js撸完，跟着我的脚步，感兴趣点击链接 ![2\_02.png][2_02.png]

看到倪升武大佬写了一篇不错的文章，分享给你，觉得文章不错可以点击文末「阅读原文」关注大佬，跟紧大佬的脚步。女娲造人的时候就已经有了工厂模式？请看正文！

**正文**

工厂模式使用的频率非常高，我们在开发中总能见到它们的身影。即定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。这是一篇纯技术文，我们直奔主题，工厂方法模式的通用类图如下所示。

![640][]

如图所示，Product抽象类负责定义产品的共性，实现对事物最抽象的定义，Creator为抽象工厂类，具体如何创建产品类由具体的实现工厂ConcreteCreator来完成。我们来看一下通用的模板代码。

public abstract class Product \{  
   
 public void method() \{   
   // 产品类的公共方法，已经实现实现了公共的逻辑  
 \}  
 //非公共方法，需要子类具体实现  
 public abstract void method2();   
\}

具体产品类可以有多个，都继承与抽象类Product，如下。

public class ConcreateProduct1 extends Product \{  
   
 @Override  
 public void method2() \{  
   //product1的业务逻辑  
 \}  
\}  
public class ConcreateProduct2 extends Product \{  
  
 @Override  
 public void method2() \{  
   //product2的业务逻辑  
 \}  
\}

抽象工厂类负责定义产品对象的产生，代码如下。

public abstract class Creator \{  
 //创建一个产品对象，其输入参数类型可以自行设置  
 public abstract <T extends Product> T createProduct(Class<T> clazz);  
\}

这里用的是泛型，传入的对象必须是Product抽象类的实现类。具体如何产生一个产品的对象，是由具体工厂类实现的，具体工厂类继承这个抽象工厂类。

public class ConcreteCreator extends Creator \{  
  
 @Override  
 public <T extends Product> T createProduct(Class<T> clazz) \{  
   Product product = null;  
   try \{  
     product = (Product) Class.forName(clazz.getName()).newInstance();  
   \} catch (Exception e) \{ //异常处理  
     e.printStackTrace();  
   \}  
   return (T) product;  
 \}  
\}

通过这样的设计，我们就可以在测试类中随意生产产品了，看下面的测试类。

public class FactoryTest \{   
  
 public static void main(String\[\] args) \{  
   Creator factory = new ConcreteCreator();  
   //通过不同的类创建不同的产品  
   Product product1 = factory.createProduct(ConcreteProduct1.class);   
   Product product2 = factory.createProduct(ConcreteProduct2.class);  
    /\*  
     \* 下面继续其他业务处理  
     \*/  
  \}  
\}

下面真正进入正题，我们来看看女娲是如何利用工厂模式来造人的。

现在女娲要造人，她要造三种人：白种人、黄种人和黑种人。怎么造呢？她得有个能产生人类的工厂吧（类似于八卦炉的东西），这个工厂得让她生产出不同的人种。每个人都有两个属性：皮肤颜色和说话。那现在我们开始设计女蜗造人的程序，首先我们看一下造人的类图。

![640][640 1]

抽象接口Human是人类，里面有两个方法，getColor获得皮肤颜色，talk交谈。下面三个具体Human的实现类，分别实现三个人种。根据工厂模式，应该有个抽象工厂，AbstractHumanFactory就担当了这个责任，里面有个抽象方法createHuman，那HumanFactory就是实现类了，实现抽象工厂里的方法。下面我们看看具体实现。

public interface Human \{  
 //人有不同的颜色    
 public void getColor();    
 //人会说话  
 public void talk();   
\}

接下来对Human接口的不同实现。

public class BlackHuman implements Human \{  
  
 @Override  
 public void getColor() \{  
   // 黑种人  
   System.out.println("Black");  
 \}  
 @Override  
 public void talk() \{  
   System.out.println("Black man");  
 \}  
\}  
public class Human implements Human \{    
  
 @Override  
 public void getColor() \{  
   //黄种人  
   System.out.println("Yellow");  
 \}  
 @Override  
 public void talk() \{  
   System.out.println("Yellow man");  
 \}  
\}  
public class WhiteHuman implements Human \{  
  
 @Override  
 public void getColor() \{  
   //白种人  
   System.out.println("White");  
 \}  
 @Override  
 public void talk() \{  
   System.out.println("White man");  
 \}  
\}

好了，人的模子搞好了，现在女娲要开始搭建八卦炉了，于是女娲开始画八卦炉模型了。

public abstract class AbstractHumanFactory\{  
 //注意这里T必须是Human的实现类才行，因为要造Human嘛  
 public abstract <T extends Human> T createHuman(Class<T> clazz);   
\}

然后女娲开始具体实现这个八卦炉了。

public class HumanFactory extends AbstractHumanFactory \{  
  
 @Override  
 public <T extends Human> T createHuman(Class<T> clazz) \{  
   Human human = null;  
   try \{  
     human = (Product) Class.forName(clazz.getName()).newInstance();  
   \} catch (Exception e) \{   
     //异常处理  
     System.out.println("人种产生错误");  
   \}  
   return (T) human;  
 \}  
\}

好，现在人种也有了，八卦炉也有了，剩下的就是采集黄土，然后命令八卦炉开始生产了。

public class FactoryTest \{  
 public static void main(String\[\] args) \{  
   AbstractHumanFactory bagualu = new HunmanFactory();  
   //黑人诞生了  
   Human blackMan = bagualu.createHuman(BlackHuman.class);   
   //黄人诞生了  
    Human yellowMan = bagualu.createHuman(YelloHuman.class);  
   //白人诞生了   
   Human whiteMan = bagualu.createHuman(WhiteHuman.class);   
   \}  
\}

女娲就是这么把人造出来的……这就是工厂模式。

当然，工厂模式还可以扩展，比如静态工厂模式、多个工厂模式、利用工厂模式来替代单例模式、延迟初始化等等。由于篇幅原因，我在这就不展开了，感兴趣的同学可以点击左下角“阅读原文”关注倪升武大佬。

此文章是倪升武大佬的文章，如果感兴趣可以点击文章下方「阅读原文」关注大佬的订阅号！

**推****荐****阅****读**

***1.***

***2. ***

***3.***

***4.***

![640?][640 2]

[640_wx_fmt_jpeg]: /images/20210731/a0227cdcc00d44e79ab7284060c1b273.png?wx_fmt=jpeg
[2_02.png]: /images/20210731/1e953ac16a424f6ba9c43aac4782783a.png
[640]: /images/20210731/74bb2de011544661b24df842f6c56000.png
[640 1]: /images/20210731/2b67dd289b6847eea3cde8c8880f0b18.png
[640 2]: /images/20210731/04453dabb3d54adeb1840822772c74bf.png?