抽象工厂模式

1.定义

为创建一组相关或相互依赖的对象提供一个接口，而无需指定他们的具体实现类

2.通用代码

//抽象产品类

public abstract class AbstractProductA{

//每个产品共有的方法

public void shareMethod(){

}

//每个产品相同的方法，不同实现

public abstract void doSomething();

}

public abstract class AbstractProductB{

//每个产品共有的方法

public void shareMethod(){

}

//每个产品相同的方法，不同实现

public abstract void doSomething();

}

//产品A1的实现类

public class ProductA2 extends AbstractProductA{

public void doSomething(){

System.out.println("产品A1的实现方法");

}

}

//产品A2的实现类

public class ProductA2 extends AbstractProductB{

public void doSomething(){

System.out.print("产品A2的实现方法");

}

}

//产品B1的实现类

public class ProductB2 extends AbstractProductB{

public void doSomething(){

System.out.println("产品B1的实现方法");

}

}

//产品B2的实现类

public class ProductB2 extends AbstractProductB{

public void doSomething(){

System.out.print("产品B2的实现方法");

}

}

//抽象工厂类

public abstract class AbstractCreator{

//创建A产品家族

public abstract AbstractProductA createProductA();

//创建B产品的家族

public abstract AbstractProductB createProductB();

}

//产品等级1的实现类

public class Creator1 extends AbstractCreator{

public abstrctProductA createProductA(){

return new ProductA1();

}

public abstractProductB createProductB(){

return new ProductB1();

}

}

//产品等级2的实现类

public class Creator2 extends AbstractCreator{

public abstrctProductA createProductA(){

return new ProductA2();

}

public abstractProductB createProductB(){

return new ProductB2();

}

}

//场景类

public class Client{

public static void main(String[] args){

//定义两个工厂

AbstractCreator creator1 = new Creator1();

AbstractCreator creator2=new Creator2();

//产生A1,A2,B1,B2这几个对象

AbstractProductA a1=creator1.creatorProductA();

AbstractProductA a2=creator2.creatorProductA();

AbstractProductB b1=creator1.creatorProductB();

AbstractProductB b1=creator2.creatorProductB();

}

}

3.优点

封装性，每个产品的实现类不是高层模块要关系的，他要关系的是什么？是接口，是抽象，它不关心对象是如何创建出来，只需要指定工厂类是谁，我们就能够创建一个需要的对象

产品族的约束为非公开状态，例

4.缺点

产品族扩展很困难

5.使用场景

一个对象族都有相同的约束则可以使用抽象工厂模式，产品族不扩展，但是产品等级需要扩展

6.类图