java设计模式-工厂模式

1.普通工厂模式

1)简单工厂模式也叫静态工厂模式，就是工厂类一般使用静态方法，通过接收不同的参数来生成不同的对象实例。
2)对于增加新产品无能为力！不修改代码的话，是无法扩展的。
3)一般使用较多还是简单工厂模式。

/**
 * 抽象类-所有车的父类
 */
public interface Car {
	
	public void run();
}

/**
 * 实体类-宝马车
 */
public class BMWCar implements Car {

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

}

/**
 * 实体类-奔驰车
 */
public class BenzCar implements Car {

	@Override
	public void run() {
		System.out.println("奔驰在跑");
	}

}

/**
 * 车的工厂类
 */
public class CarFactory {

	public static final int TYPE_BMW = 1;  //宝马
	public static final int TYPE_BENZ = 2;  //奔驰
	
	public static Car createCar(int type) {
		Car car = null;
		switch (type) {
		case CarFactory.TYPE_BMW:
			car = new BMWCar();
			break;
		case CarFactory.TYPE_BENZ:
			car = new BenzCar();
			break;
		default:
			throw new RuntimeException("找不到你要的车！");
		}
		return car;
	}
	
}

/**
 * 测试类
 */
public class Test {
	
	public static void main(String[] args) {
		Car bmw = CarFactory.createCar(CarFactory.TYPE_BMW);
		bmw.run();
		Car benz = CarFactory.createCar(CarFactory.TYPE_BENZ);
		benz.run();
		try {
			CarFactory.createCar(3);
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}
}

2.工厂方法模式

1)解决简单工厂模式不满足开闭原则的缺点。

2)工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个(对于一个项目或者一个独立模块而言)工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

/**
 * 车的工厂类
 */
public interface CarFactory {

	public Car createCar(); 
	
}

 

/**
 *  宝马工厂类
 */
public class BMWFactory implements CarFactory {
	
	private static BMWFactory instance = new BMWFactory();

	private BMWFactory() {
	}

	public static BMWFactory getInsance() {
		return BMWFactory.instance;
	}

	@Override
	public BMWCar createCar() {
		return new BMWCar();
	}

}

/**
 *  奔驰工厂类
 */
public class BenzFactory implements CarFactory {
	
	private static BenzFactory instance = new BenzFactory();

	private BenzFactory() {
	}

	public static BenzFactory getInsance() {
		return BenzFactory.instance;
	}

	@Override
	public BenzCar createCar() {
		return new BenzCar();
	}

}

/**
 * 测试类
 */
public class Test {
	
	public static void main(String[] args) {
		Car bmw = BMWFactory.getInsance().createCar();
		bmw.run();
		Car benz = BenzFactory.getInsance().createCar();
		benz.run();
	}
}

简单工厂与工厂方法模式的对比：

1）但从设计理论的角度出发，肯定是工厂方法更好，符合OCP原则，结构复杂度虽然高了一点，但代码复杂度降低了很多。

2）但是随着产品种类的增加，使用工厂方法模式会一直增加工厂类，管理难度增加，不熟悉的人真不知道用哪个工厂类。简单工厂方法就一个类，虽然需要修改代码，但是代码量比较少。

所以还是建议使用简单工厂模式。

3.抽象工厂模式

抽象工厂模式与工厂模式有本质的区别，工厂模式是针对不同的产品，抽象工厂则是针对产品族。

/**
 *	发动机
 */
public interface Engine {
	public void run();
}

/**
 *  A型发动机
 */
public class EngineA implements Engine {

	@Override
	public void run() {
		System.out.println("A型发动机启动了！");
	}

}

/**
 *  B型发动机
 */
public class EngineB implements Engine {

	@Override
	public void run() {
		System.out.println("B型发动机启动了！");
	}

}

/**
 * 轮胎
 */
public interface Tyre {
	public void run();
}

/**
 *	A类轮胎
 */
public class TyreA implements Tyre {

	@Override
	public void run() {
		System.out.println("A类轮胎在跑！");
	}

}

/**
 *	B类轮胎
 */
public class TyreB implements Tyre {

	@Override
	public void run() {
		System.out.println("B类轮胎在跑！");
	}

}

/**
 *	抽象工厂类
 */
public interface AbstractFactory {
	Engine createEngine();
	Tyre createTyre();
}

/**
 *  A类产品族的抽象工厂
 */
public class AbstractFactoryA implements AbstractFactory {

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

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

}

/**
 *  B类产品族的抽象工厂
 */
public class AbstractFactoryB implements AbstractFactory {

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

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

}