创建型设计模式05-抽象工厂模式

// 抽象产品类 A
interface AbstractProductA {
  void operationA();
}
// 抽象产品类 B
interface AbstractProductB {
  void operationB();
}

// 具体产品类 A1
class ProductA1 implements AbstractProductA {
  @Override
  public void operationA() {
    System.out.println("具体产品类 A1 实现抽象产品 A");
  }
}
// 具体产品类 A2
class ProductA2 implements AbstractProductA {
  @Override
  public void operationA() {
    System.out.println("具体产品类 A2 实现抽象产品 A");
  }
}
// 具体产品类 B1
class ProductB1 implements AbstractProductB {
  @Override
  public void operationB() {
    System.out.println("具体产品类 B1 实现抽象产品 B");
  }
}
// 具体产品类 B2
class ProductB2 implements AbstractProductB {
  @Override
  public void operationB() {
    System.out.println("具体产品类 B2 实现抽象产品 B");
  }
}

// 抽象工厂类
interface AbstractFactory {
  AbstractProductA createProductA();
  AbstractProductB createProductB();
}

// 具体工厂类 1
class ConcreteFactory1 implements AbstractFactory {
  @Override
  public AbstractProductA createProductA() {
    return new ProductA1();
  }
  @Override
  public AbstractProductB createProductB() {
    return new ProductB1();
  }
}
// 具体工厂类 2
class ConcreteFactory2 implements AbstractFactory {
  @Override
  public AbstractProductA createProductA() {
    return new ProductA2();
  }
  @Override
  public AbstractProductB createProductB() {
    return new ProductB2();
  }
}

// 客户端
public class Client {
  public static void main(String[] args) {
    // 创建具体工厂类 1
    AbstractFactory factory1 = new ConcreteFactory1();
    // 使用工厂类 1 创建产品 A 和 B
    AbstractProductA productA1 = factory1.createProductA();
    AbstractProductB productB1 = factory1.createProductB();
    // 调用产品 A 和 B 的方法
    productA1.operationA();
    productB1.operationB();
    // 创建具体工厂类 2
    AbstractFactory factory2 = new ConcreteFactory2();
    // 使用工厂类 2 创建产品 A 和 B
    AbstractProductA productA2 = factory2.createProductA();
    AbstractProductB productB2 = factory2.createProductB();
    // 调用产品 A 和 B 的方法
    productA2.operationA();
    productB2.operationB();
  }
}

/**
 * @author Shier
 * 家具类
 */
public class Furniture {
    private String type;
    private String style;
    private double price;
    public Furniture(String type, String style, double price) {
        this.type = type;
        this.style = style;
        this.price = price;
    }
    public void printInfo() {
        System.out.println("Type: " + type);
        System.out.println("Style: " + style);
        System.out.println("Price: " + price);
    }
}

/**
 * @author Shier
 * 现代风格家具制造商
 */
public class ModernFurnitureMaker {
    public Furniture createChair() {
        return new Furniture("椅子", "现代风格", 150.0);
    }
    public Furniture createSofa() {
        return new Furniture("沙发", "现代风格", 500.0);
    }
}

/**
 * @author Shier
 * 传统风格家具制造商
 */
public class TraditionalFurnitureMaker {
    public Furniture createChair() {
        return new Furniture("椅子", "传统风格", 100.0);
    }
    public Furniture createSofa() {
        return new Furniture("沙发", "传统风格", 600.0);
    }
}

/**
 * @author Shier
 * 客户端类
 */
public class Client {
    public static void main(String[] args) {
        // 创建现代风格家具
        ModernFurnitureMaker modernMaker = new ModernFurnitureMaker();
        Furniture modernChair = modernMaker.createChair();
        Furniture modernSofa = modernMaker.createSofa();
        // 打印信息
        modernChair.printInfo();
        modernSofa.printInfo();
        // 创建传统风格家具
        TraditionalFurnitureMaker traditionalMaker = new TraditionalFurnitureMaker();
        Furniture traditionalChair = traditionalMaker.createChair();
        Furniture traditionalSofa = traditionalMaker.createSofa();
        // 打印信息
        traditionalChair.printInfo();
        traditionalSofa.printInfo();
    }
}

/**
 * 抽象产品类-椅子
 */
public interface Chair {
    void printInfo();
}

/**
 * @author Shier
 * 具体产品类-现代椅子
 */
public class ModernChair implements Chair {
    public void printInfo() {
        System.out.println("类型: 椅子, 风格: 现代, 价格: 150.0");
    }
}

/**
 * @author Shier
 * 具体工厂类-现代风格家具
 */
public class ModernFurnitureFactory implements FurnitureMaker {
    public Chair createChair() {
        return new ModernChair();
    }
    public Sofa createSofa() {
        return new ModernSofa();
    }
}

/**
 * @author Shier
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        // 创建现代风格家具工厂
        FurnitureMaker modernFactory = new ModernFurnitureFactory();
        Chair modernChair = modernFactory.createChair();
        Sofa modernSofa = modernFactory.createSofa();
        // 打印信息
        modernChair.printInfo();
        modernSofa.printInfo();
        // 创建传统风格家具工厂
        FurnitureMaker traditionalFactory = new TraditionalFurnitureFactory();
        Chair traditionalChair = traditionalFactory.createChair();
        Sofa traditionalSofa = traditionalFactory.createSofa();
        // 打印信息
        traditionalChair.printInfo();
        traditionalSofa.printInfo();
    }
}