抽象工厂模式（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
