工厂模式介绍

一、简单工厂模式

1. 基本介绍

1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为。
3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。

2. 代码实现

（1）创建抽象类及其子类

public abstract class Machine {
    private String name;

    public abstract void product();

    public void open() {
        System.out.println(name + " open;");
    }

    public void close() {
        System.out.println(name + " close;");
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class FoodMachine extends Machine {

	public FoodMachine() {
		setName(" 生产食物的机器 ");
	}

	@Override
	public void product() {
		System.out.println(" 生产食物 ");
	}

}

public class ClothesMachine extends Machine {

	public ClothesMachine() {
		setName(" 生产衣服的机器 ");
	}

	@Override
	public void product() {
		System.out.println(" 生产衣服 ");
	}

}

（2）创建工厂类

public class SimpleFactory {
	FoodMachine foodMachine = new FoodMachine();
	ClothesMachine clothesMachine = new ClothesMachine();

	public Machine createMachine(String orderMachine) {

		Machine machine = null;

		if (orderMachine.equals("food")) {
			machine = foodMachine;
		} else if (orderMachine.equals("clothes")) {
			machine = clothesMachine;
		}
		
		return machine;
	}
}

（3）测试简单工厂模式

public class OrderMachine {
	SimpleFactory simpleFactory = new SimpleFactory();

	public OrderMachine() {
		do {
			String orderMachine = getType();
			Machine machine = simpleFactory.createMachine(orderMachine);
			if (machine != null) {
				machine.open();
				machine.product();
				machine.close();
			} else {
				System.out.println(" 不支持生产 ");
				break;
			}
		} while (true);
	}

	private String getType() {
		try {
			BufferedReader strIn = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input machine:");
			return strIn.readLine();
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}
	
	public static void main(String[] args) {
		new OrderMachine();
	}
}

3. UML类图

二、工厂模式

1. 基本介绍

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方
法模式将对象的实例化推迟到子类。

2. 代码实现

（1）创建抽象类及其子类

public abstract class Machine {
    private String name;

    public abstract void product();


    public void open() {
        System.out.println(name + " open;");
    }

    public void close() {
        System.out.println(name + " close;");
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class FlourMachine extends Machine{
	
	public FlourMachine() {
		setName("生产面粉的机器");
	}

	@Override
	public void product() {
		System.out.println(" 生产面粉 ");
		
	}

}

public class BreadMachine extends Machine{
	
	public BreadMachine() {
		setName("生产面包的机器");
	}

	@Override
	public void product() {
		setName("生产面包的机器");
		System.out.println(" 生产面包 ");
	}
}

public class ManClothesMachine extends Machine{

	public ManClothesMachine() {
		setName("生产男装的机器");
	}
	@Override
	public void product() {
		setName("生产男装的机器");
		System.out.println(" 生产男装 ");
	}
}

public class FemaleClothesMachine extends Machine{

	public FemaleClothesMachine() {
		setName("生产女装的机器");
	}
	
	@Override
	public void product() {
		setName("生产女装的机器");
		System.out.println(" 生产女装 ");
	}
}

（2）创建抽象工厂和抽象工厂子类

public abstract class OrderMachine {

	//定义一个抽象方法，让各个工厂子类自己实现
	abstract Machine createMachine(String orderType);
	
	// 构造器
	public OrderMachine() {
		Machine machine = null;
		String orderType;
		do {
			orderType = getType();
			machine = createMachine(orderType); 
			machine.open();
			machine.product();
			machine.close();
			
		} while (true);
	}

	private String getType() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input machine 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}
}

public class ClothesOrderFactory extends OrderMachine {
	
	@Override
	Machine createMachine(String orderType) {
	
		Machine machine = null;
		if(orderType.equals("man")) {
			machine = new ManClothesMachine();
		} else if (orderType.equals("female")) {
			machine = new FemaleClothesMachine();
		}
		return machine;
	}

}

public class FoodOrderFactory extends OrderMachine {

	@Override
	Machine createMachine(String orderType) {
		Machine machine = null;
		if(orderType.equals("bread")) {
			machine = new BreadMachine();
		} else if (orderType.equals("flour")) {
			machine = new FlourMachine();
		}
		return machine;
	}

}

（3）创建测试类

public class Order {

	public static void main(String[] args) {
		String loc = "food";
		if (loc.equals("clothes")) {
			new ClothesOrderFactory();
		} else {
			new FoodOrderFactory();
		}
	}
}

3. UML类图

三、抽象工厂模式

1. 基本介绍

1. 抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类。
2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3. 从设计层面看，抽象工厂模式就是对工厂模式的改进(或者称为进一步的抽象)。
4. 将工厂抽象成两层，抽象工厂和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

2. 代码实现

（1）工厂模式第一步中的抽象类及其子类不需要改变，新建抽象工厂和抽象工厂的实现类。

public interface AbstractFactory {
	public Machine createMachine(String orderMechine);
}

public class ClothesOrderFactory implements AbstractFactory {
	
	@Override
	public Machine createMachine(String orderType) {
	
		Machine machine = null;
		if(orderType.equals("man")) {
			machine = new ManClothesMachine();
		} else if (orderType.equals("female")) {
			machine = new FemaleClothesMachine();
		}
		return machine;
	}

}

public class FoodOrderFactory implements AbstractFactory {

	@Override
	public Machine createMachine(String orderType) {
		Machine machine = null;
		if(orderType.equals("bread")) {
			machine = new BreadMachine();
		} else if (orderType.equals("flour")) {
			machine = new FlourMachine();
		}
		return machine;
	}

}

public class OrderMachine {
	
	private AbstractFactory abstractFactory;
	
	// 构造器
	public OrderMachine(AbstractFactory abstractFactory) {
		setFactory(abstractFactory);
		
	}

	private void setFactory(AbstractFactory abstractFactory) {
		Machine machine = null;
		String orderType;
		do {
			orderType = getType();
			machine = abstractFactory.createMachine(orderType); 
			machine.open();
			machine.product();
			machine.close();
			
		} while (true);
		
	}

	private String getType() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
			System.out.println("input machine 种类:");
			String str = strin.readLine();
			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}
}

（3）新建测试类

public class Order {

	public static void main(String[] args) {
		new OrderMachine(new FoodOrderFactory());
	}
}

3. UML类图

四、工厂模式小结

• 工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
• 工厂设计模式的依赖原则
  （1）创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。有的书上说，变量不要直接持有具体类的引用。
  （2）不要让类继承具体类，而是继承抽象类或者是实现interface(接口)
  （3）不要覆盖基类中已经实现的方法。

其他设计模式