设计模式之抽象工厂模式感悟

工厂模式生产的是基于一种产品的抽象，抽象工厂模式是生产的多种具有共性的产品的抽象；

他的定义是：

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

AbstractFactory 抽象工厂角色 声明 一组  用于创建一种产品的方法，每一个方法对应一种产品

ConcreteFactory 具体工厂角色， 它实现了在抽象工厂中定义的创建产品的方法，生成一组具体的产品，这些产品构成一个产品的种类，每一个产品都位于某个产品等级结构中。

AbstractProduct  抽象产品角色，它为每种产品声明接口。

ConcreteProduct 具体产品角色，它定义具体工厂生产的具体产品对象。

抽象工厂在《Android源码设计模式解析与实战》中，我发现抽象工厂模式的抽象工厂类下面Q3工厂类和Q7工厂类的抽象，我认为可以理解为 抽象工厂就是意义上的车，Q3，Q7，就是具体的细节，抽象程度是二级，如果要扩展的话我感觉可以继续往上抽象，比如说 一种车型继承最基础的车，然后加进去一些自己独特的方法，然后再生成工厂，弊端确实存在，每加一个工厂，就会加一个具体的实现。

例如

我们新建一个目录，其中AbstarctFactory是抽象工厂 ，AbstractProduct是抽象产品类,  SpecifiFactory是具体工厂,SoecificProduct是具体产品

</pre><pre name="code" class="java">public abstract class AbstarctFactory {
	/**
	 * 创建产品A的方法
	 * */
	public abstract AbstractProductA createProdcutA();
	
	/**
	 * 创建产品B的方法
	 * */
	public abstract AbstractProductB createProductB();

}

public abstract class AbstractProductA {
<span style="white-space:pre">	</span>/**
<span style="white-space:pre">	</span> * 具体产品A的方法
<span style="white-space:pre">	</span> * */
<span style="white-space:pre">	</span>public abstract void method();
<span style="white-space:pre">	</span>
}

public abstract class AbstractProductB {
<span style="white-space:pre">	</span>/**
<span style="white-space:pre">	</span> * 产品B的具体方法
<span style="white-space:pre">	</span> * */
<span style="white-space:pre">	</span>public abstract void method();


}

public class SpecificFactoryA extends AbstarctFactory{


<span style="white-space:pre">	</span>@Override
<span style="white-space:pre">	</span>public AbstractProductA createProdcutA() {
<span style="white-space:pre">		</span>// TODO Auto-generated method stub
<span style="white-space:pre">		</span>return new SpecificProductA();
<span style="white-space:pre">	</span>}


<span style="white-space:pre">	</span>@Override
<span style="white-space:pre">	</span>public AbstractProductB createProductB() {
<span style="white-space:pre">		</span>// TODO Auto-generated method stub
<span style="white-space:pre">		</span>return new SpecificProductB();
<span style="white-space:pre">	</span>}


}<pre name="code" class="java">

B和A一样，知识名字变了变，不过这在实际中就代表着不同的产品，里面的方法代表着相同的属性，不同的实现，A有A的实现，B有B的实现，咱们这里以产品A举个例子

public class SpecificProductA extends AbstractProductA{

	@Override
	public void method() {
		// TODO Auto-generated method stub
		System.out.println("这是产品A");
	}

}

</pre>这里是一个具体的产品A的实现，咱们看主方法<pre name="code" class="java">public class My {
	
	public static void main(String[] args) {
		SpecificFactoryA aa=new SpecificFactoryA();
		SpecificProductA a0=(SpecificProductA) aa.createProdcutA();
		SpecificProductB b0=(SpecificProductB) aa.createProductB();
		a0.method();
		b0.method();
	}

}

</pre>对于上书中的这段代码，我觉得可以这样理解，A,B是一种产品类型，A1，B1是一种产品类型，两个工厂就是生产这两种不同的产品。</p><p></p><p>在书中所给的例子中是这样呈现的：</p><p>     Q3 Q5 Q7是一个车系，但三者之间的零件差距大，这几种是一系列的车<span style="white-space:pre">	</span>，但各个系统使用的零件不同，  比如 Q3.Q7对应的是一系列车，而发动机、轮胎、制动系统对应的是一系列零部件，两者是两种不同的产品类型，汽车工厂需要生产轮胎，发动机，制动系统三种部件</p><p><span style="white-space:pre">	</span><pre name="code" class="java">public abstract class CarFactroy {
	
	/**
	 * 生产轮胎
	 * */
	public abstract ITire createTire();
	
	/**
	 * 生产发动机
	 * */
	public abstract IEngine createEngine();
	
	/**
	 * 生产制动系统
	 * */
	public abstract IBrake createBrake();


}

咱们以轮胎为例子，轮胎是以接口定义的：

public interface IBrake {
	void tire();
}

这样要实现制造一个Q3的话需要继承CarFactory然后以轮胎 引擎，制动的实现类做对象，进行返回。

这样做的话虽然说是抽象工厂的事件，只不过造出来的是零件，如果再往上抽象一层，结合之前的工厂模式，那么会不会更好一点呢？