【重构】使用简单工厂模式重构Switch语句

Code Smell：Switch Statements

Switch语句的问题在于，一旦有新case出现，Switch语句块就要加上这条case。

如果Switch语句块很多且散布在不同的地方，找到并修改它们将是非常恐怖的事。

下面这个例子是，根据枚举中employee的角色，

GetDescription(EmployeeType empType)方法给出employee的职位描述；

PayAmount(EmployeeType empType)方法给出employee的薪酬。

如果这个时候我在枚举中添加另一个角色：consultant。

那么我就要找到上面两个方法，把case consultant的判断语句加到原来的switch语句中。

而简单工厂模式重构的意义在于：不用再去找涉及新角色的switch语句，把角色应有的属性和方法直接写在该角色所在的类中。

package refraction.swith;

public class BeforeRefraction {

enum EmployeeType{
ENGINEER,SALESMAN,MANAGER;
}
public static int m_basicSalary;
public static int m_commission;
/**
*
* switch语句接收枚举类型，判断输出相应的薪资算法
* @param empType    Employee type in enum
* @return           Payment of each type
*/
public int PayAmount(EmployeeType empType) throws Exception
{
switch (empType)
{
case ENGINEER:
return m_basicSalary;
case SALESMAN:
return m_basicSalary + m_commission;
case MANAGER:
return 2 * m_basicSalary;
default:
throw new Exception("no such employee type!");
}
}
/**
* switch再来一遍，接收枚举类型，判断输出相应的职位描述
*
* @param empType    Employee type in enum
* @return           Description of each type
*/
public String GetDescription(EmployeeType empType) throws Exception
{
switch (empType)
{
case ENGINEER:
return "Coding, Debug, Optimization";
case SALESMAN:
return "Getting contracts";
case MANAGER:
return "Analysis, Scheduling, Reporting";
default:
throw new Exception("no such employee type!");
}
}
}

多态是面向对象编程的精髓之一，我们来回顾多态的要点：

1.接口/抽象类的引用变量可以引用实现类的对象

2.父类的引用变量可以引用子类的对象

3.实现类需要重写抽象方法

基于多态的理念，我们

第一步：把case中的角色抽象成继承了（实现了）统一抽象类（接口）的子类。

第二步：子类实现各自的抽象方法

第三步：工厂根据定制，按需创建子类的对象。

STEP1

把Switch语句中的每个case抽取出来：

class Engineer

class Salesman

class Manager

STEP2

然后把他们共有的部分抽象为一个抽象类或者接口：

abstract class Employee

STEP3

工厂接收抽象类或接口的引用变量，再根据引用变量的类型按条件new出具体的子类。工厂可以是一个单独的类，也可以是放在上面的抽象类中。

package refraction.swith;

public class AfterRefraction {

public static void main(String[] args) {
Employee employee = null;
try {
employee = Factory.getEmployee(EmployeeType.ENGINEER);
} catch (Exception e) {
e.printStackTrace();
}
employee.getDescription();
System.out.println("Salary:"+employee.PayAmount());

}
}

enum EmployeeType{
ENGINEER,SALESMAN,MANAGER;
}

abstract class Employee{
public static int m_basicSalary;
public static int m_commission;
/*
* 工厂方法也可以放在这里，仍然是一个静态方法
*/
public abstract String getDescription();
public abstract int PayAmount();
}

//把Switch语句中的每个case抽取出来，然后把他们共有的部分抽象为一个抽象类或者
class Engineer extends Employee{
@Override
public String getDescription() {
return "Coding, Debug, Optimization";
}

@Override
public int PayAmount() {
return  m_basicSalary;
}

}
class Salesman extends Employee{
@Override
public String getDescription() {
return "Getting contracts";
}

@Override
public int PayAmount() {
return  m_basicSalary + m_commission;
}
}

class Manager extends Employee{
@Override
public String getDescription() {
return "Analysis, Scheduling, Reporting";
}

@Override
public int PayAmount() {
return  m_basicSalary *2;
}
}

/**
*
* 工厂类，这里只有一个静态方法
* 工厂类只做一件事：按条件new对象
* 这样一来，我们在main方法中就不用new不同的employee对象了
*/

class Factory{
public static Employee getEmployee(EmployeeType employee) throws Exception{
switch(employee){
case ENGINEER:
return new Engineer();
case SALESMAN:
return new Salesman();
case MANAGER:
return new Manager();
default:
throw new Exception("no such employee type!");
}
}
}

简单工厂模式的缺陷：

1.甲方必须知道工厂能产出什么，否则工厂要抛出异常。

2.新增了case后，虽然不用再去找散落各处的switch语句，但是工厂中的switch语句还是要跟着改的，违反了开闭原则。