2.工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)(设计模式笔记)

分类:
1：创建型模式：
单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式；
2：结构型模式：
适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式
3：行为型模式：
模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，
解释器模式，状态模式，策略模式，职责链模式，访问者模式。

应用场景:
jdk中Calendar的getInstance方法
jdbc中Connection对象的获取
hibernate中Sessionfactory创建session
spring中ioc容器创建管理bean对象
xml解析时的DocumentBuilderFactory创建解析器对象
反射中class对象的newInstance()

面向对象的基本原则
ocp(开闭原则，open-closed principle):一个软件的实体应该对扩展开放，对修改关闭
dip(依赖倒转原则, dependence inversion principle):要针对接口编程，不要针对实现编程
lod(迪米特法则，law of derneter):只与你直接的朋友通信，而避免和陌生人通信
isp(接口隔离原则):接口口隔离原则认为："使用多个专门的接口比使用单一的总接口要好"。
因为接口如果能够保持粒度够小，就能保证它足够稳定，正如单一职责原则所标榜的那样
srp(单一职责原则，Single Responsibility Principle SRP):所谓单一职责原则就是一个类只负责一个职责,只有一个引起变化的原因.
如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化会削弱或抑制这个类完成其他职责的能力，
这个耦合会导致脆弱的设计。
lsp(里氏替换原则,Liskov Substitution Principle）:任何基类可以出现的地方，
子类一定可以出现。LSP是继承复用的基石，只有当子类可以替换基类，软件单位的功能不受影响时，
基类才能真正的被复用，而子类也可以在基类的基础上增加新的行为。

(1)简单工厂模式:

public class Audi implements Car {

	@Override
	public void run() {
		System.out.println("奥迪跑的快");
	}

}

public class BaoMa implements Car {

	@Override
	public void run() {
		System.out.println("宝马跑的更快");
	}

}

public interface Car {

	public void run();
}

public class CarFactory {
	
	public static Car createCar(String type) {
		//添加车的时候是否会更改代码违背开闭原则
		if("奥迪".equals(type)) {
			return new Audi();
		} else if("宝马".equals(type)) {
			return new BaoMa();
		} else {
			return null;
		}
	}
}

public class Test {

	@org.junit.Test
	public void test1() {
		Car audi = new Audi();
		Car baoma = new BaoMa();
		
		audi.run();
		baoma.run();
	}
	
	@org.junit.Test
	public void test2() {
		//调用者和创建者已分离
		Car audi = CarFactory.createCar("奥迪");
		audi.run();
	}
}

可以利用泛型和反射方式构建简单工厂(从而在产生新对象的时候，满足开闭原则)

@SuppressWarnings("unchecked")
public class CarFactory2 {
	//利用泛型和反射的方式构造简单工厂，满足开闭原则
	public static <T> T createCar(String className)  {
		try {
			return (T) Class.forName(className).newInstance();
		} catch (InstantiationException | IllegalAccessException
				| ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	@Test
	public void test() {
		Car audi = CarFactory2.createCar("com.designpattern.simplefactory.Audi");
		Car baoma = CarFactory2.createCar("com.designpattern.simplefactory.BaoMa");
		audi.run();
		baoma.run();
	}
}

(2)工厂方法模式(符合开闭原则，但是创建类和接口较多)

public interface Car {

	public void run();
}

public class Audi implements Car {

	@Override
	public void run() {
		System.out.println("奥迪跑的快");
	}

}

public class BaoMa implements Car {

	@Override
	public void run() {
		System.out.println("宝马跑的更快");
	}

}

public interface CarFactory {
	public Car createCar();
}

public class AudiFactory implements CarFactory {

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

}

public class BaoMaFactory implements CarFactory {

	//扩展的时候创建新的具体工厂，符合开闭原则
	@Override
	public Car createCar() {
		return new BaoMa();
	}

}

(3)抽象工厂模式

用来生产不同产品族的全部产品(对于增加新的产品，无能为力;支持增加产品族)
抽象共产模式是工厂方法模式的升级版本，在有多高业务品种，业务分类时，通过
抽象工厂模式产生需哟啊的对象是一种非常友好的解决方式。
产品族举例(发动机，座椅，轮胎)，三者构成一个产品族

public interface Seat {
	void releax();
}

class LuxurySeat implements Seat {

	@Override
	public void releax() {
		System.out.println("休息时很舒适");
	}
	
}

class LowSeat implements Seat {

	@Override
	public void releax() {
		System.out.println("休息时感觉一般");
	}
	
}

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 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 createTyre();

}

//低级car生产工厂
public class LowCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LowEngine();
	}

	@Override
	public Seat createSeat() {
		return new LowSeat();
	}

	@Override
	public Tyre createTyre() {
		return new LowTyre();
	}

}

//高级car生产工厂
public class LuxuryCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}

	@Override
	public Seat createSeat() {
		return new LuxurySeat();
	}

	@Override
	public Tyre createTyre() {
		return new LuxuryTyre();
	}

public class Test {
	
	@org.junit.Test
	public void test() {
		CarFactory factory = new LuxuryCarFactory();
		Engine e = factory.createEngine();
		e.run();
		e.start();
	}