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{
@Override
public Food createFood() {
return new Apple();
}

@Override
public Vehicle crateVehicle() {
return new Car();
}

@Override
public Weapon createWeapon() {
return new AK47();
}

}

package com.chb.factoryDEsingPattern_AbstractFactory;
public class MagicFactory implements AbstractFactory{
@Override
public Food createFood() {
return new Mushroom();
}

@Override
public Vehicle crateVehicle() {
return new Broom();
}

@Override
public 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...

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

好的，来了：

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

老白呀， 老子怎么觉得缺点什么， 衣食无忧， 有车游山玩水， 有枪闯天下，还缺什么呢？

老白: 爷， 酒足饭饱思淫欲， 你还缺一个妞，嘿嘿！

对， 老白知我心呀， 老白给爷弄个妞，

老白： 好的，通知下去，给大爷弄个妞来

凡人（魔法）厂长: 白爷，我们没有这个生产线， 而且你的规范里也没有这个要求， 如果你修改规范， 我们生产线要大改， 而且成本提高。

老白： 这一动，伤筋动骨，到底变不变。。。不改，生产不了

于是老白卒（抽象工厂模式遇到难题）

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