[19/04/29-星期一] GOF23_行为型模式(责任链模式、迭代器模式)

一、行为模式

二、责任链模式(chainOfResponsibility)

【一个请求类】

/*** 请假类
 * 封装请假的基本信息
 */
package cn.sxt.chainOfResponsibility;

public class LeaveRequest {
    private String empName;
    private int leaveDays;
    private String reason;
    
    public LeaveRequest(String empName, int leaveDays, String reason) {
        super();
        this.empName = empName;
        this.leaveDays = leaveDays;
        this.reason = reason;
    }
    
    
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
    public int getLeaveDays() {
        return leaveDays;
    }
    public void setLeaveDays(int leaveDays) {
        this.leaveDays = leaveDays;
    }
    public String getReason() {
        return reason;
    }
    public void setReason(String reason) {
        this.reason = reason;
    }
    

}

 

【领导类】

/***
 * 抽象类 "领导"类
 */
package cn.sxt.chainOfResponsibility;

public abstract class Leader {
    protected String name;//protected子类可以使用的属性
    protected Leader nextLeader;//责任链上的下一个领导
    
    
    public Leader(String name) {
        super();
        this.name = name;
    }
    
    //下一个(上一级)领导的名字
    public void setNextLeader(Leader nextLeader) {
        this.nextLeader = nextLeader;
    }
    //处理请求的核心方法 抽象方法
    public abstract void handleRequest(LeaveRequest request);
    
}

 

【各级领导】

/** "主任" 类
 * 
 */
package cn.sxt.chainOfResponsibility;

public class Director extends Leader {
    

    public Director(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<=3) {
            System.out.println("员工："+request.getEmpName()+",请假天数："+request.getLeaveDays()+",事由："
                    +request.getReason());
            System.out.println("意见：主任_"+this.name+",审批通过！");
            
        }else {//大于3天交给下家-经理处理
            if (this.nextLeader!=null) {
                this.nextLeader.handleRequest(request);
            }
        }    
    }
    
}


/** "经理" 类
 * 
 */
package cn.sxt.chainOfResponsibility;

public class Manager extends Leader {
    

    public Manager(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<=10) {
            System.out.println("员工："+request.getEmpName()+",请假天数："+request.getLeaveDays()+",事由："
                    +request.getReason());
            System.out.println("意见：经理_"+this.name+",审批通过！");
            
        }else {//大于10天交给总经理处理
            if (this.nextLeader!=null) {
                this.nextLeader.handleRequest(request);
            }
        }    
    }
    
}

/** 添加"副总经理" 类,不需要修改已有的代码
 * 
 */
package cn.sxt.chainOfResponsibility;

public class ViceGeneraManager extends Leader {
    

    public ViceGeneraManager(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<=20) {
            System.out.println("员工："+request.getEmpName()+",请假天数："+request.getLeaveDays()+",事由："
                    +request.getReason());
            System.out.println("意见：副总经理_"+this.name+",审批通过！");
            
        }else {//副总经理找经理
            if (this.nextLeader!=null) {
                this.nextLeader.handleRequest(request);
            }
        }    
    }
    
}

/** "总经理" 类
 * 
 */
package cn.sxt.chainOfResponsibility;

public class GeneraManager extends Leader {
    

    public GeneraManager(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<=30) {
            System.out.println("员工："+request.getEmpName()+",请假天数："+request.getLeaveDays()+",事由："
                    +request.getReason());
            System.out.println("意见：总经理_"+this.name+",审批通过！");
            
        }else {//总经理没有下一家
            System.out.println("莫非"+request.getEmpName()+"想辞职,让他交离职申请吧！");
            
        }    
    }
    
}

【客户】

/**
 * 
 */
package cn.sxt.chainOfResponsibility;

public class Client {
    public static void main(String[] args) {
        Leader director=new Director("张主任");
        Leader manager=new Manager("王经理");
        Leader viceLeader=new ViceGeneraManager("赵副总");//增加副总审批
        Leader genLeader=new GeneraManager("李总");
        
        //组织责任链，即领导之间的关系
        director.setNextLeader(manager);
        manager.setNextLeader(viceLeader);
        viceLeader.setNextLeader(genLeader);
        
        //请假操作
        LeaveRequest req1=new LeaveRequest("Tom", 15, "去抓老鼠Jerry");
        director.handleRequest(req1);
        
        LeaveRequest req2=new LeaveRequest("Dog", 31, "去揍Tom猫");
        director.handleRequest(req2);
        
    }
}

 

三、迭代器模式(iterator)

 

【自定义接口】

/**
 * 自定义迭代器接口
 */
package cn.sxt.iterator;

public interface Myiterator {
    void first();//将游标指向第一个元素
    void next();//将游标指向下一个元素
    boolean hasNext();//判断是否存在下一个元素
    
    boolean isFirst();
    boolean isLast();
    
    Object getCurrentObj();//获取当前游标指向的对象

}

/**
 * 自定义聚合类
 */
package cn.sxt.iterator;


import java.util.ArrayList;
import java.util.List;

public class ConcreteMyAggregate {
    private List<Object> list=new ArrayList<Object>();


    public void addObj(Object obj) {//增
        this.list.add(obj);
    }

    public void remove(Object obj) {//删除
        this.list.remove(obj);    
    }


    public List<Object> getList() {
        return list;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }
    
    public Myiterator creaMyiterator() {//获得一个迭代器
        return new ConcreteIterator();
        
    }

    //使用内部类定义迭代器 可以使用外部类的属性
    private class ConcreteIterator implements Myiterator{
        private int cursor;//定义游标，用于遍历时的位置,如果要倒置遍历，则private int cursor=list.size()-1,下边的++变--

        @Override
        public void first() {
            cursor=0;
        }
        
        @Override
        public Object getCurrentObj() {//当前游标指向的对象
            return list.get(cursor);
        }

        @Override
        public boolean hasNext() {
            if (cursor<list.size()) {
                return true;
            }
            return false;
        }

        @Override
        public boolean isFirst() {
            return cursor==0?true:false;
        }

        @Override
        public boolean isLast() {
            return cursor==(list.size()-1)?true:false;
        }
        @Override
        public void next() {
            if (cursor<list.size()) {
                cursor++;
            }            
        }
        
        
            
    } 
}

【测试】

/**
 * 
 */
package cn.sxt.iterator;

public class Client {
    public static void main(String[] args) {
        ConcreteMyAggregate cma=new ConcreteMyAggregate();
        cma.addObj("我");
        cma.addObj("爱");
        cma.addObj("你");
        
        Myiterator iter=cma.creaMyiterator();
        while (iter.hasNext()) {
            System.out.println(iter.getCurrentObj());
            iter.next();            
        }        
    }    

}