工厂模式

工厂模式
简单工厂，工厂方法，抽象工厂

模式的问题：你如何能轻松方便地构造对象实例，而不必关心构造对象实例的细节和复杂过程呢？
解决方案：建立一个工厂来创建对象

引言

1. 还没有工厂时代：假如还没有工业革命，如果一个客户要一款奔驰车,一般的做法是客户去造一辆奔驰车，然后拿来用。【自给自足】
2. 简单工厂模式：后来出现工业革命。用户不用去创建奔驰车。因为客户有一个工厂来帮他创建宝马.想要什么车，这个工厂就可以建。比如想要奔驰车。工厂就造奔驰的车。即工厂可以创建产品。【小作坊】
3. 工厂方法模式时代：为了满足客户，车系列越来越多，奔驰，宝马，奥迪等系列一个工厂无法创建所有的车型。于是由单独分出来多个具体的工厂。每个具体工厂创建一种车型。即具体工厂类只能创建一个具体产品。但是造车工厂还是个接口。你需要指定某个具体的工厂才能生产车出来。【各种品牌汽车工厂】
4. 抽象工厂模式时代：随着客户的要求越来越高，需要奔驰，宝马，奥迪不需要指定工厂，就是要什么造什么，具体哪个工厂造车，不关心了。【汽车超级工厂】
   这就是工厂模式。

特点

隐藏复杂的逻辑处理过程，只关心执行结果。

分类

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
工厂模式可以分为三类：

1. 简单工厂模式（Simple Factory）
2. 工厂方法模式（Factory Method）
3. 抽象工厂模式（AbstractFactory）

这三种模式从上到下逐步抽象，并且更具一般性。
GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。
将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类

公共接口以及实现类

创建造车接口Car以及实现类Benz，Bmw，Audi：

public interface Car {
	//获取汽车
	String getName();
}

public class Benz implements Car{

	@Override
	public String getName() {
		return "Benz";
	}

}

public class Bmw implements Car{

	@Override
	public String getName() {
		return "Bmw";
	}

}

public class Audi implements Car{

	@Override
	public String getName() {
		return "Audi";
	}
	
}

简单工厂

简单工厂类SimpleFactory 如下：

/**
 *	对于这个工厂来说（太强大了） 
 *	这个工厂什么车都可以生产，有奔驰，宝马，奥迪都可以生产不符合现实
 *	编程也是一种艺术（融会贯通），艺术来源于生活，也是要回归到生活
 */
public class SimpleFactory {
	
	/**
	 * 实现统一管理
	 * 如果没有工厂模式，小作坊，没有执行标准
	 * 如果买到三无产品（没有标准）
	 * 有了工厂模式，卫生监督局工作难度会大大减轻
	 * @param name
	 * @return
	 */
	public Car getCar(String name) {
		if ("Audi".equalsIgnoreCase(name)) {
			return new Audi();
		} else if ("Benz".equalsIgnoreCase(name)) {
			return new Benz();
		} else if ("Bmw".equalsIgnoreCase(name)) {
			return new Bmw();
		} else {
			System.out.println("这种类型的车造不出来...");
		}
		return null;
	}
	
}

简单工厂测试类SimpleFactoryTest 如下：

public class SimpleFactoryTest {
	public static void main(String[] args) {
		Car car = new SimpleFactory().getCar("Audi");
		System.out.println(car.getName());
	}
}

//执行结果
Audi

工厂方法

定义一个工厂接口，以及实现工厂类，如下：

/**
 * 	工厂定义标准 
 */
public interface Factory {
	//符合汽车上路标准
	//尾气排放标准
	//安全带的标准
	Car getCar();
}

public class BenzFactory  implements Factory{

	@Override
	public Car getCar() {
		return new Benz();
	}

}

public class BmwFactory  implements Factory{

	@Override
	public Car getCar() {
		return new Bmw();
	}

}

public class AudiFactory implements Factory{

	@Override
	public Car getCar() {
		return new Audi();
	}

}

工厂方法测试类FactotyTest如下：

public class FactotyTest {
	public static void main(String[] args) {
		/**
		 * 工厂方法模式
		 * 各个产品的生产商，都拥有各自的工厂
		 * 生成工艺，生成的高科技程度都是不一样的
		 */
		Factory factory = new AudiFactory();
		System.out.println(factory.getCar().getName());
		
		factory = new BenzFactory();
		System.out.println(factory.getCar().getName());
	}
}

//执行结果
Audi
Benz

抽象工厂

创建一个工厂抽象类，以及实现工厂类继承工厂抽象类，如下：

public abstract class AbstractFactory {
	
	protected abstract Car getCar();
	
	public Car getCar(String name) {
		if ("Audi".equalsIgnoreCase(name)) {
			return new AudiFactory().getCar();
		} else if ("Benz".equalsIgnoreCase(name)) {
			return new BenzFactory().getCar();
		} else if ("Bmw".equalsIgnoreCase(name)) {
			return new BmwFactory().getCar();
		} else {
			System.out.println("这种类型的车造不出来...");
		}
		return null;
	}
}

public class BenzFactory  extends AbstractFactory{

	@Override
	public Car getCar() {
		return new Benz();
	}

}

public class BmwFactory  extends AbstractFactory{

	@Override
	public Car getCar() {
		return new Bmw();
	}

}

public class AudiFactory extends AbstractFactory{

	@Override
	public Car getCar() {
		return new Audi();
	}

}

创建一个dufault工厂类，这里因为AbstractFactory不能new，如下：

public class DefaultFactory extends AbstractFactory{

	private AudiFactory dufaultFactory = new AudiFactory();
	
	@Override
	protected Car getCar() {
		return dufaultFactory.getCar();
	}

}

抽象工厂测试类AbstractFactoryTest如下：

public class AbstractFactoryTest {
	public static void main(String[] args) {
		DefaultFactory factory = new DefaultFactory();
		System.out.println(factory.getCar("Benz").getName());
	}
}

//执行结果
Benz

简单工厂：一个工厂做所有的事情，可以造奔驰，宝马，奥迪（感觉很混乱，没有一个标准）
工厂方法：定义一个造车工厂接口，奔驰工厂、宝马工厂、奥迪工厂实现造车接口（需要用户去关心使用哪个工厂，使用哪个工厂都需要手动去new）
抽象工厂：实现了解耦