工厂模式

工厂模式实现了创建者与调用者的分离。

OCP（开闭原则 Open-Closed Principe）：一个软件的实体应当对拓展开放，对修改关闭。（当添加新产品时，应该扩展新的类，而不应该修改已有类）
DIP(依赖倒转原型，Dependence Inversion Principle)：要针对接口编程，不要针对实现编程。 （依赖抽象，而不依赖具体）
LoD（迪米特法则，Law of Demeter）：只与你得朋友通信，而避免和陌生人通信。（尽量减少依赖）

简单工厂

构建一个车的接口，有一个run()方法。

package simpleFactory;
public interface Car {
 void run();
}

不同的车实现该接口：

public class Audi implements Car {
 	@Override
 	public void run() {
  		System.out.println("奥迪跑！");
 	} 
}


public class Byd implements Car{
	 @Override
 	public void run() {
  		System.out.println("比亚迪跑！");
 	}
}

如果不通过工厂进行调用，调用者需要了解每一个车的具体的类，在客户端进行new对象实例。

public class Client1 { 
 	public static void main(String[] args) {
  		Car c1 = new Audi();
  		Car c2 = new Byd();
  		c1.run();
  		c2.run();
 	}
}

构建一个创建车对象的简单工厂，通过传入不同的类型参数进行判断对应要实例化哪一个对象。

public class CarFactory {
 	public static Car createCar(String type) {
  		if("audi".equals(type)) {
   			return new Audi();
  		} else if("byd".equals(type)) {
   			return new Byd();
  		} else return null;
 	}
}

或者，直接在简单工厂类中创建构造不同对象的方法：

public class CarFactory2 {
 	public static Car createAudi() {
  		return new Audi();
 	}		
 	public static Car creatByd() {
  		return new Byd();
 	}
}

这样，在客户端可以直接调用简单工厂类：

public class Client02 {
 	public static void main(String[] args) {
  		Car c1 = CarFactory.createCar("audi");
  		Car c2 = CarFactory.createCar("byd");
  		//Car c1 = CarFactory2.createAudi();
  		//Car c2 = CarFactory2.creatByd();
  		c1.run();
  		c2.run();
 	}
}

简单工厂模式也叫静态工厂模式，工厂类一般使用静态方法，通过接收参数的不同返回不同的对象实例。
但对于新增加产品，必须修改已有类或已有方法，是违反开闭原则的。
简单工厂模式的要点在于：
工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅“消费”产品；客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，就可以获取你所需要的对象，而无须知道其创建细节。

工厂方法模式

先创建一个CarFactory，不在其中直接构建对象实例，而是构建一个接口，接口的方法是用于创建对象实例的：

public interface CarFactory {
 	Car createCar();
}

对于每一种车，都创建一个具体的工厂实现这个工厂接口：

public class AudiFactory implements CarFactory{
 	@Override
 	public Car createCar() {
  		return new Audi();
 	}
}

public class BydFactory implements CarFactory {
 	@Override
 	public Car createCar() {
  		return new Byd();
 	}	
}

那么在客户端调用时，它只需要知道自己调用的车属于哪一个具体的工厂：

public class Client {
 	public static void main(String[] args) {
  		Car c1 = new AudiFactory().createCar();
  		Car c2 = new BydFactory().createCar();
  		c1.run();
  		c2.run();
 	}
}

这种模式符合开闭原则，如果我要增加一种新车，我需要先创建一个具体产品类实现Car接口，再创建一个具体工厂类实现CarFactory接口，而不需要修改已有的业务代码，因为除了两个接口以外，其他的类均与我要创建的新车没有关联。

虽然增加了扩展性，但是以构建了更多的类为代价。一般工程应用中，使用简单工厂比较多。

抽象工厂模式

用来生产不同产品族的全部产品。
比如一个产品族中有发动机，座椅，轮胎。由高端发动机，高端座椅，高端轮胎构成高端汽车。
在生产时，要增加新的产品族，而对增加新的产品无能为力。

首先定义产品族，为产品族中的每一个产品定义一个接口，由具体的产品类实现接口。

发动机：

public interface Engine {
	void run();
	void start();
}

class LuxuryEngine implements Engine {

	@Override
	public void run() {
		System.out.println("转的快!");
	}
	@Override
	public void start() {
		System.out.println("启动快!");
	}
}

class LowEngine implements Engine {

	@Override
	public void run() {
		System.out.println("转的慢!");
	}
	@Override
	public void start() {
		System.out.println("启动慢!");
	}
}

座椅：

public interface Seat {
	void massage();
}

class LuxurySeat implements Seat {
	@Override
	public void massage() {
		System.out.println("能按摩！");
	}
	
}

class LowSeat implements Seat {
	@Override
	public void massage() {
		System.out.println("不能按摩！");
	}
}

轮胎：

public interface Tyre {
	void revolve();
}

class LuxuryTyre implements Tyre {
	@Override
	public void revolve() {
		System.out.println("轮胎磨损小！");
	}	
}

class LowTyre implements Tyre {
	@Override
	public void revolve() {
		System.out.println("轮胎磨损快！");
	}
}

接下来我们创建一个汽车工厂（抽象工厂）定义产品族中三个产品的创建：

public interface CarFactory {
	Engine createEngine();
	Seat createSeat();
	Tyre creatTyre();
}

在具体的汽车工厂中，我们对几种产品进行组合：
低端汽车：

public class LowCarFactory implements CarFactory{
	@Override
	public Engine createEngine() {
		return new LowEngine();
	}
	@Override
	public Seat createSeat() {
		return new LowSeat();
	}
	@Override
	public Tyre creatTyre() {
		return new LowTyre();
	}
}

高端汽车：

public class LuxuryCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}
	@Override
	public Seat createSeat() {
		return new LuxurySeat();
	}
	@Override
	public Tyre creatTyre() {
		return new LuxuryTyre();
	}
}

客户端调用：

public class Client {
	public static void main(String[] args) {
		CarFactory factory = new LuxuryCarFactory();
		Engine e = factory.createEngine();
		e.start();
		e.run();
	}
}

应用场景

JDBC中Connection对象的获取
Hibernate中SessionFactory创建Session
Spring中IOC容器创建管理bean对象
反射中Class对象的newInstance()