1. 使用设计模式的好处：可提高代码的重复性，让代码更容易被他人理解，保证代码的可靠性。

2. 工厂模式定义：就是创建一个工厂类来创建你需要的类，工厂模式包括工厂模式和抽象工厂模式，抽象工厂模式是工厂模式的扩展。

3. 工厂模式意图：定义一个接口来创建对象，但是让子类来决定哪些类需要被实例化，工厂方法把实例化工作推迟到子类中去实现。

4. 工厂方法适合场景：

 <1>. 有一组类似的对象需要创建

 <2>. 在编码时不能预见需要创建哪种类的实例

 <3>. 系统需要考虑扩展性，不应依赖产品类实例如何被创建、组合和表达的细节

5. 工厂方法类图：

代码实现，举个例子，以一汽大众汽车工厂为例，大家都知道，一汽大众可生产多款汽车，有速腾、高尔夫、CC、宝来等等，我们就是使用工厂来创建不同款式的汽车。

<1>. 创建汽车接口，该接口就有一个生产汽车抽象。

package com.dasauto.car;/** * 一汽大众汽车接口 * @author DuanCZ */public interface ICar {		/**	 * 生产汽车	 */	public void createCar();	}

 

<2>. 创建速腾汽车实现类，该类实现汽车接口

package com.dasauto.car;public class SagitarCar implements ICar {		/**	 * 生产速腾汽车	 */	public void createCar() {				System.out.println("-----------生产一台速腾汽车---------");	}}

<3>，创建高尔夫汽车实现类，该类实现汽车接口

package com.dasauto.car;public class GolfCar implements ICar {	/**	 * 生产高尔夫汽车	 */	public void createCar() {		System.out.println("----------创建一台高尔夫汽车----------");	}}

<4>, 创建汽车工厂类，该类将根据不同款式的汽车类名称来实例化对象

package com.dasauto.car;public class CarFactory {		/**	 * 根据类名称去创建汽车对象	 * @param className	 * @return	 */	public ICar getCar(String className){				try {			ICar car = (ICar) Class.forName(className).newInstance();			return car;		} catch (InstantiationException e) {			// TODO Auto-generated catch block			e.printStackTrace();		} catch (IllegalAccessException e) {			// TODO Auto-generated catch block			e.printStackTrace();		} catch (ClassNotFoundException e) {			// TODO Auto-generated catch block			e.printStackTrace();		}		return null;	}}

 

<5>, 模拟客户端，测试

package com.dasauto.car;public class CarClient {		public static void main(String[] args) {				CarFactory carFactory = new CarFactory();		ICar car = carFactory.getCar("com.dasauto.car.SagitarCar");		car.createCar();	}}

 工厂方法模式很简单，就是单一的一种产品，这不同汽车类名称可以配置到xml中去，如果以后多了一种汽车，那么就是编写好实现类后，配置个XML文件，这样客户端就可以很简单的应用了。

 

6. 抽象工厂方法类图

相比工厂方法模式，抽象工厂就复杂一些了，它有产品族的概念，也就是说不是生产单一产品了，而是生产一系列产品。

代码实现，例如我们做一款程序，程序可能使用多种不同的数据库来完成数据持久化操作。下面是根据模型模拟代码

<1>,

package com.dcz.demo;/** * 抽象产品A * @author DuanCZ */public interface IProductA {		public void method_1();		public void method_2();}

 

<2>,

package com.dcz.demo;/** * 抽象产品B * @author DuanCZ */public interface IProductB {		public void method_1();		public void method_2();}

 

<3>,

package com.dcz.demo;public interface IAbstractFactory {		public IProductA productA();		public IProductB productB();}

 

<4>,

package com.dcz.demo;public class concretenessProductA1 implements IProductA {	@Override	public void method_1() {				System.out.println("生产等级为1的A类Method_1");	}	@Override	public void method_2() {				System.out.println("生产等级为1的A类Method_2");	}}

 

<5>,

package com.dcz.demo;public class concretenessProductA2 implements IProductA {	@Override	public void method_1() {				System.out.println("生产等级为2的A类Method_1");	}	@Override	public void method_2() {				System.out.println("生产等级为2的A类Method_2");	}}

 

<6>,

package com.dcz.demo;public class concretenessProductB1 implements IProductB {	@Override	public void method_1() {		System.out.println("生产等级为1的B类Method_1");	}	@Override	public void method_2() {		System.out.println("生产等级为1的B类Method_2");	}}

 

<7>,

package com.dcz.demo;public class concretenessProductB2 implements IProductB {	@Override	public void method_1() {		System.out.println("生产等级为2的B类Method_1");	}	@Override	public void method_2() {		System.out.println("生产等级为2的B类Method_2");	}}

 

<8>,

package com.dcz.demo;public class ConcreateFactory1 implements IAbstractFactory {	public IProductA productA() {		return new concretenessProductA1();	}	public IProductB productB() {		return new concretenessProductB1();	}}

<9>，

package com.dcz.demo;public class ConcreateFactory2 implements IAbstractFactory {	@Override	public IProductA productA() {		return new concretenessProductA2();	}	@Override	public IProductB productB() {		return new concretenessProductB2();	}}

<10>,

package com.dcz.demo;public class Client {		public static void main(String[] args) {		IAbstractFactory concreateFactory1 =  new ConcreateFactory1();		IProductA productA = concreateFactory1.productA();		productA.method_1();		productA.method_2();	}}

设计原则： 要依赖抽象，不要依赖具体类