文章目录
- 概念
- 结构
- 实例
- 优化
概念
抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
工厂方法是有一个类型的产品，也就是只有一个产品的抽象类或接口，而抽象工厂相对于工厂方法来说，是有n个类型的产品，也就具有n个产品的抽象类或接口。通俗的来讲，就是由生成一个类型的产品转变为生成一组产品，这是二者的主要区别，两个的相同点是抽象的工厂接口里关联的永远是抽象的产品。
结构
抽象工厂的类图如下：
AbstractFactory(抽象工厂)：它声明了一组用于创建一族产品的方法，每一个方法对应一种产品（抽象的产品）。
ConcreteFactory(具体工厂)：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品。
AbstractProduct(抽象产品)：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
ConcreteProduct(具体产品)：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。
实例
现在有海尔和海信两家公司，都会生产电视和空调，根据这种场景，我们可以拆分一下，把电视和空调作为产品族，海尔和海信两家公司作为两个生产产品的抽象工厂，它们都可以生产电视和空调。
空调的抽象产品：
public interface HVAC {
void displayHVAC();
}
海尔空调：
public class HaierHVAC implements HVAC {
@Override
public void displayHVAC() {
System.out.println("海尔空调");
}
}
海信空调：
public class HisenseHAVC implements HVAC{
@Override
public void displayHVAC() {
System.out.println("海信空调");
}
}
电视的抽象产品：
public interface TV {
void displayTV();
}
海尔电视：
public class HaierTV implements TV{
@Override
public void displayTV() {
System.out.println("海尔电视");
}
}
海信电视：
public class HisenseHAVC implements HVAC{
@Override
public void displayHVAC() {
System.out.println("海信空调");
}
}
抽象的工厂，海信工厂和海尔工厂实现该接口：
public interface AbstractFactory {
TV createTV();
HVAC createHVAC();
}
海尔工厂：
public class HaierFactory implements AbstractFactory{
@Override
public TV createTV() {
return new HaierTV();
}
@Override
public HVAC createHVAC() {
return new HaierHVAC();
}
}
海信工厂：
public class HisenseFactory implements AbstractFactory {
@Override
public TV createTV() {
return new HisenseTV();
}
@Override
public HVAC createHVAC() {
return new HisenseHAVC();
}
}
客户端实现：
public class Client {
public static void main(String[] args) {
//创建海尔的空调和电视
AbstractFactory haierFactory = new HaierFactory();
TV haierTV = haierFactory.createTV();
HVAC haierHVAC = haierFactory.createHVAC();
haierTV.displayTV();
haierHVAC.displayHVAC();
}
}
结果：
优化
抽象工厂比工厂方法多了一个产品族的抽象，也就是可以在工厂里创建多个产品。当新的公司介入时，如长虹公司也来了，那就在实现一个长虹公司的工厂，实现抽象工厂，然后重写里面的方法即可。
但是假如海尔和海信不仅仅生产空调和电视了，还想生产冰箱，那就需要再增加一个产品，这时，海尔和海信工厂都需要增加一个生产冰箱的方法，假如有n个像海尔和海信这样的工厂，那每个工厂都需要重写方法，很难扩展。
于是我苦思冥想，终于想到了一个方案，先说下思路：
1、因为当扩展新的产品时，就要重写工厂的方法，所以这个工厂里，我打算只放一个获取产品的方法，返回类型是一个抽象的产品。
2、要实现完全的开闭原则不太现实，只能减少对原有类的影响，要改的话只改动一个类就好，所以可以把需要变动的地方都放到一个类中，需要变动的点就是扩展新的产品。
3、因为客户面向的是抽象，所以在客户端不能出现具体的产品，只能出现抽象产品，但是可以通过字符串的形式进行传参，这样与每个类都没有耦合。
4、因为海尔和海信的工厂是固定的，可以在里面出现魔法值。
下面是优化的效果：
抽象工厂类，只有一个抽象的方法：
public interface AbstractFactory {
Product create(String type);
}
海尔工厂类，可通过反射获取具体的产品：
public class HaierFactory implements AbstractFactory {
@Override
public Product create(String type) {
Map<String, String> productClassNameByType = ExtendUtil.getProductClassNameByType(type);
String className = productClassNameByType.get("haier");
Object o = null;
try {
o = Class.forName(className).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return (Product) o;
}
}
海信工厂类：
public class HisenseFactory implements AbstractFactory {
@Override
public Product create(String type) {
Map<String, String> productClassNameByType = ExtendUtil.getProductClassNameByType(type);
String className = productClassNameByType.get("hisense");
Object o = null;
try {
o = Class.forName(className).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return (Product) o;
}
}
一个工具类，用来扩展使用，存放产品族和具体产品之间的关系：
public class ExtendUtil {
private static Map<String, Map<String, String>> map = new HashMap<>();
static {
map = new HashMap<String, Map<String, String>>() {{
Map<String, String> tvMap = new HashMap<>();
tvMap.put("haier", "com.tfjybj.ming.design.absfactory.HaierTV");
tvMap.put("hisense", "com.tfjybj.ming.design.absfactory.HisenseTV");
put("tv", tvMap);
Map<String, String> hvacMap = new HashMap<>();
hvacMap.put("haier", "com.tfjybj.ming.design.absfactory.HaierHVAC");
hvacMap.put("hisense", "com.tfjybj.ming.design.absfactory.HisenseHVAC");
put("hvac", hvacMap);
}};
}
public static Map<String,String> getProductClassNameByType(String type){
return map.get(type);
}
}
最抽象的产品：
public interface Product {
void display();
}
海尔电视：
public class HaierTV implements Product {
@Override
public void display() {
System.out.println("海尔电视");
}
}
海尔空调：
public class HaierHVAC implements Product {
@Override
public void display() {
System.out.println("海尔空调");
}
}
海信电视：
public class HisenseTV implements Product {
@Override
public void display() {
System.out.println("海信电视");
}
}
海信空调：
public class HisenseHAVC implements Product{
@Override
public void display() {
System.out.println("海信空调");
}
}
客户端使用：
public class Client {
public static void main(String[] args) {
//创建海尔的空调和电视
AbstractFactory haierFactory = new HaierFactory();
//客户端面向的是抽象
Product tv = haierFactory.create("tv");
Product hvac = haierFactory.create("hvac");
tv.display();
hvac.display();
}
}
如果增加新的产品如冰箱，或者新增工厂如长虹电器，则需要改动的地方只有这里：
欢迎您的观看，有问题一起探讨。
