抽象工厂模式

抽象工厂模式优点

 

1. 因为每个具体工厂类只负责创建产品，没有简单工厂中的逻辑判断，因此符合单一职责原则。
2. 与简单工厂模式不同，抽象工厂并不使用静态工厂方法，可以形成基于继承的等级结构。
3. 新增一个产品族（如上文类图中的MySQLUserDao，MySQLRoleDao，MySQLProductDao）时，只需要增加相应的具体产品和对应的具体工厂类即可。相比于简单工厂模式需要修改判断逻辑而言，抽象工厂模式更符合开-闭原则。

抽象工厂模式缺点

1. 新增产品种类（如上文类图中的UserDao，RoleDao，ProductDao）时，需要修改工厂接口（或者抽象工厂）及所有具体工厂，此时不符合开-闭原则。抽象工厂模式对于新的产品族符合开-闭原则而对于新的产品种类不符合开-闭原则，这一特性也被称为开-闭原则的倾斜性。

抽象工厂模式

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

* @author Administrator

* 优点：

* 1、封装性

* 2、产品族内的约束为非公开状态

* 缺点：

* 抽象工厂模式最大的缺点就是产品族扩展非常困难（抽象工厂改变，工厂实现类也要改变）

* 使用场景：

* 一个对象族（或是一组没有任何关系的对象）都有相同的约束，则可以使用抽象工厂模式

* 抽象工厂提供一系列创建多个抽象产品的接口，而具体的工厂负责实现具体的产品实例。抽象工厂模式与工厂

* 方法模式最大的区别在于抽象工厂中每个工厂可以创建多个种类的产品。工厂方法模式中一种工厂只能创建一种

* 具体产品，而在抽象工厂模式中一种具体工厂可以创建多个种类的具体产品。

 

// 抽象产品类A
abstract class AbstractProductA {
	public void shareMethod() {

	}

	public abstract void doSomething();
}

// 抽象产品类B
abstract class AbstractProductB {
	public void shareMethod() {

	}

	public abstract void doSomething();
}

// 产品A1的实现类
class ProductA1 extends AbstractProductA {
	@Override
	public void doSomething() {
		System.out.println("产品A1 的实现方法");
	}
}

// 产品A2的实现类
class ProductA2 extends AbstractProductA {
	@Override
	public void doSomething() {
		System.out.println("产品A2 的实现方法");
	}
}

// 产品B1的实现类
class ProductB1 extends AbstractProductB {
	@Override
	public void doSomething() {
		System.out.println("产品B1 的实现方法");
	}
}

// 产品B2的实现类
class ProductB2 extends AbstractProductB {
	@Override
	public void doSomething() {
		System.out.println("产品B2 的实现方法");
	}
}

// 抽象工厂类（有N个产品族就应该有N个创建方法）
abstract class AbstractCreator {
	// 创建A产品家族
	public abstract AbstractProductA createProductA();

	// 创建B产品家族
	public abstract AbstractProductB createProductB();
}

// 产品等级1 的实现类
class Creator1 extends AbstractCreator {
	@Override
	public AbstractProductA createProductA() {
		return new ProductA1();
	}

	@Override
	public AbstractProductB createProductB() {
		return new ProductB1();
	}
}

// 产品等级2 的实现类
class Creator2 extends AbstractCreator {
	@Override
	public AbstractProductA createProductA() {
		return new ProductA2();
	}

	@Override
	public AbstractProductB createProductB() {
		return new ProductB2();
	}
}

public class Main {
	public static void main(String[] args) {
		// 定义两个工厂
		AbstractCreator creator1 = new Creator1();
		AbstractCreator creator2 = new Creator2();
		// 产生A1对象
		AbstractProductA a1 = creator1.createPaoductA();
		// 产生A2对象
		AbstractProductA a2 = creator2.createPaoductA();
		// 产生B1对象
		AbstractProductB b1 = creator1.createPaoductB();
		// 产生B2对象
		AbstractProductB b2 = creator2.createPaoductB();
		/*
		 * 业务逻辑。。。
		 */

	}
}