1.抽象工厂模式介绍
想象一下现实生活中的工厂肯定都是具体的，也就是说每个工厂都会生产某一种具体的产品，那么抽象工厂意味着生产出来的产品是不具体的，那这岂不是很奇怪？抽象工厂的模式起源于以前对不同操作系统的图形化解决方案，如不确定的操作系统中的按钮和文本其实现不同，展示效果也不一样，对于每一个操作系统，其本身就构成一个产品类，而按钮与文本也构成一个产品类，两种产品两种变化，各有各自的特点，如Android中的Button和TextView、WindowPhone中的Button和TextView等。
2.抽线工厂模式的定义
为创建一组相关或是相互依赖的对象提供一个接口，而不需要指定它们的具体类。
3.抽象工厂模式的使用场景
一个对象有相同约束的时候可以使用抽象工厂模式。举个例子，Android、ios、window Phone下都有短信软件和拨号软件，两者属于软件的范畴，但是他们所在的操作系统平台不一样，即使同一家公司出品的软件，其代码实现逻辑也是不同的，这时候就可以考虑使用抽象工厂方法模式来产生Android、ios、Window Phone下的短信软件和拨号软件。
4.抽象工厂模式的例子
抽象产品A
public abstract class AbstractProductA {
/**
* 每个具体的产品子类需要去实现的方法
*/
public abstract void fun();
}
抽象产品B
public abstract class AbstractProductB {
/**
* 每个具体的产品子类需要去实现的方法
*/
public abstract void fun();
}
具体产品A1
public class ConcreteProductA1 extends AbstractProductA {
@Override
public void fun() {
System.out.print("产品A1的具体实现方法\n");
}
}
具体产品A2
public class ConcreteProductA2 extends AbstractProductA {
@Override
public void fun() {
System.out.print("产品A2的具体实现方法\n");
}
}
具体产品B1
public class ConcreteProductB1 extends AbstractProductB {
@Override
public void fun() {
System.out.print("产品B1的具体实现方法\n");
}
}
具体产品B2
public class ConcreteProductB2 extends AbstractProductB {
@Override
public void fun() {
System.out.print("产品B2的具体实现方法\n");
}
}
抽象工厂类
public abstract class AbstractFactory {
/**
* 创建产品A的方法
* @return 返回产品A对象
*/
public abstract AbstractProductA createProductA();
/**
* 创建产品B的方法
* @return 返回产品B对象
*/
public abstract AbstractProductB createProductB();
}
具体工厂1
public class ConcreteFactory1 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
具体工厂2
public class ConcreteFactory2 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB2();
}
}
Client端测试类
public class Clicent {
public static void main(String[] args) {
AbstractFactory abstractFactory1 = new ConcreteFactory1();
AbstractFactory abstractFactory2 = new ConcreteFactory2();
factory1(abstractFactory1);
factory2(abstractFactory2);
}
private static void factory1(AbstractFactory abstractFactory1) {
AbstractProductA productA = abstractFactory1.createProductA();
AbstractProductB productB = abstractFactory1.createProductB();
productA.fun();
productB.fun();
}
private static void factory2(AbstractFactory abstractFactory2) {
AbstractProductA productA = abstractFactory2.createProductA();
AbstractProductB productB = abstractFactory2.createProductB();
productA.fun();
productB.fun();
}
}
LOg输出信息
产品A1的具体实现方法
产品B1的具体实现方法
产品A2的具体实现方法
产品B2的具体实现方法
抽象工厂的分类
1.AbstractFactory：抽象工厂角色，他声明了一组用于创建一种产品的方法，每个方法对应一种产品，如上图AbstractFactory用于分别创建产品A和产品B。
2.ConcreteFactory：具体工厂角色，它实现了在抽象工厂中定义的创建产品方法，生成一组具体产品，这些产品形成一个产品种类，每一个产品都位于某个产品等级结构中，如上述AbstractProductA和AbstractProductB。
3.AbstractProduct：抽象产品角色，它为每种产品声明接口，如上述AbstractProductA和AbstractProductB。
4.ConcreProduct：具体产品觉色，它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法，如上述人ConcreteProductA1,ConcreteProductA2,ConcreteProductB1,ConcreteProductB2。
上面我们可以看出抽象工厂方法模式的一个弊端，就是类的徒增，如果工厂类过多，势必导致文件非常多，因此在实际开发中要权衡慎用。
抽象工厂方法模式的优点
一个显著的优点是分离即接口与实现，客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已，使其从具体的产品实现中实现解耦，同事基于接口与实现的分离，是抽象该工厂方法模式在切换产品类时更加灵活、容易。
