设计模式-创建型模式-工厂模式

工厂模式

工厂模式的和兴就是负者合适对象的创建；是一种非常常见的创建性设计模式，隐藏创建对象的创建逻辑，通过使用共同的接口来创建对象；添加新类时只需要做少量的修改；

1.简单工厂模式

调用方法直接获取对象 （前面说的单例模式也是一种方式）；

简单工厂具体的实现方式一般是 ，静态工厂模式，反射类注册，newInstance 方式

1.1 静态工厂模式

只负责对象实例化，符合单一职责； 只需要调用创建接口就可以；

public class SimpleFactory1 {

	public static Vehicle create(VehicleType type) {
		Vehicle vehicle = null;
		switch (type) {
		case CAR:
			vehicle = new Car();
			break;
		case BIKE:
			vehicle = new Bike();
			break;
		case TRUCK:
			vehicle = new Truck();
			break;
		}
		return vehicle;
	}

	enum VehicleType {
		BIKE, CAR, TRUCK;
	}

	public interface Vehicle {
		void move();
	}

	public static class Bike implements Vehicle {

		@Override
		public void move() {
			System.out.println(" Bike ...");
		}
	}

	public static class Car implements Vehicle {
		@Override
		public void move() {
			System.out.println(" Car ...");
		}
	}

	public static class Truck implements Vehicle {
		@Override
		public void move() {
			System.out.println(" Truck ...");
		}
	}
}

但是添加新类的时候，还需要修改 创建的代码，就打破了开闭原则；

解决方式：在工厂类中，添加Map 保存对象或者类

1.2 反射类进行类注册

public class SimpleFactory2 {

	private static Map<String, Class> vehicleClassMap = new HashMap<>();
	static {
		vehicleClassMap.put("Bike", Bike.class);
		vehicleClassMap.put("Car", Car.class);
		vehicleClassMap.put("Truck", Truck.class);
	}

	public static Vehicle create(String type) {
		try {
			Class type1 = vehicleClassMap.get(type);
			Vehicle vehicle = (Vehicle) type1.newInstance();
			return vehicle;
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return null;
	}

	public interface Vehicle {
		void move();
	}

	public static class Bike implements Vehicle {
		@Override
		public void move() {
			System.out.println(" Bike ...");
		}
	}

	public static class Car implements Vehicle {
		@Override
		public void move() {
			System.out.println(" Car ...");
		}
	}

	public static class Truck implements Vehicle {
		@Override
		public void move() {
			System.out.println(" Truck ...");
		}

	}
}

4.工厂方法模式

静态工厂模式的改进，工厂类抽象化；

公有方法在工厂方法(这里指的是创建对象的方法)抽象类中执行； 特定示例的创建被放到具体的工厂类中；

示例

public interface Vehicle {
	public String color = null;

	void move();
}

public abstract class Factory {

	void orderVehicle(String size, String color) {
		Vehicle vehicle = create(size);
	}

	abstract Vehicle create(String size);
}



public class CarFactory extends Factory {

	@Override
	public Vehicle create(String size) {
		if (size.equals("small")) {
			return new SportCar();
		} else {
			return new SedanCar();
		}
	}

	public static class Car implements Vehicle {
		@Override
		public void move() {
			System.out.println(" Car ...");
		}
	}

	public class SportCar extends Car implements Vehicle {
		@Override
		public void move() {
			System.out.println(this.color);
			System.out.println(" SportCar ...");
		}
	}

	public class SedanCar extends Car implements Vehicle {
		@Override
		public void move() {
			System.out.println(this.color);
			System.out.println(" SedanCar ...");
		}
	}
}

5.抽象工厂模式

抽象工厂也是工厂方法模式扩展

抽象工厂不是单一的创建对象，而是创建一系列相互关联的对象；这一系列相互关联的对象叫做对象簇，或者叫做产品簇；

抽象工厂由下面几个部分组成

• AbstractFactory （抽象工厂类），定义不同类型产品，或者叫一系列 的方法，
• ConcreteFactory （具体工厂类），实现抽象工厂类，创建不同类型的产品，或者说一系列
• AbstractProduct（抽象产品类），抽象工厂类创建的抽象类产品，所有的抽象产品类 构成一个系列，称之为产品簇；

代码示例：

AbstractFactory

public abstract class HumanAndMagicFactory {

	abstract Food createFood();

	abstract Transportation createTransportation();
}

AbstractProduct

产品1和其对应的实现

public interface Food {

	void eat();

}

public class MushRoom implements Food {

	@Override
	public void eat() {
		System.out.println("MushRoom is good");
	}
}

public class Rice implements Food {

	@Override
	public void eat() {
		System.out.println("Rice is nice");
	}
}

产品2和其对应的实现

public interface Transportation {

	void move();
}

public class Car implements Transportation {
	@Override
	public void move() {
		System.out.println("car move is tutututu broom");
	}
}

public class MagicBroom implements Transportation {
	@Override
	public void move() {
		System.out.println("MagicBroom  wuwuwu~");
	}
}

ConcreteFactory

public class HumanFactory extends HumanAndMagicFactory {

	@Override
	Food createFood() {
		return new Rice();
	}

	@Override
	Transportation createTransportation() {
		return new Car();
	}
}


public class MagicFactory extends HumanAndMagicFactory {

	@Override
	Food createFood() {
		return new MushRoom();
	}

	@Override
	Transportation createTransportation() {
		return new MagicBroom();
	}
}

这些类放到上面的概念图就是

5. 总结

这三种方式在某种意义上面也有很多重复的概念；模式之间没有严格的边界； 那只要知道工厂的核心就是产生对象，创建对象；具体工厂方法的细分就是对产生对象的方法做补充或者更抽象；