121 项目 029 笔记向 设计模式 抽象工厂模式

抽象工厂模式定义

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

能用类图如下：



抽象工厂模式是工厂方法模式的升级版本,在有多个业务品种,业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式.

通用源码

类图

抽象产品A

package com.laolang.dp.abstractfactory;

/**
* 抽象产品A类
*/
public abstract class AbstractProductA {

// 每个产品共有的方法
public void shareMethod(){}

// 每个产品相同方法,不同实现
public abstract void doSomething();
}

抽象产品B

package com.laolang.dp.abstractfactory;

/**
* 抽象产品B类
*/
public abstract  class AbstractProductB {
// 每个产品共有的方法
public void shareMethod(){}

// 每个产品相同方法,不同实现
public abstract void doSomething();
}

产品AOne

package com.laolang.dp.abstractfactory;

public class ProductAOne extends AbstractProductA {
@Override
public void doSomething() {
System.out.println("产品AOne");
}
}

产品ATwo

package com.laolang.dp.abstractfactory;

/**
* 产品ATwo的实现
*/
public class ProductATwo extends AbstractProductA {
@Override
public void doSomething() {
System.out.println("产品ATwo的实现");
}
}

产品BOne

package com.laolang.dp.abstractfactory;

/**
* 产品BOne
*/
public class ProductBOne extends AbstractProductB {
@Override
public void doSomething() {
System.out.println("产品BOne");
}
}

产品BTwo

package com.laolang.dp.abstractfactory;

/**
* 产品BTwo
*/
public class ProductBTwo extends AbstractProductB {
@Override
public void doSomething() {
System.out.println("产品BTwo");
}
}

抽象工厂

package com.laolang.dp.abstractfactory;

/**
* 抽象工厂类
*/
public abstract class AbstractFactory {

// 创建A产品家族
public abstract AbstractProductA createProductA();

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

One类产品工厂实现

package com.laolang.dp.abstractfactory;

/**
* 只生产产品One类产品
*/
public class ProductOneFactory extends AbstractFactory {
/**
* 只生产AOne类产品
* @return
*/
@Override
public AbstractProductA createProductA() {
return new ProductAOne();

}

/**
* 只生产BOne类产品
* @return
*/
@Override
public AbstractProductB createProductB() {
return new ProductBOne();
}
}

Two类产品工厂实现

package com.laolang.dp.abstractfactory;

/**
* 只生产Two类产品
*/
public class ProductTwoFactory extends AbstractFactory {
/**
* 只生产ATwo类产品
* @return
*/
@Override
public AbstractProductA createProductA() {
return new ProductATwo();
}

/**
* 只生产BTwo类产品
* @return
*/
@Override
public AbstractProductB createProductB() {
return new ProductBTwo();
}
}

使用

package com.laolang.dp.abstractfactory;

import org.junit.Test;

public class AbstractFactoryTest {

@Test
public void testOne(){
// 定义出两个工厂
AbstractFactory factoryOne = new ProductOneFactory();
AbstractFactory factoryTwo = new ProductTwoFactory();

// 生产AOne产品
AbstractProductA aOne = factoryOne.createProductA();

// 生产ATwo产品
AbstractProductA aTwo = factoryTwo.createProductA();

// 生产BOne产品
AbstractProductB bOne = factoryOne.createProductB();

// 生产BTwo产品
AbstractProductB bTwo = factoryTwo.createProductB();
}
}

抽象工厂模式的优缺点

优点

封装性

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

缺点

纵向扩展困难,如再增加一个Three类街产品,则要大规模的修改代码

使用场景

一个对象族都有相同的约束，则可以使用抽象工厂模式

例如开发在三种不同操作系统上运行的程序,可以使用抽象工厂屏蔽操作系统的影响,由不同的产品类去处理与操作系统的交互