创建型--抽象工厂模式

偏执的太偏执、 2021-09-23 00:56 274阅读 0赞

## 概念 ##

--------------------

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

工厂模式：一个工厂类用来创建多个产品族中的同一种产品。  
抽象工厂模式：多个工厂类用来创建多个产品族。每个产品族中有多个种类的产品。

优点：

1.  当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。  
    缺点：
2.  难以支持在产品族中增加新种类产品。需要在抽象的创建产品对象接口中和它的实现类中修改代码。

## 抽象工厂模式 ##

/* 一个产品族(套装)中包含产品种类:A(上衣),B(裤子)
     * A类产品有A1,A2两个款式
     * B类产品有B1,B2两个款式
      * 套装1包含A1,B1
      * 套装2包含A2,B2
     * */
    // 创建A类产品的公共接口
    interface AbstractProduceA{
    	void Show();
    }
    // 创建一些A类产品:A1,A2
    class ProduceA1 implements AbstractProduceA{
    	@Override
    	public void Show() {
    		System.out.println("ProduceA1 Creation Completion");
    	}
    }
    class ProduceA2 implements AbstractProduceA{
    	@Override
    	public void Show() {
    		System.out.println("ProduceA2 Creation Completion");
    	}
    }
    // 创建B类产品的公共接口
    interface AbstractProduceB{
    	void Show();
    }
    // 创建一些A类产品:B1,B2
    class ProduceB1 implements AbstractProduceB{
    	@Override
    	public void Show() {
    		System.out.println("ProduceB1 Creation Completion");
    	}
    }
    class ProduceB2 implements AbstractProduceB{
    	@Override
    	public void Show() {
    		System.out.println("ProduceB2 Creation Completion");
    	}
    }
    // 创建某个产品族中的各类产品
    interface AbstractFactory {
    	//A,B
    	AbstractProduceA CreateProduceA();
    	AbstractProduceB CreateProduceB();
    }
    // 创建套装1中各类产品的工厂
    class ConcreteFactory1 implements AbstractFactory{
    	@Override
    	public AbstractProduceA CreateProduceA() {
    		return new ProduceA1();
    	}
    	@Override
    	public AbstractProduceB CreateProduceB() {
    		return new ProduceB1();
    	}
    }
    // 创建套装2中各类产品的工厂
    class ConcreteFactory2 implements AbstractFactory{
    	@Override
    	public AbstractProduceA CreateProduceA() {
    		return new ProduceA2();
    	}
    	@Override
    	public AbstractProduceB CreateProduceB() {
    		return new ProduceB2();
    	}
    }
    // 客户端
    public class Client {
    	public static void main(String[] args) {
    		// 创建套装1中的各类产品对象
    		AbstractFactory taozhuang1 = new ConcreteFactory1();
    		AbstractProduceA a1 = taozhuang1.CreateProduceA();
    		AbstractProduceB b1 = taozhuang1.CreateProduceB();
    		a1.Show();
    		b1.Show();
    	}
    }
    
    Output:
    ProduceA1 Creation Completion
    ProduceB1 Creation Completion
    
    /* 如果要增加新种类的产品:帽子C */
    // AbstractFactory 要改，其具体实现类也要改
    /*
    interface AbstractFactory {
    	AbstractProduceA CreateProduceA();
    	AbstractProduceB CreateProduceB();
    	AbstractProduceC CreateProduceC();
    }
    class ConcreteFactory1 implements AbstractFactory{
    	@Override
    	public AbstractProduceA CreateProduceA() {
    		return new ProduceA1();
    	}
    	@Override
    	public AbstractProduceB CreateProduceB() {
    		return new ProduceB1();
    	}
    	@Override
    	public AbstractProduceC CreateProduceC() {
    		return new ProduceC1();
    	}
    }
    class ConcreteFactory2 implements AbstractFactory{
    	@Override
    	public AbstractProduceA CreateProduceA() {
    		return new ProduceA2();
    	}
    	@Override
    	public AbstractProduceB CreateProduceB() {
    		return new ProduceB2();
    	}
    	@Override
    	public AbstractProduceC CreateProduceC() {
    		return new ProduceC2();
    	}
    }
    interface AbstractProduceC{
    	void Show();
    }
    //创建一些C类产品:C1,C2
    class ProduceC1 implements AbstractProduceC{
    	@Override
    	public void Show() {
    		System.out.println("ProduceC1 Creation Completion");
    	}
    }
    class ProduceC2 implements AbstractProduceC{
    	@Override
    	public void Show() {
    		System.out.println("ProduceC2 Creation Completion");
    	}
    }
    */