Java Factory概念学习第三课（抽象factory）

系列物品生产

接上一篇交通工具的实例化的内容，现在考虑另一种情况，即Test不仅仅需要交通工具，还需要武器、食物等等。

那么先写另外两个类：

public class M416 {

  public void shoot() {
    System.out.println("开枪哒哒哒");
  }
}

public class Cookie {

  public void chew() {
    System.out.println("吧唧吧唧嚼一嚼");
  }
}

还有之前的Car类：

public class Car{
  
  public void run() {
    System.out.println("奔跑中。。。。");
  }
  
}

此时使用工厂：

public class DefaultFactory {
  Car createCar() {
    return new Car();
  }
  AK47 createAK47() {
    return new AK47();
  }
  Cookie createCookie() {
    return new Cookie();
  }
}

Test类来获取三样物品：

public class Test {

  public static void main(String[] args) {

    DefaultFactory df = new DefaultFactory();
    AK47 ak47 = df.createAK47();
    Car car = df.createCar();
    Cookie cookie = df.createCookie();
  }

}

现在考虑替换，假如Test想要实例化其他的物品，而不是汽车、M416、饼干，而是另外的一种，比如魔法世界的扫把、魔杖、果实，那么需要重新做一个工厂，并包含三个生产这些东西的方法。

public class MagicFactory {

  public Broom createBroom() {
    return new Broom();
  }
  public MagicStick createMagicStick() {
    return new MagicStick();
  }
  public MagicFruit createMagicFruit() {
    return new MagicFruit();
  }
}

三个实体类：

public class Broom {

  public void run() {
    System.out.println("扫把飞起来");
  }
}

public class MagicStick {

  public void shoot() {
    System.out.println("魔杖咻咻咻");
  }
}

public class MagicFruit {

  public void chew() {
    System.out.println("啊呜啊呜吃果子");
  }
}

但这时，Test里面的东西几乎全要换掉了：

public class Test {

  public static void main(String[] args) {

    //DefaultFactory df = new DefaultFactory();
    MagicFactory mf = new MagicFactory();
    //下面的全部内容都要换
    Car car = df.createCar();
    AK47 ak47 = df.createAK47();
    Cookie cookie = df.createCookie();
  }
}

全部换掉的话未免太麻烦，这时抽象工厂闪亮登场，我们不妨把这些Factory也抽象起来，编写一个父类：

public abstract class AbstractFactory {

  /**这里的三个方法分别生产需要的物品，
  *  但是由于不确定是哪种工厂，
  *  于是把生产的产品也抽象化为交通工具(Car,Broom)+武器(M416,MagicStick)+食物(Cookie,Fruit)
  *  对应的三个抽象类也会列出
  **/
  public abstract Vehicle createVehicle();
  public abstract Weapon createWeapon();
  public abstract Food createFood();
  
}

三个抽象类：

public abstract class Vehicle {

  public abstract void run();
}

public abstract class Weapon {

  public abstract void shoot();
}

public abstract class Food {

  public abstract void chew();
}

让工厂类分别继承自AbstractFactory类；

让Car和Broom类分别继承Vehicle类；

让M416和MagicStick类分别继承Weapon类；

让Cookie和Fruit类分别继承Food类；

此时的DefaultFactory：

public class DefaultFactory extends AbstractFactory{
  
  @Override
  public Vehicle createVehicle() {
    return new Car();
  }
  
  @Override
  public Weapon createWeapon() {
    return new M416();
  }
  
  @Override
  public Food createFood() {
    return new Cookie();
  }
}

此时的MagicFactory：

public class MagicFactory extends AbstractFactory{

  @Override
  public Vehicle createVehicle() {
    return new Broom();
  }
  
  @Override
  public Weapon createWeapon() {
    // TODO Auto-generated method stub
    return new MagicStick();
  }
  
  @Override
  public Food createFood() {
    // TODO Auto-generated method stub
    return new MagicFruit();
  }
}

这时再看Test类：

public class Test {

  public static void main(String[] args) {

    AbstractFactory af = new DefaultFactory();
    Vehicle vehicle = af.createVehicle();
    Weapon weapon = af.createWeapon();
    Food food = af.createFood();
  }

}

此刻要是想要替换为另外一批产品，即魔法工厂的产品

只需要把：AbstractFactory af = new DefaultFactory();

更换为：AbstractFactory af = new MagicFactory();

以上就是抽象工厂的概念。

上一篇：一般factory
下一篇：BeanFactory