设计模式-工厂模式

工厂模式在应用中很常见，实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式
工厂模式好处
工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。
利用工厂模式可以降低程序的耦合性，为后期的维护修改提供了很大的便利。
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

工厂模式依旧老一套
分为简单工厂模式，工厂方法模式和抽象工厂
这里只是简单的记录其思想

先说说简单工厂模式
简单工厂模式思想很简单
工厂化思想，生产任务全部交给工厂
示例：

//定义Car接口
public interface Car {
	public  void carType(); 
}

不同的Car通过car接口来实现定义

public class Audi implements Car{

	@Override
	public void carType() {
		// TODO Auto-generated method stub
		System.out.println("this is Audi");
	}
}

public class Benz implements Car{

	@Override
	public void carType() {
		// TODO Auto-generated method stub
		System.out.println("this is Benz");
	}
}

public class Bmw implements Car{

 	@Override
 	public void carType() {
 		// TODO Auto-generated method stub
 		System.out.println("this is Bmw");
 	}
}

简单工厂思想：

public class SimpleFactory {

	public Car getCar(String carName)
	{
		if("Benz".equals(carName))
		{
			return new Benz();
		}
		if("Bmw".equals(carName))
		{
			return new Bmw();
		}
		if("Audi".equals(carName))
		{
			return new Audi();
		}
		else{
			System.out.println("找不到匹配类型...");
			return null;
		}
	}
}

思路很清晰，客户根据需求传参，工厂生产对应的产品。
但在实际运用中存在很大的问题，那就是一个工厂如果什么都生产的话，那么这个工厂管理和维护起来就会特别的麻烦。
试想我们生活中，有一个厂既生产宝马车，又生产奥迪车吗？

这时候我们得转变思路了，让专门的工厂去生产专门的产品。
这时候就想到工厂方法模式了。
思路来了
宝马工厂生产宝马车，奥迪工厂生产奥迪车。
那么代码就可以写了

定义carFactory

public interface CarFactory {

	public Car createCar();
}

不同类型的car通过实现carfactory来完成定义

public class BmwFactory implements CarFactory{

	@Override
	public Car createCar() {
		// TODO Auto-generated method stub
		return new Bmw();
	}
}

public class AudiFactory implements CarFactory{

	@Override
	public Car createCar() {
		// TODO Auto-generated method stub
		return new Audi();
	}
}
   public class BenzFactory implements CarFactory{

	@Override
	public Car createCar() {
		// TODO Auto-generated method stub
		return new Benz();
	}
}

//工厂方法模式测试

public class FactoryMethod {

	public static void main(String[] args) {
		Car car1 = new Car1Factory().createCar();
		car1.carType();
		Car car2 = new Car2Factory().createCar();
		car2.carType();
	}
}

这虽然比较符合工厂生产的实际了，但我们转念想想，如果
工厂方法要求客户对各个工厂都特别了解才能得到相应的产品，对客户的要求太高。
但实际是，客户只关心自己要什么。
那怎么处理这一问题呢？
抽象工厂就来了。
抽象工厂就融合了简单工厂和工厂方法的特点

抽象工厂
抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品。

抽象工厂代码示例：
1 .抽象工厂定义。

public abstract class AbstractFactory {

	protected abstract Car getCar();
	public Car getCar(String carName) {
		if("Benz".equals(carName))
		{
			return new Benz();
		}
		if("Bmw".equals(carName))
		{
			return new Bmw();
		}
		if("Audi".equals(carName))
		{
			return new Audi();
		}
		else{
			System.out.println("找不到匹配类型...");
			return null;
		}
	}
}

我们让之前定义的不同的工厂全部继承自抽象工厂

public class AudiFactory extends AbstractFactory{
	@Override
	public Car getCar() {
		// TODO Auto-generated method stub
		return new Audi();
	}
}

public class BenzFactory extends AbstractFactory{
	@Override
	public Car getCar() {
		// TODO Auto-generated method stub
		return new Benz();
	}
}

public class BwmFactory extends AbstractFactory{
	@Override
	protected Car getCar() {
		// TODO Auto-generated method stub
		return new Bmw();
	}
}

这里我们就可以通过实现抽象工厂来生产出不同的产品
我们借助DefaultFactory

public class DefaultFactory extends AbstractFactory{
	private AudiFactory af=new AudiFactory();
	@Override
	protected Car getCar() {
		// TODO Auto-generated method stub
		return af.getCar();
	}
}

抽象工厂测试

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

说到这里，工厂模式的思想就已经体现的淋漓尽致。不妨来总结一下。
首先，我们说到了简单工厂
简单工厂：
特点就是客户只需要关心自己的需求，就能获取自己想要的产品，而不必了解工厂内部信息。
缺点就是简单工厂把所有的产品都放在一个工厂里面，导致工厂内部存在大量杂乱逻辑
在数据量大的情况下，不易管理和维护。
工厂方法：
工厂方法把各个工厂的实现分开，便于管理和维护，但是客户在选择产品的时候还需要对工厂有一定的了解。对客户要求性高。
抽象工厂：
结合了二者的特点，客户只需要知道自己需要什么就能通过工厂来获取，而且各个工厂的实现分开，便于工厂的管理和维护