【设计模式】抽象工厂模式

抽象工厂（Abstract Factory Pattern）

抽象工厂模式：可以理解为是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

含义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
使用场景：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

在此使用从 族 以及 属性 两种入手方式构建抽象工厂

不同族 代码演示：

1、创建交通工具一族及颜色一族的接口

public interface Moveable{
   void go();
}

public interface Color {
   void fill();
}

2、创建接口实现类，即一族产品

交通工具一族

public class Car implements Moveable{
   @Override
   public void go() {
      System.out.println("Car with di di di di...");
   }
}

public class Train implements Moveable{
   @Override
   public void go() {
      System.out.println("Train with wu wu wu wu...");
   }
}

public class Plane implements Moveable{
   @Override
   public void go() {
      System.out.println("Plane with biu biu biu biu...");
   }
}

颜色一族

public class Red implements Color {
   @Override
   public void fill() {
      System.out.println("color is red...");
   }
}

public class Green implements Color {
   @Override
   public void fill() {
      System.out.println("color is green...");
   }
}

public class Blue implements Color {
   @Override
   public void fill() {
      System.out.println("color is blue...");
   }
}

3、为 Moveable和 Color 对象创建抽象类及获取方法

public abstract class AbstractFactory {
   public abstract Moveable getMoveable(String moveType) ;
   public abstract Color getColor(String colorType);  
}

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("moveable")){
         return new MoveableFactory();
      } else if(choice.equalsIgnoreCase("color")){
         return new ColorFactory();
      }
      return null;
   }
}

4、创建基于AbstractFactory 的具体工厂类

public class MoveableFactory extends AbstractFactory{
	@Override
    public Moveable getMoveable(String moveType){
        if(moveType == null){
            return null;
        }
        if(moveType.equalsIgnoreCase("car")){
            return new Car();
        } else if(moveType.equalsIgnoreCase("train")){
            return new Train();
        } else if(moveType.equalsIgnoreCase("plane")){
            return new Plane();
        }
        return null;
    }
     @Override
	 public Color getColor(String colorType) {
	    return null;
	 }
}

public class ColorFactory extends AbstractFactory {   
   @Override
   public Moveable getMoveable(String moveType){
      return null;
   }
   @Override
   public Color getColor(String colorType) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("red")){
         return new Red();
      } else if(color.equalsIgnoreCase("green")){
         return new Green();
      } else if(color.equalsIgnoreCase("blue")){
         return new Blue();
      }
      return null;
   }
}

验证：

public class AbstractFactoryTest {
    public static void main(String[] args) {
        //获取交通工具工厂
        AbstractFactory moveableFactory = FactoryProducer.getFactory("moveable");
        moveableFactory.getShape("car").go();
        moveableFactory.getShape("train").go();
        moveableFactory.getShape("plane").go();
        //获取颜色工厂
        AbstractFactory colorFactory = FactoryProducer.getFactory("color");
        colorFactory.getColor("red").fill();
        colorFactory.getColor("green").fill();
        colorFactory.getColor("blue").fill();
    }
}

拥有相同属性的不同族 代码演示：

1、创建相同行为及不同族之间的实现方式

猫与狗都具有叫声、移动、以及食物属性
猫与狗实现叫声、移动、以及食物属性的方式不同

public abstract class Voice{
   abstract void printCry();
}
public abstract class Move {
   abstract void printMovemode();
}
public abstract class Food {
   abstract void printEat();
}

dog的实现方式

public class Bark extends Voice{
    public void printCry() {
        System.out.println("wang wang wang....");
    }
}
public class Run extends Move{
    public void printMovemode() {
        System.out.println("run quickly...");
    }
}
public class Meat extends Food{
    public void printEat() {
        System.out.println("dog eat meat...");
    }
}

cat的实现方式

public class MiaoW extends Voice{
    public void printCry() {
        System.out.println("miao miao miao....");
    }
}
public class Walk extends Move{
    public void printMovemode() {
        System.out.println("walk yibu liangbu...");
    }
}
public class Fish extends Food{
    public void printEat() {
        System.out.println("cat eat fish...");
    }
}

2、创建实现了抽象工厂的工厂类

猫与狗都具有叫声、移动、以及食物属性

public class DogFactory extends AbastractFactory {
    @Override
    Voice  getCry() {
        return new Bark();
    }
    @Override
    Move getMovemode() {
        return new Run();
    }
    @Override
    Food  getEat() {
        return new Meat();
    }
}

public class CatFactory extends AbastractFactory {
    @Override
    Voice  getCry() {
        return new MiaoW();
    }
    @Override
    Move getMovemode() {
        return new Walk();
    }
    @Override
    Food  getEat() {
        return new Fish();
    }
}

3、创建抽象工厂类

public abstract class AbastractFactory {
    abstract Voice getCry(); // 叫声
    abstract Move getMovemode(); // 移动方式
    abstract Food getEat(); // 食物
}

测试验证：

public class AbstractFactoryTest {
   public static void main(String[] args) {
    	AbastractFactory f = new DogFactory();
        Voice v = f.getCry();
        v..printCry(); // 打印的为dog的叫声
        Move w = f.getMovemode();
        w.printMovemode();// 打印的为dog的移动方式
        Food b = f.printEat();
        b.printName();// 打印的为dog的食物

        AbastractFactory f = new CatFactory ();
        Voice v = f.getCry();
        v..printCry(); // 打印的为cat的叫声
        Move w = f.getMovemode();
        w.printMovemode();// 打印的为cat的移动方式
        Food b = f.printEat();
        b.printName();// 打印的为cat的食物
   }
}