场景描述
项目客户方收购了一家小公司，这家小公司有自己的工资系统，客户方的工资系统内部采用List来记录工资列表，新收购的小公司的工资系统内部采用数组来记录工资列表，整合两个系统的工资表数据
已有系统代码示例
- 一个统一了的工资描述模型
/**
*
* 工资描述模型对象
*/
public class PayModel {
/**
* 支付工资的人员
*/
private String userName;
/**
* 支付的工资数额
*/
private double pay;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public double getPay() {
return pay;
}
public void setPay(double pay) {
this.pay = pay;
}
@Override
public String toString() {
return "userName="+userName+",pay="+pay;
}
}
- 客户方已有的工资管理系统中的工资管理类，内部使用List来管理
/**
* 客户方已有的工资管理对象
*
*/
public class PayManager {
/**
* 聚合对象,使用List管理
*/
private List<PayModel> list = new ArrayList<>();
/**
* 获取工资列表
* @return 工资列表
*/
public List<PayModel> getPayList() {
return list;
}
/**
* 计算工资
*/
public void calcPay() {
//计算工资，把工资信息填充到工资列表中
PayModel pm1 = new PayModel();
pm1.setUserName("张三");
pm1.setPay(3000);
PayModel pm2 = new PayModel();
pm2.setUserName("李四");
pm2.setPay(5000);
list.add(pm1);
list.add(pm2);
}
}
- 被收购公司的工资系统中的工资管理类，内部通过数组来管理
/**
*
* 被客户方收购的公司的工资管理类
*
*/
public class SalaryManager {
/**
* 使用数组管理
*/
private PayModel[] pms = null;
/**
* 获取工资列表
*
* @return 工资列表
*/
public PayModel[] getPays() {
return pms;
}
/**
* 计算工资
*/
public void calcSalary() {
PayModel pm1 = new PayModel();
pm1.setUserName("王五");
pm1.setPay(3300);
PayModel pm2 = new PayModel();
pm2.setUserName("赵六");
pm2.setPay(4100);
pms = new PayModel[2];
pms[0] = pm1;
pms[1] = pm2;
}
}
- 此时来访问两个系统的工资列表，外部要采用不同的访问方式，一个是访问数组，一个是访问集合对象
PayManager payManager = new PayManager();
payManager.calcPay();
Iterator<PayModel> it = payManager.getPayList().iterator();
System.out.println("集团工资列表");
while(it.hasNext()) {
PayModel m = it.next();
System.out.println(m);
}
SalaryManager sm = new SalaryManager();
sm.calcSalary();
PayModel[] pms = sm.getPays();
System.out.println("新收购公司工资列表");
for(int i=0;i<pms.length;i++) {
System.out.println(pms[i]);
}
- 为了能让客户端以一个统一的方式进行访问，最容易的方式就是为它们定义一个统一的接口
/**
* 迭代器接口，定义访问和遍历元素的操作
*
*/
public interface Iterator {
/**
* 移动到聚合对象的第一个位置
*/
public void first();
/**
* 移动到聚合对象的下一个位置
*/
public void next();
/**
* 判断是否已经移动到聚合对象的最后一个位置
* @return true表示已经移动到聚合对象的最后一个位置
* false 表示还没有移动到聚合对象的最后一个位置
*/
public boolean isDone();
/**
* 获取迭代的当前元素
* @return 迭代的当前元素
*/
public Object currentItem();
}
- 定义统一接口来获取聚合对象
/**
* 聚合对象的接口，定义创建相应迭代器对象接口
*
*/
public abstract class Aggregate {
/**
* 工厂方法，创建相应迭代器对象的接口
* @return 相应迭代器对象的接口
*/
public abstract Iterator createIterator();
}
- 定义好了统一的接口，就需要分别实现这个接口，一个采用数组实现
/**
*
* 用来实现访问数组的迭代接口
*/
public class ArrayIteratorImpl implements Iterator{
/**
* 用来存放被迭代的聚合对象
*/
private SalaryManager aggregate = null;
/**
* 用来记录当前被迭代到的位置索引
* -1 表示刚开始的时候，迭代器指向聚合对象第一个元素之前
*/
private int index = -1;
public ArrayIteratorImpl(SalaryManager aggregate) {
this.aggregate = aggregate;
}
@Override
public void first() {
index = 0;
}
@Override
public void next() {
if(index<this.aggregate.size()) {
index = index + 1;
}
}
@Override
public boolean isDone() {
if(index == this.aggregate.size()) {
return true;
}
return false;
}
@Override
public Object currentItem() {
return this.aggregate.get(index);
}
}
- 用List实现的统一接口
/**
* 用来实现访问Collection集合的迭代几口，为了外部统一访问方式
*
*/
public class CollectionIteratorImpl implements Iterator{
/**
* 用来存放被迭代的对象
*/
private PayManager aggregate = null;
private int index = -1;
public CollectionIteratorImpl(PayManager aggregate) {
this.aggregate = aggregate;
}
@Override
public void first() {
index = 0;
}
@Override
public void next() {
if(index < this.aggregate.size()) {
index = index + 1;
}
}
@Override
public boolean isDone() {
if(index == this.aggregate.size()) {
return true;
}
return false;
}
@Override
public Object currentItem() {
return this.aggregate.get(index);
}
}
- 让PayManager和SalaryManager继承Aggregate，提供分别访问它们的访问聚合的接口
/**
* 客户方已有的工资管理对象
*
*/
public class PayManager extends Aggregate{
@Override
public Iterator createIterator() {
return new CollectionIteratorImpl(this);
}
public PayModel get(int index) {
PayModel ret = null;
if(index<this.list.size()) {
ret = this.list.get(index);
}
return ret;
}
public int size() {
return this.list.size();
}
/**
* 聚合对象,使用List管理
*/
private List<PayModel> list = new ArrayList<>();
/**
* 获取工资列表
* @return 工资列表
*/
public List<PayModel> getPayList() {
return list;
}
/**
* 计算工资
*/
public void calcPay() {
//计算工资，把工资信息填充到工资列表中
PayModel pm1 = new PayModel();
pm1.setUserName("张三");
pm1.setPay(3000);
PayModel pm2 = new PayModel();
pm2.setUserName("李四");
pm2.setPay(5000);
list.add(pm1);
list.add(pm2);
}
}
/**
*
* 被客户方收购的公司的工资管理类
*
*/
public class SalaryManager extends Aggregate{
@Override
public Iterator createIterator() {
return new ArrayIteratorImpl(this);
}
public PayModel get(int index) {
PayModel ret = null;
if(index < this.pms.length) {
ret = pms[index];
}
return ret;
}
public int size() {
return this.pms.length;
}
/**
* 使用数组管理
*/
private PayModel[] pms = null;
/**
* 获取工资列表
*
* @return 工资列表
*/
public PayModel[] getPays() {
return pms;
}
/**
* 计算工资
*/
public void calcSalary() {
PayModel pm1 = new PayModel();
pm1.setUserName("王五");
pm1.setPay(3300);
PayModel pm2 = new PayModel();
pm2.setUserName("赵六");
pm2.setPay(4100);
pms = new PayModel[2];
pms[0] = pm1;
pms[1] = pm2;
}
}
- 把通过访问聚合接口来访问聚合对象的功能独立成一个方法，虽然是不同的聚合对象，但是都调用这个方法去访问
public static void test(Iterator it) {
it.first();
while(!it.isDone()) {
Object obj = it.currentItem();
System.out.println(obj);
it.next();
}
}
- 客户端调用
PayManager payManager = new PayManager();
payManager.calcPay();
System.out.println("集团工资列表");
test(payManager.createIterator());
SalaryManager sm = new SalaryManager();
sm.calcSalary();
System.out.println("新收购公司工资列表");
test(sm.createIterator());
如同上面的代码示例，提供一个统一访问聚合对象的接口，通过这个接口就能顺序的访问聚合对象的元素，对于客户端而言，只是面向这个接口在访问，根本不需要知道聚合对象内部的表示方法
