Java（设计模式）[工厂]

简单工厂模式

结构

实现

计算父类：

public class Calculate {
	double num1;
	double num2;

	public double getResult() {
		return 0;
	}
}

加法类：

public class Add extends Calculate {
	@Override
	public double getResult() {
		return num1 + num2;
	}
}

减法类：

public class Substract extends Calculate {
	@Override
	public double getResult() {
		return num1 - num2;
	}
}

乘法类：

public class Multiply extends Calculate {
	@Override
	public double getResult() {
		return num1 * num2;
	}
}

除法类：

public class Divide extends Calculate {
	@Override
	public double getResult() {
		if (num2 == 0) {
			System.out.println("除数不能为0！");
			return 0;
		}
		return num1 / num2;
	}
}

工厂类：

public class CalculateFactory {
	public static Calculate getCalculate(String operation) {
		switch (operation) {
		case "+":
			return new Add();
		case "-":
			return new Substract();
		case "*":
			return new Multiply();
		case "/":
			return new Divide();
		}
		return new Calculate();
	}
}

测试方法：

public static void main(String[] args) {
	Calculate calculate = CalculateFactory.getCalculate("+");
	calculate.num1 = 1.5;
	calculate.num2 = 2;
	System.out.println(calculate.getResult());
}

结果：3.5

扩展

如果需要新加一种计算类型，除了要创建新的计算类，还要修改 CalculateFactory 中的 getCalculate 方法，在 switch 中添加新的判断分支。（不符合开-闭原则）

工厂方法模式

结构

实现

计算父类和加减乘除类与简单工厂一样。
工厂类：

public class CalculateFactory {
	public Calculate getCalculate() {
		return new Calculate();
	}
}

加法工厂类：

public class AddFactory extends CalculateFactory {
	@Override
	public Calculate getCalculate() {
		return new Add();
	}
}

减法工厂类：

public class SubstractFactory extends CalculateFactory {
	@Override
	public Calculate getCalculate() {
		return new Substract();
	}
}

乘法工厂类：

public class MultiplyFactory extends CalculateFactory {
	@Override
	public Calculate getCalculate() {
		return new Multiply();
	}
}

除法工厂类：

public class DivideFactory extends CalculateFactory {
	@Override
	public Calculate getCalculate() {
		return new Divide();
	}
}

测试方法：

public static void main(String[] args) {
	CalculateFactory factory = new AddFactory();
	Calculate calculate = factory.getCalculate();
	calculate.num1 = 1.5;
	calculate.num2 = 2;
	System.out.println(calculate.getResult());
}

结果：3.5

扩展

如果需要新加一种计算类型，只要创建新的计算类和新的计算工厂类就可以了，不需要修改业务代码。（符合开-闭原则）

抽象工厂模式

结构

实现

用户接口：

public interface IUser {
	public void singIn();
}

mysql 用户业务类：

public class MysqlUser implements IUser {
	@Override
	public void singIn() {
		System.out.println("用户签到：mysql");
	}
}

sqlserver 用户业务类：

public class SqlserverUser implements IUser {
	@Override
	public void singIn() {
		System.out.println("用户签到：sqlserver");
	}
}

订单接口：

public interface IOrder {
	public void finish();
}

mysql 订单业务类：

public class MysqlOrder implements IOrder {
	@Override
	public void finish() {
		System.out.println("完成订单：mysql");
	}
}

sqlserver 订单业务类：

public class SqlserverOrder implements IOrder {
	@Override
	public void finish() {
		System.out.println("完成订单：sqlserver");
	}
}

工厂接口：

public interface IFactory {
	public IUser getUser();
	public IOrder getOrder();
}

mysql 工厂类：

public class MysqlFactory implements IFactory {
	@Override
	public IUser getUser() {
		return new MysqlUser();
	}

	@Override
	public IOrder getOrder() {
		return new MysqlOrder();
	}
}

sqlserver 工厂类：

public class SqlserverFactory implements IFactory {
	@Override
	public IUser getUser() {
		return new SqlserverUser();
	}

	@Override
	public IOrder getOrder() {
		return new SqlserverOrder();
	}
}

测试方法：

public static void main(String[] args) {
	IFactory factory = new MysqlFactory();
	factory.getUser().singIn();
	factory.getOrder().finish();
}

结果：
用户签到：mysql
完成订单：mysql

扩展

如果需要新加一种数据源类型，需要创建新的数据源工厂类和每种业务的实现类。（符合开-闭原则）