我的java设计模式 总结【3】工厂 Factory

工厂模式

任何产生对象的方法或者类都可以称之为工厂，工厂就是产生东西的方法。

• 单例也是一种工厂
• 与new的区别
  • 可以灵活的控制创建方法
  • 可以增加修饰
  • 日志输出等

简单工厂

其实就是很简单的创建对象，或者说根据不同的条件，标识创建不同的对象。
参考代码：

// 定义一个接口Car 
public interface Car {
	String getType();
}
//根据Car接口来实现两个实现类 
//跑车 
public class SportsCar implements Car {
	@Override
	public String getType() {
	
		return "sports";
	}
}
// 大巴车
public class BusCar implements Car {
	@Override
	public String getType() {
		return "bus";
	}
}
//再做一个工厂类。根据不同的需求创建不同的Car对象
public class CarFactory {
	public static Car getCar(String type) {
		if ("s".equals(type)) {
			return new SportsCar();
		}
		if ("b".equals(type)) {
			return new BusCar();
		}
		return null;
	}
}
// 对于工厂的使用
	public static void main(String[] args) {
		Car c1=CarFactory.getCar("b");
		System.out.println(c1.getType());
		Car c2=CarFactory.getCar("s");
		System.out.println(c2.getType());
	}

这个简单工厂是很简单的操作和使用

工厂方法

factory methods
其实就是把构造对象的factory再工厂化对于以上代码需要增加一个factory的接口

//这里的CarFactory就变为了一个接口
public interface CarFactory {
	Car buildCar();
}
//根据不同的类型产生不同的car对象
//bus car 工厂
public class BusCarFactory implements CarFactory {
	public Car buildCar() {
		return new BusCar();
	}
}
// soports car 工厂
public class SportsCarFactory implements CarFactory {
	public Car buildCar() {
		return new SportsCar();
	}
}
//变更过后的调用办法
	public static void main(String[] args) {
		CarFactory cfb=new BusCarFactory();
		System.out.println(cfb.buildCar().getType());;
		CarFactory cfs=new SportsCarFactory();
		System.out.println(cfs.buildCar().getType());;
	}

相比较简单工厂，代码层面是多了两个具体的产生car的工厂，而且再获取car实例的时候也不用再传入不同的参数，而是直接调用不同的carFactory的实现类即可获取。

抽象工厂

Abstract Factory 抽象工厂，其实就将工厂方法复杂化，因为很多实际场景都是很复杂的，并不是单一的只有一种类型。就比如上面的例子，产生车对象，不但有车还有驾驶员，或者燃料等等其他不同于car又独立而且有和关系的的事情。
简单举例说明一下：

//增加一个驾驶员吧
public interface Driver {
	String showType();
}
//人类驾驶员
public class HumanDriver implements Driver {
	@Override
	public String showType() {	
		return "human";
	}
}
//机器人驾驶员
public class RobotDriver implements Driver {
	@Override
	public String showType() {
		return "robot";
	}
}
//而对于car Factory来说需要增加一个 关于驾驶员的方法
public interface CarFactory {
	Driver buildDriver();
	Car buildCar();
}
//再不同的实现CarFactory的对象中也同样需要增加对应的实现
//公交车的工厂
public class BusCarFactory implements CarFactory {
	public Driver buildDriver() {
		return new HumanDriver();
	}
	public Car buildCar() {
		return new SportsCar();
	}
}
// 跑车的工厂
public class SportsCarFactory implements CarFactory {
	public Driver buildDriver() {	
		return new HumanDriver();
	}	
	public Car buildCar() {
		return new BusCar();
	}
}
//对于区别驾驶员的不同我又增加了一个新的Car
//出租车
public class TaxiCar implements Car {
	@Override
	public String getType() {
		return "taxi";
	}
}
//而出租车的工厂我觉得可以是机器人来开
public class TaxiCarFactory implements CarFactory {
	public Driver buildDriver() {
		return new RobotDriver();
	}
	public Car buildCar() {
		return new TaxiCar();
	}
}
//对应的调用测试
	public static void main(String[] args) {

		CarFactory busCarFactory = new BusCarFactory();
		System.out.println(busCarFactory.buildCar().getType() + "  " + busCarFactory.buildDriver().showType());

		CarFactory sportsCarFactory = new SportsCarFactory();
		System.out.println(sportsCarFactory.buildCar().getType() + "  " + sportsCarFactory.buildDriver().showType());

		CarFactory taxiCarFactory = new TaxiCarFactory();
		System.out.println(taxiCarFactory.buildCar().getType() + "  " + taxiCarFactory.buildDriver().showType());

	}

补充

对于这三种工厂来说不一定是绝对那种好或者那种不好，具体需求还需具体对待。根据需求或者说操作对象的简易来选择就好。凡事也没有绝对，代码还是需要通俗易懂好维护。