Java-工厂模式

大家好，欢迎来到IT知识分享网。

工厂模式：主要用来实例化有共同接口的类，工厂模式可以动态决定应该实例化那一个类。

目录

一、工厂模式的形态

二、简单工厂（Simple Factory）

三、工厂方法（Factory Method）（优点在于横向扩展）

四、抽象工厂（Factory Method）

五、适用场景：

一、工厂模式的形态

工厂模式主要有以下几种形态：

1. 简单工厂（Simple Factory）
2. 工厂方法（Factory Method）
3. 抽象工厂（Abstract Factory）

二、简单工厂（Simple Factory）

定义：专门定义一个类（第三方）来创建其他类实例（解耦，将客户端创建对象的操作解耦到外部第三方类），被创建的实例通常都具有共同的父类。  —用于没有产品族并且产品个数较少

eg：

首先定义一个抽象类：机器，可以用来生产电脑

然后定义多个具体产品类：产品流水线，每个流水线负责生产该品牌产品

最后定义一个工厂类：工厂类中有许多不同流水线，其中可以生产多品牌电脑

用户想要的时候，只用在客户端输入想要的产品，与此对应的产品就会从工厂中生产，用户不必知道是如何生产的

组成：   a.一个抽象类           interface factory

             b.N个具体产品类     class MacBook implements factory{}     class Aline implements factory{}   ……

             c.一个工厂类           class RealFactory{ public static factory produce(String pro){…} }

//简单工厂模式 //定义一个抽象类,假设这是一个生产电脑的机器 interface factory{ void create(); } //---------------------- 多个具体产品类 ------------------------------------- //定义一个产品类，使用此机器生产品牌电脑 class MacBook implements factory{ @Override public void create() { System.out.println("生产一个MacBook电脑"); } } class Acer implements factory{ @Override public void create() { System.out.println("生产一个Acer电脑"); } } class Aline implements factory{ @Override public void create() { System.out.println("生产一个Aline电脑"); } } //--------------------------------------------------------------- //定义一个工厂类，拥有几条流水线工程来生产不同品牌的电脑 class RealFactory{ public static factory produce(String name) { if (name.equals("MacBook")) { return new MacBook(); } else if (name.equals("Acer")) { return new Acer(); } else if (name.equals("Aline")) { return new Aline(); } System.out.println("此工厂不生产"+name); return null; } } public class SimpleFactory { public static void main(String[] args) { RealFactory fac = new RealFactory(); System.out.println("请输入你想要的电脑："); Scanner in = new Scanner(System.in); String name = in.next(); fac.produce(name).create(); } } 

结果：

正确输入：     

错误输入：

       由上面的代码可以看出，简单工厂的核心就是一个RealFactory类，他拥有必要的逻辑判断能力和所有产品的创建权利，我们只需要向把定单给他，就能得到我们想要的产品。这使用起来似乎非常方便。

       但是，实际上，这个RealFactory有很多的局限。首先，我们每次想要增加一种新产品的时候，都必须修改RealFactory的原代码，这显然违反了开闭原则。其次，当我们拥有很多很多产品的时候，而且产品之间又存在复杂的层次关系的时候，这个类必须拥有复杂的逻辑判断能力，其代码量也将不断地激增，这非常不符合我们的编码原则。还有就是，整个系统都严重依赖RealFactory类，如果RealFactory类出问题，系统就进入不能工作的状态，这也是最为致命的一点….

所以简单工厂只适合于产品对象较少，且产品固定的需求，对于产品变化无常的需求来说显然不合适

以上的不足将在工厂模式的另外两种状态中得到解决。

三、工厂方法（Factory Method）（优点在于横向扩展）

上面的代码告诉我们，简单工厂是整个模式的核心，一旦他出了问题，整个模式都将受影响而不能工作，为了降低风险和为日后的维护、扩展做准备，我们需要对它进行重构，引入工厂方法。

定义：工厂方法定义一个用来创建对象的接口，用多态来削弱了工厂类的职能，让子类决定实例化哪一个工厂。

eg：

          首先定义一个抽象类：机器，可以用来生产电脑

          然后定义多个具体产品类：产品流水线，每个流水线负责生产该品牌产品

          然后定义一个抽象工厂，工厂可以流水线生产电脑

          最后定义多个工厂类：每个工厂可以生产自己品牌的电脑

          用户想要的时候，只用找到对应品牌的工厂发送请求，与此对应的产品就会从工厂中生产，每个品牌工厂自己管理自己流水线电脑，其他的工厂产品出问题或者倒闭了都和自家的没关系：）

组成：  a. 一个抽象产品类    interface Computre

            b.多个具体产品类   class MacBook implements Computre   。。。

            c.一个抽象工厂       interface ComputerFactory

            d.多个具体工厂（每个产品族对应一个具体工厂）   class msFactory implements ComputerFactory

interface Computre{ void create(); } //---------------------- 多个具体产品类 ------------------------------------- class MacBook implements Computre{ @Override public void create() { System.out.println("生产一个MacBook电脑"); } } class Aline implements Computre{ @Override public void create() {System.out.println("生产一个外星人电脑");} } class Acer implements Computre{ @Override public void create() {System.out.println("生产一个Acer电脑"); } } //------------------------------------------------------------------------------ interface ComputerFactory{ Computre createComputer(); } //---------------------- 多个具体工厂 ------------------------------------- //弘基电脑工厂 class msFactory implements ComputerFactory{ @Override public Computre createComputer() { return new Acer(); } } //苹果产品工厂 class AppleFactory implements ComputerFactory{ @Override public Computre createComputer() { return new MacBook(); } } //微软产品工厂 class AcerFactory implements ComputerFactory{ @Override public Computre createComputer() { return new Aline(); } } //------------------------------------------------------------------------------ public class FactoryMethod{ public static void main(String[] args) throws InterruptedException { ComputerFactory computerFactory = new AppleFactory(); Computre computre = computerFactory.createComputer(); computre.create(); } }

结果：

        从上面创建产品的栗子可以看出，工厂方法和简单工厂的主要区别是，简单工厂是把创建产品的职能都放在一个类里面，而工厂方法则把不同的产品放在实现了工厂接口的不同工厂类里面，这样就算其中一个工厂类出了问题，其他工厂类也能正常工作，互相不受影响，以后增加新产品，也只需要新增一个实现工厂接口工厂类，就能达到，不用修改已有的代码。

       但是工厂方法也有他局限的地方，那就是当面对的产品有复杂的等级结构的时候，例如，苹果工厂除了生产电脑，还生产手机产品，这样一来电脑和手机就是两大产品家族了，这两大家族下面包含了数量众多的产品，每个产品又会有多个型号，这样就形成了一个复杂的产品树了。如果用工厂方法来设计这个产品家族系统，就必须为每个型号的产品创建一个对应的工厂类，当有数百种甚至上千种产品的时候，也必须要有对应的上百成千个工厂类，这在现实中显然是不可能发生的。

四、抽象工厂（Factory Method）

抽象工厂：意的意图在于创建一系列互相关联或互相依赖的对象。

特点：提供一个创建一系列相关或相互依赖对象的接口（抽象工厂、多条产品线），而无需指定他们具体的类。

       抽象工厂和工厂方法的模式基本一样，区别在于，工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组相同，有相对关系的产品；重点在于一组，一批，一系列。

举个例子，假如生产华为手机，小米手机有很多系列，华为荣耀系列、华为P系列、华为Nova系列等；假如Nova3生产需要的配件有麒麟970的处理器，6.3英寸屏幕，而荣耀10只需要麒麟940的处理器和5.84寸的屏幕就可以了；用抽象工厂来实现：

//抽象工厂 //CPU接口 interface Cpu { void run(); class Cpu940 implements Cpu { @Override public void run() { System.out.println("我的CPU是麒麟940呦"); } } class Cpu970 implements Cpu { @Override public void run() { System.out.println("我的CPU是麒麟970"); } } } //屏幕接口 interface Screen { void size(); class Screen5 implements Screen { @Override public void size() { System.out.println("我的屏幕是5寸"); } } class Screen6 implements Screen { @Override public void size() { System.out.println("我的屏幕是6寸"); } } } //工厂接口 interface PhoneFactory { Cpu getCpu();//使用的cpu Screen getScreen();//使用的屏幕 } //--------------------------------具体实现类--------------------------- //Nova3 class Nova3Factory implements PhoneFactory { @Override public Cpu getCpu() { return new Cpu.Cpu970(); } @Override public Screen getScreen() { return new Screen.Screen6(); } } //荣耀10 class HonorFactory implements PhoneFactory { @Override public Cpu getCpu() { return new Cpu.Cpu940(); } @Override public Screen getScreen() { return new Screen.Screen5(); } } //------------------------------------------------------------------- public class AbstFactory { public static void main(String[] args) { PhoneFactory phone = new Nova3Factory(); phone.getCpu().run(); phone.getScreen().size(); } } 

从以上的例子可以看出，抽象工厂可以解决一系列的产品生产的需求，对于大批量，多系列的产品，用抽象工厂可以更好的管理和扩展；

五、适用场景：

无论是简单工厂模式，工厂方法模式还是抽象工厂模式，它们都具有类似的特性，适用场景也十分类似。

        无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。

        所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。使用工厂方法后，调用端的耦合度大大降低了。并且对于工厂来说，是可以扩展的，以后如果想组装其他的产品，只需要再增加一个工厂类的实现就可以。无论是灵活性还是稳定性都得到了极大的提高。