设计模式之工厂模式，但是宝可梦

前言

工作一年了，业务代码写太多，还是得自驱提升点技术。希望工作一年后写出来的能有更多自己的思考。

正文

工厂模式是一种创建型设计模式，主要的目的还是在创建一个对象时提供更灵活、更易扩展的机制。

简单工厂模式

情景模拟

小智到商店去买精灵球，精灵球的种类繁多。商店店员会在库房中根据小智的要求拿对应的精灵球。在这个过程中，作为买家，小智不需要关注精灵球放在库房的哪一个位置。

/**
* 精灵球可以查看成功率，实现类有普通球和超级球
**/
public interface Ball {void showDetails();
}class NormalBall implements Ball{@Overridepublic void showDetails() {System.out.println("This is a normal ball. 15% to catch");}
}class SuperBall implements Ball{@Overridepublic void showDetails() {System.out.println("This is a super ball. 25% to catch");}
}/*** 精灵球商店*/
public class BallShop {public static Ball getBall(int ballCode){if (ballCode == 0){// 去放普通球的地方...return new NormalBall();}if (ballCode == 1){// 去放超级球的地方...return new SuperBall();}return null;}
}

对比一下直接new创建类和用工厂模式创建类：

	Ball ball1 = new NormalBall();Ball ball2 = new SuperBall();Ball normalBall = BallShop.getBall(0);Ball superBall = BallShop.getBall(1);

有一个很直观的区别：我根本不需要关心new的是什么实现类，我只需要传入对应的参数，告诉工厂我需要什么实现类。更规范一点，可以把0,1等数替换为枚举类，这样作为调用方，我无需关注怎么new的，new的什么类，我只需要相信工厂类会返回给我想要的类。

举例

DateFormat是简单工厂模式的经典运用，获取实例对象时，我只需要在getTimeInstance()方法传入类提供的枚举类，我无需关注内部实现细节，传入不同参数，后续的具体实现也就不同。

		DateFormat timeInstance = DateFormat.getTimeInstance(DateFormat.FULL);String format1 = timeInstance.format(new Date());DateFormat timeInstance2 = DateFormat.getTimeInstance(DateFormat.DATE_FIELD);String format2 = timeInstance2.format(new Date());System.out.println(format1);  // 中国标准时间 上午12:37:33System.out.println(format2);  // 上午12:37

不足

简单工厂模式对于简单场景是很友好的，实现很简单，如果能确保业务不再扩展，简单工厂模式是很好的选择。然而如果业务有扩展，简单工厂模式的弊端就体现出来了。

如果现在我新增了一个新的球种类——大师球。现在商店里的店员都需要知道大师球放在哪个位置，加重了商店店员的逻辑（工厂内创建逻辑）

class MasterBall implements Ball{@Overridepublic void showDetails() {System.out.println("MasterBall!!. 100% to catch");}
}

对应的工厂类就要做相应的适配：

public class BallShop {public static Ball getBall(int ballCode){if (ballCode == 0){// 去放普通球的地方...return new NormalBall();}if (ballCode == 1){// 去放超级球的地方...return new SuperBall();}if (ballCode == 2){// 去放大师球的地方...return new MasterBall();}return null;}
}

新增一个if分支的同时打破了开闭原则（对扩展开放，对修改封闭），其次，工厂类涵盖了所有的创建逻辑，高内聚。
为了解决业务会有新增的情况，根据面向对象编程的原则，抽象！引入工厂方法模式。

工厂方法模式

场景模拟

由于精灵球的种类不断增多，店员没办法记住每种球的位置（内聚太多逻辑），所以精灵球商店把店面分成了几个区域，每个区域售卖一种球，一个店员负责一个区域，这个店员只需要关注这个区域售卖的球在哪里。作为买家小智，他只需要知道他想买哪种球，然后去对应的分区，他仍然不需要关心球在哪里存放。

于是工厂类修改为：

public interface BallShopNew {Ball findBall();
}class NormalBallFactory implements BallShopNew{@Overridepublic Ball findBall() {return new NormalBall();}
}class SuperBallFactory implements BallShopNew{@Overridepublic Ball findBall() {return new SuperBall();}
}class MasterBallFactory implements BallShopNew{@Overridepublic Ball findBall() {return new MasterBall();}
}

使用方式：

public class FactoryDemo {public static void main(String[] args) {Ball masterBall = new MasterBallFactory().findBall();Ball normalBall = new NormalBallFactory().findBall();masterBall.showDetails();normalBall.showDetails();}
}

现在如果新推出了一种新的球，只需要开辟新的分区，聘请一个新店员（创建新的实现类），遵循了开闭原则。

不足

如果这个时候，产品维度发生了扩展，商店不止卖球了，还要卖贴纸。当产品变成复数，每个工厂就要进行相应的修改来支持新的产品，或者新增对应数量的新的工厂和实现类。系统中的类会变得极其多。抽象工厂模式用于解决复数产品的场景。

抽象工厂模式

抽象工厂模式首先将产品抽象：

public interface Label {void showColor();
}class NormalLabel implements Label{@Overridepublic void showColor() {System.out.println("红白配色");}
}class MasterLabel implements Label{@Overridepublic void showColor() {System.out.println("紫色配色");}
}

再在抽象工厂中引入抽象产品。

public interface BallLabelShop {Ball findBall();Label findLabel();
}class NormalBallLabelShop implements BallLabelShop{@Overridepublic Ball findBall() {return new NormalBall();}@Overridepublic Label findLabel() {return new NormalLabel();}
}class MasterBallLabelShop implements BallLabelShop{@Overridepublic Ball findBall() {return new MasterBall();}@Overridepublic Label findLabel() {return new MasterLabel();}
}

使用：

public class FactoryDemo {public static void main(String[] args) {MasterBallLabelShop masterBallLabelShop = new MasterBallLabelShop();Ball ball = masterBallLabelShop.findBall();Label label = masterBallLabelShop.findLabel();ball.showDetails();label.showColor();NormalBallLabelShop normalBallLabelShop = new NormalBallLabelShop();Ball ball2 = normalBallLabelShop.findBall();Label label2 = normalBallLabelShop.findLabel();ball2.showDetails();label2.showColor();}
}/**
MasterBall!!. 100% to catch
紫色配色
This is a normal ball. 15% to catch
红白配色
**/

这里可能就有读者会问，这不是和工厂方法模式差不多吗？其实我的理解是抽象方法模式中，工厂的实现类是将以产品组合为单位的。
上面的例子，两个工厂分别是组合了Normal和Master两种类型，让同一工厂生产的是能配套的产品组合。回到工厂模式的维度，使用者只需要知道什么工厂会给他想要的产品组合。

总结

作为一个细分了三个种类的设计模式，到底该如何取舍？比起直接new一个对象，使用对应模式的好处到底在哪？

简单工厂模式：
1. 根据传入的参数决定产出的对象，可以隐藏一些创建的细节
2. 适用于需要根据条件创建不同对象的场景。
工厂方法模式：
1. 将简单工厂转化为抽象工厂的子类，每个子类负责相应对象的创建，将创建逻辑从简单工厂中解耦到各自实现类。
2. 适用于要创建的对象会出现扩展的场景；或者是希望将创建逻辑分别封装在具体工厂类的场景。
抽象工厂模式：
1. 抽象工厂提供接口，用于创建一系列相关或者相互依赖的对象。
2. 适用于要创建复数种类的对象；或者是希望将创建逻辑封装在具体工厂类的场景。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/471267.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！