在公司没事做，无聊自己模拟情景来练习函子（functor）的使用。

自己定的一个场景：（自己假象出来的）
公司里面的工作的人有三种角色，分别是实习生、试用期员工、正式员工。
假定 ：
实习生拿的基本工资是800元，试用期员工的基本工资是2000 ，正式员工的基本工资是3000。基本工资暂时是不会变的。实习生经过三个月的工作可以转成试用期员工，试用期员工经过三个月可以转到正式员工。每当一个项目完成后，正式员工可以拿到一部分分红，对于正式员工叫奖金，对于试用期员工叫补贴，实习生是没有的。

现在，有三个人，张三是实习生，李四是试用期员工，王五是正式员工。
要求模拟三个阶段：
1.刚开始，他们都在工作。
2.三个月后，张三变成了试用期员工，李四变成了正式员工。
3.项目结束后，试用期员工拿到补贴1500，正式员工拿到奖金5000
模拟三个阶段，张三、李四、王五拿到的总钱以及清单。

我用函子(functor)，就是Apache Commons Collections提供的三个函子：
Predicate（逻辑判断器）、Transformer（对象转换器）、Closure（对象执行器）

实现如下：

首先看看人员角色的定义：

工作者抽象类：

/**
 * 劳动者,具体分成:实习生、试用期员工、正式员工
 * @create 2010-7-30
 */
public abstract class Worker {
	
	//姓名
	private String name;
		
	public Worker(String name){
		this.name = name;
	}

	/**
	 * 打印收入项目
	 * @return
	 */
	public abstract void printItem();
	
	/**
	 * 获取总共收入
	 * @return
	 */
	public abstract int getTotal();

	public String getName() {
		return name;
	}
}

实习生类：

/**
 * 实习生类
 * @create 2010-7-30
 */
public class Intern extends Worker{
	
	// 实习生基本工资800
	private final int salary = 800;
	
	public Intern(String name){
		super(name);
	}

	// 取得所有收入
	@Override
	public int getTotal() {
		return salary;
	}

	// 打印收入清单
	@Override
	public void printItem() {
		System.out.println(getName() + "[实习生]当月收入总收入为 [薪水" + salary + "元]=["
				+ getTotal() + "]元");
	}
}

试用期员工类：

/**
 * 试用期员工类
 * @create 2010-7-30
 */
public class Probationer extends Worker{

	//薪水=2000
	private final int salary = 2000;
	
	//试用期员工有补贴
	private int  allowance;
	
	public Probationer(String name){
		super(name);
	}

	public void setAllowance(int allowance) {
		this.allowance = allowance;
	}

	@Override
	public int getTotal() {
		return salary+allowance;
	}

	@Override
	public void printItem() {
		System.out.println(getName() + "[试用期员工]当月收入总收入为 [薪水" + salary
				+ "元]+[补贴" + allowance + "]=[" + getTotal() + "]元");
	}
}

正式员工类：

/**
 * 正式员工
 * @create 2010-7-30
 */
public class Employee extends Worker{
	
	//薪水 = 3000
	private final int salary = 3000;
	
	//正式员工有奖金
	private int bonus;
	
	public Employee(String name){
		super(name);
	}

	public void setBonus(int bonus) {
		this.bonus = bonus;
	}

	@Override
	public int getTotal() {
		return salary+bonus;
	}

	@Override
	public void printItem() {
		System.out.println(getName() + "[正式员工]当月收入总收入为 [薪水" + salary + "元]+[奖金"
				+ bonus + "]=[" + getTotal() + "]元");
	}
}

接下来，看看定义的两个转换器

实习生转试用期员工的转换器：

/**
 * 实习生转成 试用期员工 的一个 函子(functor)
 * @create 2010-7-30
 */
public class TransProbationer implements Transformer {

	@Override
	public Object transform(Object input) {
		Intern inter = (Intern) input;
		Probationer probationer = new Probationer(inter.getName());
		return probationer;
	}

}

试用期员工转成正式员工的转换器

/**
 * 试用期员工转成正式员工 的一个 函子(functor)
 * @create 2010-7-30
 */
public class TransEmployee implements Transformer {

	@Override
	public Object transform(Object input) {
		Probationer probationer = (Probationer) input;
		Employee employee = new Employee(probationer.getName());
		return employee;
	}
}

再来看看定义的两个执行器：

给试用期员工发1500补贴的执行器：

/**
 * 试用期员工发1500补贴 的 一个 函子
 * @create 2010-7-30
 */
public class AddAllowanceClosure implements Closure {

	@Override
	public void execute(Object input) {
		Probationer probationer = (Probationer) input;
		probationer.setAllowance(1500);
	}
}

给正式员工发5000奖金的执行器

/**
 * 正式员工发5000奖金的 一个 函子
 * @create 2010-7-30
 */
public class AddGonusClosure implements Closure {

	@Override
	public void execute(Object input) {
		Employee employee = (Employee) input;
		employee.setBonus(5000);
	}
}

开始模拟场景：

public class TestFunctor {
	
	public static void main(String[] args) {
		
		//定义是否是试用期员工的一个函子
		Predicate isProbationerPredicate = new InstanceofPredicate(
				Probationer.class);
		
		//定义是否是正式员工的一个函子
		Predicate isEmployeePredicate = new InstanceofPredicate(Employee.class);
		
		//定义三个劳动者 张三[实习生]、李四[试用期员工]、王五[正式员工]
		Worker zhansan = new Intern("张三");
		Worker lisi = new Probationer("李四");
		Worker wangwu = new Employee("王五");
		
		//查看目前收入
		System.out.println("\n来看看 张三、李四、王五目前的月收入:");
		zhansan.printItem();
		lisi.printItem();
		wangwu.printItem();
		
		//经过努力~~张三转成试用期员工了,李四转成正式员工了~
		System.out.println("\n\n3个月过去了,张三转成试用期员工了,李四转成正式员工了......");
		Transformer transProbationer = new TransProbationer();
		Transformer transEmployee = new TransEmployee();
		zhansan = (Worker) transProbationer.transform(zhansan);
		lisi = (Worker) transEmployee.transform(lisi);
		
		//查看目前收入
		System.out.println("\n来看看 张三、李四、王五目前的月收入:");
		zhansan.printItem();
		lisi.printItem();
		wangwu.printItem();
		
		
		//公司项目取得良好的成就，因此规定凡是试用期员工发补贴1500元,正式员工发奖金5000元
		System.out.println("\n\n目前公司取得很好的成绩,因此凡是试用期员工发补贴1500元,正式员工发奖金5000元");
		Map<Predicate , Closure> map = new HashMap<Predicate, Closure>();
		Closure allowanceClosure = new AddAllowanceClosure();
		Closure gonusClose = new AddGonusClosure();
		
		//如果是试用期员工，则发补贴
		map.put(isProbationerPredicate, allowanceClosure);
		//如果是正式员工,则发奖金
		map.put(isEmployeePredicate, gonusClose);
		//SwitchClosure是实现了Switch的闭包
		Closure rewards = SwitchClosure.getInstance(map);
		rewards.execute(zhansan);
		rewards.execute(lisi);
		rewards.execute(wangwu);
		
		System.out.println("\n来看看 张三、李四、王五目前的月收入:");
		zhansan.printItem();
		lisi.printItem();
		wangwu.printItem();
	}
}

运行结果：

来看看 张三、李四、王五目前的月收入:
张三[实习生]当月收入总收入为 [薪水800元]=[800]元
李四[试用期员工]当月收入总收入为 [薪水2000元]+[补贴0]=[2000]元
王五[正式员工]当月收入总收入为 [薪水3000元]+[奖金0]=[3000]元


3个月过去了,张三转成试用期员工了,李四转成正式员工了......

来看看 张三、李四、王五目前的月收入:
张三[试用期员工]当月收入总收入为 [薪水2000元]+[补贴0]=[2000]元
李四[正式员工]当月收入总收入为 [薪水3000元]+[奖金0]=[3000]元
王五[正式员工]当月收入总收入为 [薪水3000元]+[奖金0]=[3000]元


目前公司取得很好的成绩,因此凡是试用期员工发补贴1500元,正式员工发奖金5000元

来看看 张三、李四、王五目前的月收入:
张三[试用期员工]当月收入总收入为 [薪水2000元]+[补贴1500]=[3500]元
李四[正式员工]当月收入总收入为 [薪水3000元]+[奖金5000]=[8000]元
王五[正式员工]当月收入总收入为 [薪水3000元]+[奖金5000]=[8000]元

可以发现，使用函子可以把逻辑判断、对象转换、对象操作分离的很开，可以任意的自由的组合，通过组合达到所要的目的，代码上可能是多了点，但是对于抗击需求的变化是很好的，可以很好的扩展，可以任意的扩展对象操作，逻辑判断等。继续研究ing~~

• 相关文章
• 全局相关文章