抽象工厂模式
定义个抽象父类，抽象父类中定义一个抽象的创建对象的方法，然后由子类来创建一系列相关的产品或者依赖簇，不同于工厂方法适用于单个产品。
案例
代码
定义多个产品以及多个实现类
/**
* 抽象产品：ProductA
*
*/
public interface ProductA {
void use();
}
/**
* 具体产品 ProductA1
*
* @author: Hui
**/
public class ProductA1 implements ProductA{
@Override
public void use() {
System.out.println("ProductA1 use ~~~ ");
}
}
/**
* 具体产品 ProductA2
*
* @author: Hui
**/
public class ProductA2 implements ProductA{
@Override
public void use() {
System.out.println("ProductA2 use ~~ ");
}
}
/**
* 抽象产品：ProductB
*
*/
public interface ProductB {
void use();
}
/**
* 具体产品 ProductB1
*
* @author: Hui
**/
public class ProductB1 implements ProductB{
@Override
public void use() {
System.out.println("ProductB1 use ~~~ ");
}
}
/**
* 具体产品 ProductB2
*
* @author: Hui
**/
public class ProductB2 implements ProductB{
@Override
public void use() {
System.out.println("ProductB2 use ~~~ ");
}
}
定义抽象工厂以及多个的子类工厂
/**
* 抽象工厂
*
* @author: Hui
**/
public abstract class AbsFactory {
public abstract ProductA createProductA();
public abstract ProductB createProductB();
}
/**
* 具体工厂 1
*
* @author: Hui
**/
public class ConcreteFactory1 extends AbsFactory{
@Override
public ProductA createProductA() {
return new ProductA1();
}
@Override
public ProductB createProductB() {
return new ProductB1();
}
}
/**
* 具体工厂 2
*
* @author: Hui
**/
public class ConcreteFactory2 extends AbsFactory{
@Override
public ProductA createProductA() {
return new ProductA2();
}
@Override
public ProductB createProductB() {
return new ProductB2();
}
}
客户端使用
/**
* 客户端
*
* @author: Hui
**/
public class Client {
public static void main(String[] args) {
AbsFactory factory = new ConcreteFactory1();
System.out.println("产品1 ~~~ ");
factory.createProductA().use();
factory.createProductB().use();
factory = new ConcreteFactory2();
System.out.println("产品2 ~~~ ");
factory.createProductA().use();
factory.createProductB().use();
}
}
输出结果
