简介
结构
图-抽象工厂模式结构图
抽象工厂模式包含以下角色：
- AbstractFactory（抽象工厂）
- ConcreteFactory（具体工厂）
- AbstractProduct（抽象产品）
- ConcreteProduct（具体产品）
AbstractProduct : 声明一个接口，这个接口中包含产品对象类型。
public abstract void show();
}
abstract class AbstractProductB {
public abstract void show();
}
ConcreteProduct : 定义一个产品对象，这个产品对象是由相关的具体工厂创建的。
@Override
public void show() {
System.out.println("ConcreteProductA1");
}
}
class ConcreteProductA2 extends AbstractProductA {
@Override
public void show() {
System.out.println("ConcreteProductA2");
}
}
class ConcreteProductB1 extends AbstractProductB {
@Override
public void show() {
System.out.println("ConcreteProductB1");
}
}
class ConcreteProductB2 extends AbstractProductB {
@Override
public void show() {
System.out.println("ConcreteProductB2");
}
}
AbstractFactory : 声明一个接口，这个接口中包含创建抽象产品对象的方法。
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
ConcreteFactory : 实现创建具体产品对象的方法。
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
class ConcreteFactory2 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB2();
}
}
Client : 只使用 AbstractFactory 和 AbstractProduct 声明的接口。
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
AbstractProductA productA1 = factory1.createProductA();
AbstractProductB productB1 = factory1.createProductB();
productA1.show();
productB1.show();
AbstractFactory factory2 = new ConcreteFactory2();
AbstractProductA productA2 = factory2.createProductA();
AbstractProductB productB2 = factory2.createProductB();
productA2.show();
productB2.show();
}
}
运行结果
ConcreteProductB1
ConcreteProductA2
ConcreteProductB2
动机
一个系统要独立于它的产品的创建、组合和表示时。
一个系统要由多个产品系列中的一个来配置时。
当你要强调一系列相关的产品对象的设计以便进行联合使用时。
当你提供一个产品类库，而只想显示它们的接口而不是实现时。
要点
优点
（1）抽象工厂模式隔离了具体类的生成，用户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。
（2）当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。
（3）增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开放封闭原则”。
缺点
在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。
实例
众所周知，苹果和三星这两家世界级的电子产品厂商都生产手机和电脑。
我们以生产手机和电脑为例，演示一下抽象工厂模式的应用
AbstractProduct 角色
首先，定义手机和电脑两个抽象接口，他们都有各自的产品信息
public String getProductInfo();
}
interface Computer {
public String getProductInfo();
}
ConcreteProduct 角色
在我们的例子中，苹果、三星两家公司的手机和电脑都有各自的具体产品信息。
@Override
public String getProductInfo() {
return "苹果手机，采用ios系统";
}
}
class SamsungTelephone implements Telephone {
@Override
public String getProductInfo() {
return "三星手机，采用android系统";
}
}
class AppleComputer implements Computer {
@Override
public String getProductInfo() {
return "苹果电脑，采用mac系统";
}
}
class SamsungComputer implements Computer {
@Override
public String getProductInfo() {
return "三星电脑，采用windows系统";
}
}
AbstractFactory 角色
苹果，三星这两个厂商都生产手机和电脑。所以它们可以有一个抽象父类或父接口，提供生产手机和生产电脑的方法。
public Telephone produceTelephone();
public Computer produceComputer();
}
ConcreteFactory 角色
苹果、三星工厂分别实现父接口，生产不同类型的产品。
@Override
public Telephone produceTelephone() {
return new AppleTelephone();
}
@Override
public Computer produceComputer() {
return new AppleComputer();
}
}
class SamsungFactory implements ElectronicFactory {
@Override
public Telephone produceTelephone() {
return new SamsungTelephone();
}
@Override
public Computer produceComputer() {
return new SamsungComputer();
}
}
测试代码
public static void main(String[] args) {
ElectronicFactory appleFactory = new AppleFactory();
Telephone phone = appleFactory.produceTelephone();
System.out.println(phone.getProductInfo());
Computer computer = appleFactory.produceComputer();
System.out.println(computer.getProductInfo());
}
}
运行结果
苹果电脑，采用mac系统
