设计模式——抽象工厂模式

抽象工厂模式——软件设计模式

女娲造人类图

人类总称

public interface Human  {
    public void getColor();
    public void talk();
    public void getSex();
}

各色人种

public abstract class AbstractBlackHuman implements Human {
    public void getColor(){
      System.out.println("皮肤的颜色是black");
    }
    public void talk(){
      System.out.println("黑人说话");
    }
}
public abstract class AbstractWhiteHuman implements Human {
    public void getColor(){
      System.out.println("皮肤的颜色是white");
    }
    public void talk(){
      System.out.println("白人说话");
    }
}
public abstract class AbstractYellowHuman implements Human {
    public void getColor(){
      System.out.println("皮肤的颜色是yellow");
    }
    public void talk(){
      System.out.println("黄种人说话");
    }
}

黄色女性人种

public class FemaleYellowHuman extends AbstractYellowHuman{
  public void getSex(){
    System.out.println("女性");
  }
}

黄色男性人种

public class MaleYellowHuman extends AbstractYellowHuman{
  public void getSex(){
    System.out.println("男性");
  }
}

人类创建工厂接口

public interface HumanFactory  {
  public Human createYellowHuman();
  public Human createWhiteHuman();
  public Human createBlackHuman();
}

人类创造工厂

public class FemaleHumanFactory extends HumanFactory {
  public Human createYellowHuman(){
    return new FemaleBlackHuman();
  }
  public Human createBlackHuman(){
    return new FemaleYellowHuman();
  }
  public Human createWhiteHuman(){
    return new FemaleWhiteHuman();
  }
}
public class MaleHumanFactory extends HumanFactory {
  public Human createYellowHuman(){
    return new MaleBlackHuman();
  }
  public Human createBlackHuman(){
    return new MaleYellowHuman();
  }
  public Human createWhiteHuman(){
    return new MaleWhiteHuman();
  }
}

场景类

public class NvWa{
  public static void main(String[] args) {
    HumanFactory maleHumanFactory = new MaleHumanFactory();
    HumanFactory femaleHumanFactory = new FemaleHumanFactory();
    maleHumanFactory.createWhiteHuman();
    maleHumanFactory.createYellowHuman();
    maleHumanFactory.createBlackHuman();
    femaleHumanFactory.createWhiteHuman();
    femaleHumanFactory.createYellowHuman();
    femaleHumanFactory.createBlackHuman();
  }
}

抽象工厂方式的定义

Provide an interface for creating families of related or dependent objects without specifying their concrete classes.
为创建一组相关或者相互依赖的对象提供一个接口，而且无需制定它们的具体

抽象工厂模式

• 抽象工厂模式是工厂方法模式的升级版本
• 多个业务品种、业务分类

抽象产品类

public abstract class AbstractProductA{
  //每个产品共有的方法
  public void sharedMethod(){
    //code to do something
  }
  //每个产品相同方法，不同实现
  public abstract void doSomething();
}
public abstract class AbstractProductB{
  //每个产品共有的方法
  public void sharedMethod(){
    //code to do something
  }
  //每个产品相同方法，不同实现
  public abstract void doSomething();
}

产品实现类

public class ProductA1 extends AbstractProductA{
  public void doSomething(){
    System.out.println("产品A1的实现方法");
  }
}
public class ProductA2 extends AbstractProductA{
  public void doSomething(){
    System.out.println("产品A2的实现方法");
  }
}
public class ProductB1 extends AbstractProductA{
  public void doSomething(){
    System.out.println("产品B1的实现方法");
  }
}
public class ProductB2 extends AbstractProductA{
  public void doSomething(){
    System.out.println("产品B2的实现方法");
  }
}

抽象工厂类

public abstract class AbstractCreator{
  public abstract AbstractProductA createProductA();
  public abstract AbstractProductB createProductB();
}

工厂实现类

public class Creator1 extends AbstractCreator{
  public AbstractProductA createProductA(){
    return new ProductA1();
  }
  public AbstractProductA createProductB(){
    return new ProductB1();
  }
}
public class Creator2 extends AbstractCreator{
  public AbstractProductA createProductA(){
    return new ProductA2();
  }
  public AbstractProductA createProductB(){
    return new ProductB2();
  }
}

场景类Client

public class Client{
  public static void main(String[] args) {
    //定义两个工厂
    AbstractCreator creator1 = new Creator1();
    AbstractCreator creator2 = new Creator2();
    AbstractProductA a1 = creator1.createProductA();
    AbstractProductA a2 = creator2.createProductA();
    AbstractProductA b1 = creator1.createProductB();
    AbstractProductA b2 = creator2.createProductB();
    /**
     * 业务逻辑
     */
  }
}

抽象工厂模式的优缺点

抽象工厂模式的优点

• 封装性：高层模块只关心工厂类是谁，不考虑产品类
• 产品族内的约束为非公开状态

抽象工厂模式的缺点

• 产品族扩展非常困难

抽象工厂模式的使用场景

• 涉及到不同操作系统的时候，都可以考虑使用抽象工厂模式