java 设计模式 学习笔记（3） 抽象工厂模式

抽象工厂模式 ： 提供一个创建一系列相关的或相互依赖对象的接口，而无需指定它们具体的类。

1. 在这个设计模式中，有抽象工厂接口， AbstracFactory Class 。这个接口有两个方法，分别用来创建抽象 Animal 和 抽象 Fruit 。也就是说，它会分别创建Animal 和 Fruit ，但具体不确定到底是 创建 Animal 中的 Bear 还是 Cat ，创建 Fruit 中的 Banana 还是 Apple。

public interface AbstractFactory { public Animal createAnimal(); public Fruit createFruit(); }

2. 类似于前面两种工厂 类，抽象工厂模式有两个抽象产品，分别是 Animal 和 Fruit 。当然也可以再添加抽象产品 Human 之类的，但 这个时候就可能要在 工厂类中添加 createHuman 方法。

/** * 这是一个动物类，有一个所有动物都有的方法 shout * @author liaogang.pt */ public abstract class Animal { public void shout(){ System.out.println("you create a :"+this.getClass().getName()); } } /** * 这是一个抽象方法，有所有水果的共同方法 eat（），被人类吃。 * @author liaogang.pt * */ public abstract class Fruit { public void eat(){ System.out.println("you eat a :"+this.getClass().getName() + "in Fruit class"); } }

3. 分别有cat,bear 类继承了 Animal 类， Apple ，banana 类继承了Fruit。 其中Bear 类重写了 shout（） 方法，用来表示Bear 和 Cat 是两个不同的产品。同样Apple 类重写了 eat（） 方法来表示和 Banana 的不同实现。

/** * 这是一个熊类，简单起见，它继承了 Animal 类，同时也就继承了shout 方法 * @author liaogang.pt */ public class Bear extends Animal{ public void shout(){ System.out.println("you create a bear in Bear class" ); } } /** * 这是一个猫类，简单起见，它继承了 Animal 类，同时也就继承了shout 方法 * @author liaogang.pt */ public class Cat extends Animal{ }

public class Apple extends Fruit{ public void eat(){ System.out.println("you create a apple in Apple Class"); } } public class Banana extends Fruit{ }

4. 建立一个具体工厂类SpecificFactory1来implements 抽象工厂，并实现了 createAnimal （） 和 createFruit（） 方法，来创建一个 Bear 和 一个 Apple

public class SpecificFactory1 implements AbstractFactory { @Override public Animal createAnimal() { // TODO Auto-generated method stub return new Bear(); } @Override public Fruit createFruit() { // TODO Auto-generated method stub return new Apple(); } }

5. 建立一个具体工厂类SpecificFactory12来implements 抽象工厂，并实现了 createAnimal （） 和 createFruit（） 方法，来创建一个 Bear 和 一个 Banana 。

public class SpecificFactory2 implements AbstractFactory{ @Override public Animal createAnimal() { // TODO Auto-generated method stub return new Bear(); } @Override public Fruit createFruit() { // TODO Auto-generated method stub return new Banana(); } }

6. 建立TestAbstractFactory 类来测试实验结果：

1.先声明一个抽象工厂AbstractFactory，接着 用具体工厂SpecificFactory1 来对它赋值

2. 分别创建一个 抽象Fruit 类和一个 抽象Animal 类，

3. 调用 Fruit 的eat（）方法 和 调用 Animal 的 shout（） 方法

从这里的逻辑可以看出，关键在于我们用了哪一个具体工厂来给 AbstractFactory 赋值，赋值不一样，那么产生的两个产品类也不一样，最后导致产品类调用 eat 和 shout 方法产生的结果不一样。

public class TestAbstractFactory { public static void main(String[] args){ AbstractFactory factory = new SpecificFactory1(); Animal animal = factory.createAnimal(); Fruit fruit = factory.createFruit(); animal.shout(); fruit.eat(); } } 结果： you create a bear in Bear class you create a apple in Apple Class

如果将

AbstractFactory factory = new SpecificFactory1();

改成

AbstractFactory factory = new SpecificFactory2();

其他地方代码不变，那么结果将是：

you create a bear in Bear class
you eat a :Banana

最后的讨论：

为什么要使用抽象工厂？

根据上面的实验结果，可以知道，用户需要创建两种产品，但具体着两种产品中的哪两个产品可能会随着时间的变化而变化。一个种类的产品的差异在于其具体实现不同，但有其共同点。通俗地讲，用户需要一个宠物和一个水果，他需要一个宠物来陪他，还需要一个水果吃。但是用户只喜欢宠物中的Bear 和 Cat ，也只喜欢 水果中的 Apple 和BANANA 。但现在不确定到底是要宠物中的Bear 或Cat，水果中的Apple 或 Banana。那么这个时候，就应该抽象出一个 Animal 类和一个 Fruit 类，Animal 类中有shout 方法类陪他解闷，Fruit 类中eat（） 方法类给他填饱肚子。

因为他只需要一个 Animal 和一个 Fruit ，假设我们一开始就建立一个具体工厂来分别创建一个 Bear 类 和 一个Apple 类。如果用户这个时候喜欢 Bear 和 BANANA 的组合，那么我们就得修改 这个具体工厂类，让其创建一个Bear 类和一个 BANANA类，假设用户的需求一直在变化，那么我们就得一直更改这个具体工厂。如果修改的地方多了，那么我们在改代码的时候就非常容易出错。

这个时候就建立一个 抽象工厂，来创建 一个抽象 的Animal和一个抽象的 Fruit。然后建立一个具体工厂来Implements 抽象工厂，并实现了createFriut （） 和 createAnimal（） ，用来创建 Bear 和Apple 组合。并在用户代码中使用多态来的方式来创建Animal 类和Fruit 类。

AbstractFactory factory = new SpecificFactory2();
Animal animal = factory.createAnimal();
Fruit fruit = factory.createFruit();

如果用户不喜欢Bear 和Apple 组合，改成了喜欢 Cat 和 Banana 组合，那么我就再建议一个 具体工厂类，来分别创建一个 Cat 类 和一个Banana 类，而只需要在用户代码中 将SpecificFactory2 改成 SpecificFactoryX 就可以了，除了新建的具体工厂类，其他地方的代码都不用做修改。