工厂设计模式

1.简单工厂

构成

1. 抽象产品类：定义产品的标准和规范
2. 具体产品类：具体实现产品的标准和规范
3. 简单工厂类：根据需求，创建产品对象

优点

将产品对象的创建，不在由我们自己来new 而是由工厂来进行创建

缺点

是工厂和产品之间产生了高度的耦合，工厂的设计不符合类设计的开闭原则：类的扩展性不强

package org.lanqiao.simplefactory.demo;
//抽象产品类：可以是一个抽象类，也可以是一个接口
public interface ICar {
	public void driver();
}

package org.lanqiao.simplefactory.demo;
//具体产品
public class Benz implements ICar{

	@Override
	public void driver() {
		System.out.println("驾驶一辆奔驰");
		
	}

}

package org.lanqiao.simplefactory.demo;
//具体产品
public class BMW  implements ICar{

	@Override
	public void driver() {
		System.out.println("驾驶一辆宝马...");
		
	}
	
}

package org.lanqiao.simplefactory.demo;
//工厂类
public class SimpleFactory {
	
	public static ICar  creatCar(Class<?> clazz) {
		if(clazz.getName().equals(BMW.class.getName())) {
			
			return creatBMW();
		}else if(clazz.getName().equals(Benz.class.getName())) {
			return creatBenz();
			
		}
		return null;
		
	}
	private static  BMW creatBMW() {
		
		return new BMW();
	}
	
	private static  Benz creatBenz() {
		return new Benz();
		
	}	
}

package org.lanqiao.simplefactory.demo;

public class Test {
	public static void main(String[] args) {
		//通过使用工厂来创建对象
		SimpleFactory sf = new SimpleFactory();
		ICar bmw =  sf.creatCar(BMW.class);
		bmw.driver();
		
		ICar benz = sf.creatCar(Benz.class);
		benz.driver();
		
	}
}

2.工厂方法

构成

1. 抽象产品
2. 具体产品
3. 抽象工厂
4. 具体的工厂

优点

1. 抽象工厂类的存在。降低了工厂类和产品之间的耦合度
2. 符合可程序设计的开闭原则，程序的扩展性增强

缺点

在扩展程序的时候，都需要创建具体的工厂类。程序的复杂度有所提升。

package org.lanqiao.factorymethod.demo;
//抽象产品类：可以是一个抽象类，也可以是一个接口
public interface ICar {
	public void driver();
	public void sit();
}

package org.lanqiao.factorymethod.demo;
//具体产品
public class Benz implements ICar{

	@Override
	public void driver() {
		System.out.println("奔驰的操控性不如宝马...");
		
	}

	@Override
	public void sit() {
		System.out.println("奔驰的乘坐就是比宝马舒服...");
		
	}

}

package org.lanqiao.factorymethod.demo;
//具体产品
public class BMW  implements ICar{

	@Override
	public void driver() {
		System.out.println("宝马的操控性就是好。。。。");
		
	}

	@Override
	public void sit() {
		System.out.println("宝马的乘坐舒适性不如奔驰...");
		
	}
	
}

package org.lanqiao.factorymethod.demo;

public class Audi  implements ICar{

	@Override
	public void driver() {
	System.out.println("驾驶一辆奥迪");
		
	}

	@Override
	public void sit() {
		System.out.println("坐在奥迪里边哭");
		
	}

}

package org.lanqiao.factorymethod.demo;
//抽象工厂类
public abstract class AbstractCarFactory {
	public abstract ICar  creatCar();
}

package org.lanqiao.factorymethod.demo;

public class AudiFactory  extends AbstractCarFactory{

	@Override
	public ICar creatCar() {
		// TODO Auto-generated method stub
		return new  Audi();
	}

}

package org.lanqiao.factorymethod.demo;

public class BenzFactory extends AbstractCarFactory{

	@Override
	public ICar creatCar() {
		
		return new Benz();
	}

}

package org.lanqiao.factorymethod.demo;

public class BMWFactory	extends AbstractCarFactory {

	@Override
	public ICar creatCar() {
		return new BMW();
	}

}

package org.lanqiao.factorymethod.demo;

public class TestFactoryMethod {
	public static void main(String[] args) {
		AbstractCarFactory bmwF = new BMWFactory();
		
		ICar bmw = bmwF.creatCar();
		bmw.driver();
		bmw.sit();
		
		AbstractCarFactory benzF = new BenzFactory();
		ICar benz = benzF.creatCar();
		benz.driver();
		benz.sit();
	}
}

3.抽象工厂

构成

优点

1. 分离接口和实现：客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已。也就是说，客户端从具体的产品实现中解耦。
2. 切换产品族变得容易：对于增加新的产品族，抽象工厂模式很好地支持了开闭原则，只需要增加具体产品并对应增加一个新的具体工厂，对已有代码无须做任何修改（如：新增一种手柄操作支持）。

缺点

不易扩展新产品：如果需要给整个产品族添加一个新的产品，那么就需要修改抽象工厂，这样就会导致修改所有的工厂实现类（如：新增一种操作系统的支持，那么Factory代码需要全部修改）。

示例：《王者荣耀》---既可以运行在Linux 、Windows
            在不同的操作系统上安装游戏：游戏的控制、游戏界面的显示，游戏的玩法应该是游戏本身的

package org.lanqiao.abstractfactory.demo;

public interface Windows {
	public void controller();
}

package org.lanqiao.abstractfactory.demo;

public class WindowsController  implements Windows{

	@Override
	public void controller() {
		System.out.println("windows控制《王者荣耀》");
		
	}

}

package org.lanqiao.abstractfactory.demo;
/*
 * 抽象工厂：定义游戏使用的平台
 */
public abstract  class AbstractFactory {
	public  abstract Linux installLinux();
	public abstract Windows installWindow();
}

package org.lanqiao.abstractfactory.demo;

public class InterfaceController	extends AbstractFactory{

	@Override
	public Linux installLinux() {
		System.out.println("在Linux系统上安装《王者荣耀》的界面渲染");
		return new LinuxController();
	}

	@Override
	public Windows installWindow() {
		System.out.println("在Windows系统上安装《王者荣耀》的界面渲染");
		return new WindowsController();
	}

}

package org.lanqiao.abstractfactory.demo;

public interface Linux {
	public void controller();
}

package org.lanqiao.abstractfactory.demo;

public class LinuxController implements Linux {

	@Override
	public void controller() {
		System.out.println("linux 控制《王者荣耀》");
		
	}
	
}

package org.lanqiao.abstractfactory.demo;

public class OpreationController extends AbstractFactory{

	@Override
	public Linux installLinux() {
		System.out.println("在Linux系统上安装《王者荣耀》的游戏控制");
		return new LinuxController();
	}

	@Override
	public Windows installWindow() {
		System.out.println("在Windows系统上安装《王者荣耀》的游戏控制");
		return new WindowsController();
	}

}

package org.lanqiao.abstractfactory.demo;

public class Test {
	public static void main(String[] args) {
		AbstractFactory linuxOpreation  = new OpreationController();
		Linux linux = linuxOpreation.installLinux();//安装游戏控制
		AbstractFactory linuxInterface = new InterfaceController();
		linuxInterface.installLinux();//渲染游戏界面;
		linux.controller();//进行游戏
		
		
	}
}