23种设计模式01---工厂模式之抽象工厂模式

前言

在上篇文章 23种设计模式01—工厂模式
中介绍了简单工厂模式和工厂方法模式，
但是简单工厂模式在添加新的产品师，需要修改工厂类，违背了开闭原则（OCP原则）；
工厂方法模式，提供一个抽象工厂角色，一旦要创建新的同一产品的不同型号， 只需要创建一个具体工厂角色，用于创建对应的产品，而不用修改原有的代码，解决了简单工厂的缺点。
但是，如果要产生不同系列的产品，工厂方法模式就无能为力了。

一、抽象工厂模式

首先我们来描述一个人， 开着车， 嘴里叼着苹果， 手里拿着ak47，很潇洒。。。
这个人有三个对象描述他的状态，车(交通工具），苹果（食物），ak47(武器)

package com.chb.factoryDEsingPattern_AbstractFactory;
public class Car {public void run() {System.out.print("老子开着车,");}
}package com.chb.factoryDEsingPattern_AbstractFactory;
public class Apple {public void eat() {System.out.print("嘴里叼着苹果,");}
}package com.chb.factoryDEsingPattern_AbstractFactory;
public class AK47 {public void shoot() {System.out.println("手里拿着ak47, da da da...");}
}

这是个怎么样的人呢

package com.chb.factoryDEsingPattern_AbstractFactory;
public class Test {public static void main(String[] args) {Car car = new Car();car.run();Apple apple = new Apple();apple.eat();AK47 ak47 = new AK47();ak47.shoot();}
}结果：老子开着车,嘴里叼着苹果,手里拿着ak47, da da da...

但是老子吃的，用的，武器都是自己造的，这个太费事，不好，给我来个工厂，可以创造这些产品，

package com.chb.factoryDEsingPattern_AbstractFactory;
public class DefaultFactory {public Car createCar(){return new Car();}public Apple createApple() {return new Apple();}public AK47 createAk47() {return new AK47();}
}

这个工厂帮我创建所需要的产品

package com.chb.factoryDEsingPattern_AbstractFactory;
public class Test {public static void main(String[] args) {//我要找到这个工厂DefaultFactory df = new DefaultFactory();//这个工厂帮我创建我所需要的所有商品Car car = df.createCar();car.run();Apple apple = df.createApple();apple.eat();AK47 ak47 = df.createAk47();ak47.shoot();}
}

又不满足了， 普通人做烦了，老子要做哈利波特，

哈利波特骑着扫把， 使用魔法棒， 吃毒蘑菇

package com.chb.factoryDEsingPattern_AbstractFactory;
public class Broom {public void run() {System.out.println("扫把，给老子冲...");}
}package com.chb.factoryDEsingPattern_AbstractFactory;
public class Mushroom {public void eat() {System.out.print("吃个蘑菇回血了，");}
}package com.chb.factoryDEsingPattern_AbstractFactory;
public class MagicStick {public void shoot() {System.out.print("Avada Kedavra, 烧死你。。。");}
}

活不能自己干， 来个魔法工厂

package com.chb.factoryDEsingPattern_AbstractFactory;public class MagicFactory {public Broom createBroom() {return new Broom();}public Mushroom createMushroom() {return new Mushroom();}public MagicStick createMagicStick() {return new MagicStick();}}

检验一下装备怎么样

尼玛，老子总共要三个装备，一会普通工厂，一会魔法工厂， 老子有钱，来个VIP, 老子想当平凡人， 你要个凡人套装； 老子相当超人， 你给个魔法套装。

两个厂长：大爷，我们只做凡人套装（我们制作魔法套装）。

于是他们被炒了， 我的想法实现不了吗？

空手套白狼厂长:大爷，我们可以做，而且实惠。只需定金三百万。

大爷不差钱，满足我的要求，钱不是问题， 先给你五百万。

空手套白狼厂长的分析

不管是凡人套装，还是魔法套装，就是三个系列产品：
交通工具：Car VS Broom
食物：Apple VS Mushroom
武器： AK47 VS MagicStick
我来定义一个规范， 产生这三个产品， 让那两个SB**当苦力**

规范

交通工具可以跑， 食物可以吃， 武器有攻击力。

package com.chb.factoryDEsingPattern_AbstractFactory;
public interface Vehicle {void run();
}package com.chb.factoryDEsingPattern_AbstractFactory;
public interface Food {void eat();
}package com.chb.factoryDEsingPattern_AbstractFactory;
public interface Weapon {void shoot();
}

空手套白狼厂长将规范给两个厂长

于是他们都按照规范做产品, 下面只展示一个案例

空手套白狼厂长：另外，对于我的客户来说你们就是空手套白狼厂， 于是，两个厂成为了第三方, 我们是签过保密协议的。。。

于是对外都为空手套白狼厂(AbstractFactory ):

package com.chb.factoryDEsingPattern_AbstractFactory;
public interface AbstractFactory {public abstract Food createFood();public abstract Vehicle crateVehicle();public abstract Weapon createWeapon();
}

两个厂长为了生计，付出一些代价，成为第三方（做苦力）

package com.chb.factoryDEsingPattern_AbstractFactory;
public class DefaultFactory  implements AbstractFactory{@Overridepublic Food createFood() {return new Apple();}@Overridepublic Vehicle crateVehicle() {return new Car();}@Overridepublic Weapon createWeapon() {return new AK47();}}package com.chb.factoryDEsingPattern_AbstractFactory;
public class MagicFactory implements AbstractFactory{@Overridepublic Food createFood() {return new Mushroom();}@Overridepublic Vehicle crateVehicle() {return new Broom();}@Overridepublic Weapon createWeapon() {return new MagicStick();}}

规范订好了， 小弟苦力找了， 就剩下钱多人傻的大爷了

小狼呀， 给我来套凡人套装

好的，来了：

在这里，充分使用了父类引用指向子类对象，展现了好处。

package com.chb.factoryDEsingPattern_AbstractFactory;
public class Test {public static void main(String[] args) {// 下发指令， 小弟(DefaultFactory)干活AbstractFactory af = new DefaultFactory();Vehicle vehicle = af.crateVehicle();vehicle.run();Food food =af.createFood();food.eat();Weapon weapon = af.createWeapon();weapon.shoot();}
}老子开着车,嘴里叼着苹果,手里拿着ak47, da da da...

小狼呀， 给我来套魔法套装

好的，来了：

于是白狼靠着规范（制定者比执行者高级）和满足多方位需求，走向致富道路。。。

老白呀， 老子怎么觉得缺点什么， 衣食无忧， 有车游山玩水， 有枪闯天下，还缺什么呢？
老白: 爷， 酒足饭饱思淫欲， 你还缺一个妞，嘿嘿！
对， 老白知我心呀， 老白给爷弄个妞，
老白： 好的，通知下去，给大爷弄个妞来
凡人（魔法）厂长: 白爷，我们没有这个生产线， 而且你的规范里也没有这个要求， 如果你修改规范， 我们生产线要大改， 而且成本提高。
老白： 这一动，伤筋动骨，到底变不变。。。不改，生产不了
于是老白卒（抽象工厂模式遇到难题）

由上面对话可知，抽象工厂模式生产系列产品很好，但是在添加新的系列产品时，需要修改抽象工厂，同时具体工厂要实现对象的方法。违背了开闭原则。

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！