抽象工厂模式（Abstract Factory）

抽象工厂模式（Abstract Factory）

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

产品

• 父类

package com.ghg.data_structure.mode.abstractfactory;

/**
 * 门口A
 * @author Administrator
 *
 */
public interface IProductA {
    public void doWork(); 
}
package com.ghg.data_structure.mode.abstractfactory;

/**
 * 产品B
 * @author Administrator
 *
 */
public interface IProductB {
    public void doWork(); 
}

• A产品实现

package com.ghg.data_structure.mode.abstractfactory;

/**
 * 产品子类A1
 * @author Administrator
 *
 */
public class ProductA1 implements IProductA {

    public ProductA1() {
        super();
        System.out.println("ProductA1  ");
    }

    public void doWork() {
        System.out.println("ProductA1   doWork");
        
    }

}
package com.ghg.data_structure.mode.abstractfactory;

/**
 * 产品子类A1
 * @author Administrator
 *
 */
public class ProductA2 implements IProductA {

    public ProductA2() {
        super();
        System.out.println("ProductA2  ");
    }

    public void doWork() {
        System.out.println("ProductA2   doWork");
        
    }

}

• B产品实现

package com.ghg.data_structure.mode.abstractfactory;

/**
 * 产品2
 * @author Administrator
 *
 */
public class ProductB1 implements IProductB {

    public ProductB1() {
        super();
    System.out.println(" ProductB1 ");
    }

    public void doWork() {
        System.out.println("ProductB1   doWork");
        
    }

    
}

package com.ghg.data_structure.mode.abstractfactory;

/**
 * 产品2
 * 
 * @author Administrator
 *
 */
public class ProductB2 implements IProductB {

    public ProductB2() {
        super();
        System.out.println("  ProductB2 ");
    }

    public void doWork() {

        System.out.println("ProductB2   doWork");

    }

}

工厂

• 接口

package com.ghg.data_structure.mode.abstractfactory.factory;

import com.ghg.data_structure.mode.abstractfactory.IProductA;
import com.ghg.data_structure.mode.abstractfactory.IProductB;
/**
 * 工厂一
 * @author Administrator
 *
 */
public interface Factory1 {
    /**
     * 生产产品1
     * @return
     */
    public IProductA getProductA1(); 
    /**
     * 生产产品2
     * @return
     */
    public  IProductB getProductB1(); 
}

package com.ghg.data_structure.mode.abstractfactory.factory;

import com.ghg.data_structure.mode.abstractfactory.IProductA;
import com.ghg.data_structure.mode.abstractfactory.IProductB;
/**
 * 工厂一
 * @author Administrator
 *
 */
public interface Factory2 {
    /**
     * 生产产品1
     * @return
     */
    public IProductA getProductA2(); 
    /**
     * 生产产品2
     * @return
     */
    public  IProductB getProductB2(); 
}

• A接口工厂实现

package com.ghg.data_structure.mode.abstractfactory.factory;

import com.ghg.data_structure.mode.abstractfactory.IProductA;
import com.ghg.data_structure.mode.abstractfactory.IProductB;
import com.ghg.data_structure.mode.abstractfactory.ProductA1;
import com.ghg.data_structure.mode.abstractfactory.ProductB1;

public class ConcreteFactory1 implements Factory1 {

    public IProductA getProductA1() {
        /**
         * 产品a1
         */
        return new ProductA1();
    }

    public IProductB getProductB1() {
        /**
         * 产品B1
         */
        return new ProductB1();
    }

}

• B接口工厂实现

package com.ghg.data_structure.mode.abstractfactory.factory;

import com.ghg.data_structure.mode.abstractfactory.IProductA;
import com.ghg.data_structure.mode.abstractfactory.IProductB;
import com.ghg.data_structure.mode.abstractfactory.ProductA2;
import com.ghg.data_structure.mode.abstractfactory.ProductB2;

public class ConcreteFactory2 implements Factory2 {

    public IProductA getProductA2() {
        /**
         * 产品a2
         */
        return new ProductA2();
    }

    public IProductB getProductB2() {
        /**
         * 产品B2
         */
        return new ProductB2();
    }

}

测试

package com.ghg.data_structure.mode.abstractfactory;

import com.ghg.data_structure.mode.abstractfactory.factory.ConcreteFactory1;
import com.ghg.data_structure.mode.abstractfactory.factory.ConcreteFactory2;
import com.ghg.data_structure.mode.abstractfactory.factory.Factory1;
import com.ghg.data_structure.mode.abstractfactory.factory.Factory2;

public class Test1 {

    public static void main(String[] args) {
    
        Factory1 factory1 = new ConcreteFactory1();

        
        
        IProductA productA1 = factory1.getProductA1();
        IProductB productB1 = factory1.getProductB1();
        productA1.doWork();
        productB1.doWork();
        
        Factory2 factory2 = new ConcreteFactory2();
        IProductA productA2 = factory2.getProductA2();
        IProductB productB2 = factory2.getProductB2();
        productA2.doWork();
        productB2.doWork();
    }

}

结果

ProductA1  
 ProductB1 
ProductA1   doWork
ProductB1   doWork
ProductA2  
  ProductB2 
ProductA2   doWork
ProductB2   doWork