工厂模式

工厂模式

-实现了创建者和调用者的分离
-详细分类：
简单工厂模式(又称静态工厂模式)：用来生产统一等级结构中的任意产品(对于增加新的产品，需要修改已有代码)
工厂方法模式：用来生产同一等级结构中的固定产品(支持增加任意产品)
抽象工厂模式：用来生产不同产品族的全部产品(对于增加新的产品，无能为力；支持增加产品族)

工厂模式核心本质

-实例化对象，用工厂方法代替new操作
-将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

工厂模式要点

-简单工厂模式(静态工厂模式)：虽然某种程度不符合设计原则，但实际使用最多。
-工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展。
-抽象工厂模式：不可以增加产品，可以增加产品族

简单工厂模式

要点:
-简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接受的参数的不同来返回不同的对象实例。
-对于增加新产品无能为力！不修改代码

简单工厂的实现：

汽车类接口：

package SimpleFactory;

public interface Car {
	void run();
}

实现类A：

package SimpleFactory;

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

实现类B：

package SimpleFactory;

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

简单工厂类实现方式一：

package SimpleFactory;

/**
 * 简单工厂类
 * @author 
 *
 */
public class CarFactory2 {
	
	public static Car createAudi() {
		return new Audi();
	}
	
	public static Car createByd() {
		return new Byd();
	}
}

简单工厂类实现方式二：

package SimpleFactory;

/**
 * 简单工厂类
 * @author 
 *
 */
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;
		}
	}
}

调用者：

package SimpleFactory;

/**
 * 简单工厂情况下
 * 
 * 要点:
 * 	-简单工厂模式也叫静态工厂模式，就是工厂类一般是使用
 * 	   静态方法，通过接受的参数的不同来返回不同的对象实例。
 * 	-对于增加新产品无能为力！不修改代码
 * @author 
 *
 */

public class Client02 {	//调用者
	public static void main(String[] args) {
		Car c1 = CarFactory.createCar("Audi");
		Car c2 = CarFactory.createCar("Byd");
		
		c1.run();
		c2.run();
	}
}

工厂方法模式

工厂方法模式要点：
-避免了简单工厂模式的缺点(不完全满足OCP)
-工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式 只有一个(对于一个项目或者一个独立模块而言)工厂类，而工 厂方法模式有一组实现了相同接口的场类。

汽车类接口：

package FactoryMethod;

public interface Car {
	void run();
}

工厂类接口：

package FactoryMethod;

public interface CarFactory {
	Car createCar();
}

汽车实现类A：

package FactoryMethod;

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

汽车工厂类A：

package FactoryMethod;

public class AudiFactory implements CarFactory {

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

汽车实现类B：

package FactoryMethod;

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

汽车工厂类B：

package FactoryMethod;

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

调用者：

package FactoryMethod;

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

简单工厂模式和工厂方法模式比较：

-结构复杂度：从这个角度比较。显然简单工厂模式要占优，简单工厂模式只需个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加。这无疑会使类的个数越来越多。从而增加了精构的复杂程度。

-代码复杂度：代码复杂度和精构复杂度是一对矛盾.既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂的了。简单工厂模式的工厂类随着产品类的增加需要增加很多方法(或代码)， 而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。

-客户端编程难度：工厂方法模式虽然在工厂誉结构中引入了接口从而满足了OCP。但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户请无需实例化。这无疑是个吸引人的优点。

-管理上的难度：工厂方法模式虽然在工厂誉结构中引入了接口从而满足了OCP。但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户请无需实例化。这无疑是个吸引人的优点。
然后我们从维护性的角度分析下。假如某个具体产品类需要进行一定的修改。很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候电对工厂类的修改会变得相当麻烦(对号入座已经是个问题了)。反而简单工厂没有这些麻烦，当多个产品类需要修改是,简单工厂模式仍然仅仅需要修改唯的工厂类(无论怎样都能改到满足要求吧?大不了把这个类重写)。

根据设计理论建议:工厂方法模式。但实际上,我们一般都用简单工厂模式。

抽象工厂模式

抽象工厂模式：
-用来生产不同产品族的全部产品。(对于新增的产品，无能为力；支持增加产品族)
-抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

汽车工厂类接口：

package AbstractFactory;

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

发动机类接口：

package AbstractFactory;

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("启动慢！");
	}
	
}

座椅类接口：

package AbstractFactory;

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("不能按摩！");
	}
	
}

轮胎类接口：

package AbstractFactory;

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("磨损快！");	
	}
	
}

高端汽车工厂类：

package AbstractFactory;

class LuxuryCarFactory implements CarFactory{

	public Engine createEngine() {
		// TODO Auto-generated method stub
		return new LuxuryEngine();
	}

	public Seat createSeat() {
		// TODO Auto-generated method stub
		return new LuxurySeat();
	}

	public Tyre createTyre() {
		// TODO Auto-generated method stub
		return new LuxuryTyre();
	}

}

低端汽车工厂类：

package AbstractFactory;

public class LowCarFactory implements CarFactory{

	public Engine createEngine() {
		// TODO Auto-generated method stub
		return new LowEngine();
	}

	public Seat createSeat() {
		// TODO Auto-generated method stub
		return new LowSeat();
	}

	public Tyre createTyre() {
		// TODO Auto-generated method stub
		return new LowTyre();
	}

}

调用者类 :

package AbstractFactory;

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