abstract factory -对象创建型模式

最新推荐文章于 2025-03-17 17:59:20 发布

原创最新推荐文章于 2025-03-17 17:59:20 发布 · 131 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

23 篇文章

订阅专栏

本文深入解析抽象工厂模式，一种创建型设计模式，用于创建一系列相互依赖的对象，无需指定具体类。探讨了其在多产品族场景下的应用，通过具体工厂实现单例模式，确保系统仅消费同一族的产品。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.意图
提供一个创建一系列的相关或相互依赖的对象接口，而无需指定具体类
2.参与对象
AbstractFactory;ConcreteFactory;AbstractProduct;ConcreteProduct;Client
3.使用
系统的产品有多于一个的产品族，而系统只消费其中某一族的产品
4.相关技术
具体工厂使用单件

5.结构

6.java代码

public interface AbstractFactory {
   public AbstractProductA createProductA(String productFlag);
   public AbstractProductB createProductB(String productFlag);
}

public interface AbstractProductA {
  void playA();
}

public interface AbstractProductB {
	void playB();
}

public class ConcreteFactoryA implements AbstractFactory {
	private final static ConcreteFactoryA concreteFactoryA = new ConcreteFactoryA();
    
	public static ConcreteFactoryA getConcreteFactory() {
		return concreteFactoryA;
	}

	private ConcreteFactoryA() {

	}
	@Override
	public AbstractProductA createProductA(String productFlag) {
		if(productFlag == null || "".equalsIgnoreCase(productFlag) ){
			throw new RuntimeException("缺少产品标识无法创建！");
		}
		if("productA1".equalsIgnoreCase(productFlag)){
			return new productA1();
		}
        if("productA2".equalsIgnoreCase(productFlag)){
			return new productA2();
		}
        throw new RuntimeException("不存在该产品族标识无法创建！");
	}

	@Override
	public AbstractProductB createProductB(String productFlag) {
		// TODO Auto-generated method stub
		return null;
	}

}

public class ConcreteFactoryB implements AbstractFactory {
	private final static ConcreteFactoryB concreteFactoryB = new ConcreteFactoryB();

	public static ConcreteFactoryB getConcreteFactory() {
		return concreteFactoryB;
	}

	private ConcreteFactoryB() {

	}

	@Override
	public AbstractProductA createProductA(String productFlag) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public AbstractProductB createProductB(String productFlag) {
		if(productFlag == null || "".equalsIgnoreCase(productFlag) ){
			throw new RuntimeException("缺少产品标识无法创建！");
		}
		if("productB1".equalsIgnoreCase(productFlag)){
			return new productB1();
		}
        if("productB2".equalsIgnoreCase(productFlag)){
			return new productB2();
		}
        throw new RuntimeException("不存在该产品族标识无法创建！");
	}

}

public class productA1 implements AbstractProductA {

	@Override
	public void playA() {
		System.out.println("A1产品创建成功");
	}

}

public class productA2 implements AbstractProductA {

	@Override
	public void playA() {
		System.out.println("A2产品创建成功");
	}

}

public class productB1 implements AbstractProductB {

	@Override
	public void playB() {
		System.out.println("B1产品创建成功");
	}

}

public class productB2 implements AbstractProductB {

	@Override
	public void playB() {
		System.out.println("B2产品创建成功");
	}

}

public class FactoryProducer {
	final static Map factoryMap = new HashMap();
	static {
		try {
			factoryMap.put("productA", Class.forName("designPattern.builderModel.abstractFactory.ConcreteFactoryA"));
			factoryMap.put("productB", Class.forName("designPattern.builderModel.abstractFactory.ConcreteFactoryB"));
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	private FactoryProducer() {
		throw new RuntimeException();
	}

	public static AbstractFactory getFactory(String productFamily) {
		if (productFamily == null || "".equalsIgnoreCase(productFamily)) {
			throw new RuntimeException("缺少产品族标识无法创建相关工厂！");
		}
		Object o = factoryMap.get(productFamily);
		if (o != null) {
			Class factoryClass = (Class) o;
			try {
				Method method = factoryClass.getMethod("getConcreteFactory", null);
				return (AbstractFactory) method.invoke(null, null);
			} catch (Exception e) {
				System.out.println("不存在该类"+e.getMessage());
			}
		}
		
		throw new RuntimeException("不存在该产品族标识无法创建相关工厂！");
	}
}


public class Client {
	public static void main(String[] args) {
          AbstractFactory abstractFactory = FactoryProducer.getFactory("productB");
          AbstractProductB abstractProductB = abstractFactory.createProductB("productB2");
          abstractProductB.playB();
          
	}
}