list的总结

目录

一、责任链模式

1.1概述

1.2结构

1.3实现

1.4 优缺点

1.5应用场景

1.6源码解析

二、状态模式

2.1概述

2.2结构

2.3实现

2.4优缺点

2.5应用场景 

三、责任链模式实验

任务描述

实现方式

编程要求

测试说明

四、状态模式实验

任务描述

实现方式

编程要求

测试说明

一、责任链模式

1.1概述

1.2结构

1.3实现

现需要开发一个请假流程控制系统。请假一天以下的假只需要小组长同意即可；请假1天到3天的假还需要部门经理同意；请求3天到7天还需要总经理同意才行。

请求（Request）

package com.yanyu.responsibilily;

public class LeaveRequest {
    private String name;//姓名
    private int num;//请假天数
    private String content;//请假内容
    public LeaveRequest(String name, int num, String content) {
        this.name = name;
        this.num = num;
        this.content = content;
    }
    public String getName() {
        return name;
    }
    public int getNum() {
        return num;
    }
    public String getContent() {
        return content;
    }
}

抽象处理者（Handler）角色

package com.yanyu.responsibilily;

//处理者抽象类
public abstract class Handler {
    protected final static int NUM_ONE = 1;
    protected final static int NUM_THREE = 3;
    protected final static int NUM_SEVEN = 7;

    //该领导处理的请假天数区间
    private int numStart;
    private int numEnd;

    //领导上面还有领导
    private Handler nextHandler;

    //设置请假天数范围 上不封顶
    public Handler(int numStart) {
        this.numStart = numStart;
    }

    //设置请假天数范围
    public Handler(int numStart, int numEnd) {
        this.numStart = numStart;
        this.numEnd = numEnd;
    }

    //设置上级领导
    public void setNextHandler(Handler nextHandler){
        this.nextHandler = nextHandler;
    }
    //各级领导处理请假条方法
    protected abstract void handleLeave(LeaveRequest leave);
    //提交请假条
    public final void submit(LeaveRequest leave){
        if(0 == this.numStart){
            return;
        }

        //如果请假天数达到该领导者的处理要求
        if(leave.getNum() >= this.numStart){
            this.handleLeave(leave);

            //如果还有上级 并且请假天数超过了当前领导的处理范围
            if(null != this.nextHandler && leave.getNum() > numEnd){
                this.nextHandler.submit(leave);//继续提交
            } else {
                System.out.println("流程结束");
            }
        }
    }

}

具体处理者（Concrete Handler）角色

package com.yanyu.responsibilily;

//小组长
public class GroupLeader extends Handler {
    public GroupLeader() {
        //小组长处理1-3天的请假
        super(Handler.NUM_ONE, Handler.NUM_THREE);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("小组长审批：同意。");
    }
}

package com.yanyu.responsibilily;

//部门经理
public class Manager extends Handler {
    public Manager() {
        //部门经理处理3-7天的请假
        super(Handler.NUM_THREE, Handler.NUM_SEVEN);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("部门经理审批：同意。");
    }
}

package com.yanyu.responsibilily;

//总经理
public class GeneralManager extends Handler {
    public GeneralManager() {
        //部门经理处理7天以上的请假
        super(Handler.NUM_SEVEN);
    }

    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("总经理审批：同意。");
    }
}

客户端类

package com.yanyu.responsibilily;

public class Client {
    public static void main(String[] args) {
        //请假条来一张
        LeaveRequest leave = new LeaveRequest("小花",5,"身体不适");

        //各位领导
        GroupLeader groupLeader = new GroupLeader();
        Manager manager = new Manager();
        GeneralManager generalManager = new GeneralManager();

        groupLeader.setNextHandler(manager);//小组长的领导是部门经理
        manager.setNextHandler(generalManager);//部门经理的领导是总经理
        //之所以在这里设置上级领导，是因为可以根据实际需求来更改设置，如果实战中上级领导人都是固定的，则可以移到领导实现类中。
        //提交申请
        groupLeader.submit(leave);
    }
}

1.4 优缺点

1.5应用场景

1.6源码解析

在javaWeb应用开发中，FilterChain是职责链（过滤器）模式的典型应用，以下是Filter的模拟实现分析:

模拟web请求Request以及web响应Response

public interface Request{
 
}
​
public interface Response{
 
}

模拟web过滤器Filter

 public interface Filter {
    public void doFilter(Request req,Response res,FilterChain c);
 }

模拟实现具体过滤器

public class FirstFilter implements Filter {
    @Override
    public void doFilter(Request request, Response response, FilterChain chain) {
​
        System.out.println("过滤器1 前置处理");
​
        // 先执行所有request再倒序执行所有response
        chain.doFilter(request, response);
​
        System.out.println("过滤器1 后置处理");
    }
}
​
public class SecondFilter  implements Filter {
    @Override
    public void doFilter(Request request, Response response, FilterChain chain) {
​
        System.out.println("过滤器2 前置处理");
​
        // 先执行所有request再倒序执行所有response
        chain.doFilter(request, response);
​
        System.out.println("过滤器2 后置处理");
    }
}

模拟实现过滤器链FilterChain

public class FilterChain {
​
    private List<Filter> filters = new ArrayList<Filter>();
​
    private int index = 0;
​
    // 链式调用
    public FilterChain addFilter(Filter filter) {
        this.filters.add(filter);
        return this;
    }
​
    public void doFilter(Request request, Response response) {
        if (index == filters.size()) {
            return;
        }
        Filter filter = filters.get(index);
        index++;
        filter.doFilter(request, response, this);
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        Request  req = null;
        Response res = null ;
​
        FilterChain filterChain = new FilterChain();
        filterChain.addFilter(new FirstFilter()).addFilter(new SecondFilter());
        filterChain.doFilter(req,res);
    }
}

二、状态模式

2.1概述

 【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。

2.2结构

2.3实现

环境（Context）角色

package com.yanyu.State;

//环境角色
public class Context {
    //定义出所有的电梯状态
    public final static OpenningState openningState = new OpenningState();//开门状态，这时候电梯只能关闭
    public final static ClosingState closeingState = new ClosingState();//关闭状态，这时候电梯可以运行、停止和开门
    public final static RunningState runningState = new RunningState();//运行状态，这时候电梯只能停止
    public final static StoppingState stoppingState = new StoppingState();//停止状态，这时候电梯可以开门、运行

    //定义一个当前电梯状态
    private LiftState liftState;

    public LiftState getLiftState() {
        return this.liftState;
    }

    public void setLiftState(LiftState liftState) {
        //当前环境改变
        this.liftState = liftState;
        //把当前的环境通知到各个实现类中
        this.liftState.setContext(this);
    }

    public void open() {
        this.liftState.open();
    }

    public void close() {
        this.liftState.close();
    }

    public void run() {
        this.liftState.run();
    }

    public void stop() {
        this.liftState.stop();
    }
}

抽象状态（State）角色

package com.yanyu.State;

//抽象状态类
public abstract class LiftState {
    //定义一个环境角色，也就是封装状态的变化引起的功能变化
    protected Context context;

    public void setContext(Context context) {
        this.context = context;
    }

    //电梯开门动作
    public abstract void open();

    //电梯关门动作
    public abstract void close();

    //电梯运行动作
    public abstract void run();

    //电梯停止动作
    public abstract void stop();
}

具体状态（Concrete State）角色

package com.yanyu.State;

//开启状态
public class OpenningState extends LiftState {

    //开启当然可以关闭了，我就想测试一下电梯门开关功能
    @Override
    public void open() {
        System.out.println("电梯门开启...");
    }

    //关闭电梯门
    @Override
    public void close() {
        //状态修改
        super.context.setLiftState(Context.closeingState);
        //动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().close();
    }

    //电梯门不能开着就跑，这里什么也不做
    @Override
    public void run() {
        //do nothing
    }

    //开门状态已经是停止的了
    @Override
    public void stop() {
        //do nothing
    }
}

package com.yanyu.State;

// 关闭状态类，继承自电梯状态类
public class ClosingState extends LiftState {
    @Override
    // 电梯门关闭，这是关闭状态要实现的动作
    public void close() {
        System.out.println("电梯门关闭...");
    }

    // 电梯门关了再打开，逗你玩呢，那这个允许呀
    @Override
    public void open() {
        // 设置电梯状态为开启状态
        super.context.setLiftState(Context.openningState);
        // 调用开启状态的open方法
        super.context.open();
    }

    // 电梯门关了就跑，这是再正常不过了
    @Override
    public void run() {
        // 设置电梯状态为运行状态
        super.context.setLiftState(Context.runningState);
        // 调用运行状态的run方法
        super.context.run();
    }

    // 电梯门关着，我就不按楼层
    @Override
    public void stop() {
        // 设置电梯状态为停止状态
        super.context.setLiftState(Context.stoppingState);
        // 调用停止状态的stop方法
        super.context.stop();
    }
}

package com.yanyu.State;

// 运行状态类，继承自电梯状态类
public class RunningState extends LiftState {

    // 运行的时候开电梯门？你疯了！电梯不会给你开的
    @Override
    public void open() {
        // do nothing
    }

    // 电梯门关闭？这是肯定了
    @Override
    public void close() {//虽然可以关门，但这个动作不归我执行
        // do nothing
    }

    // 这是在运行状态下要实现的方法
    @Override
    public void run() {
        System.out.println("电梯正在运行...");
    }

    // 这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
    @Override
    public void stop() {
        // 设置电梯状态为停止状态
        super.context.setLiftState(Context.stoppingState);
        // 调用停止状态的stop方法
        super.context.stop();
    }
}

package com.yanyu.State;

// 停止状态类，继承自电梯状态类
public class StoppingState extends LiftState {

    // 停止状态，开门，那是要的！
    @Override
    public void open() {
        // 状态修改为开启状态
        super.context.setLiftState(Context.openningState);
        // 动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().open();
    }

    @Override
    public void close() {//虽然可以关门，但这个动作不归我执行
        // 状态修改为关闭状态
        super.context.setLiftState(Context.closeingState);
        // 动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().close();
    }

    // 停止状态再跑起来，正常的很
    @Override
    public void run() {
        // 状态修改为运行状态
        super.context.setLiftState(Context.runningState);
        // 动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
        super.context.getLiftState().run();
    }

    // 停止状态是怎么发生的呢？当然是停止方法执行了
    @Override
    public void stop() {
        System.out.println("电梯停止了...");
    }
}

客户端类

//测试类
public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.setLiftState(new ClosingState());
​
        context.open();
        context.close();
        context.run();
        context.stop();
    }
}

2.4优缺点

2.5应用场景 

三、责任链模式实验

请求

package step1;

import java.util.HashMap;
import java.util.Map;

// 产品类，包含宽度和高度属性
public class Product {
    private Middleware middleware; // 中间件对象
    private int width; // 宽度
    private int height; // 高度

    // 构造方法，初始化宽度和高度
    public Product(int width,int height) {
        this.width =width;
        this.height = height;
    }

    // 设置中间件对象
    public void setMiddleware(Middleware middleware) {
        this.middleware = middleware;
    }

    // 获取高度
    public int getHeight() {
        return height;
    }

    // 获取宽度
    public int getWidth() {
        return width;
    }

    // 执行产品检验，调用中间件的check方法进行检验
    public boolean doProcess() {
        if (middleware.check(width,height)) {
            System.out.println("产品最终检验合格！");
            return true;
        }
        System.out.println("产品最终检验不合格！");
        return false;
    }
}

抽象处理者（Handler）角色

package step1;

public abstract class Middleware {
    private Middleware next;

    /* Builds chains of middleware objects.*/
    public static Middleware link(Middleware first, Middleware... chain) {
        Middleware head = first;
        for (Middleware nextInChain: chain) {
            head.next = nextInChain;
            head = nextInChain;
        }
        return first;
    }

    /**
     * 在具体的节点中去实现check.
     */
    public abstract boolean check(int width, int height);

    /**
     * Runs check on the next object in chain or ends traversing if we're in
     * last object in chain.
     */
    protected boolean checkNext(int width, int height) {
        if (next == null) {
            return true;
        }
        return next.check(width, height);
    }
}

具体处理者（Handler）角色

package step1;

public class HeightCheckMiddleware extends Middleware{

    public boolean check(int width, int height) {
        /*产品高度检验通过 产品高度未检验通过*/
        /********** Begin *********/
        if (height > 10 && height < 50) {
            System.out.println("产品高度检验通过");
            return checkNext(width, height);
        } else {
            System.out.println("产品高度未检验通过");
            return false;
        }


        

        /********** End *********/
    }
}

package step1;

public class WidthCheckMiddleware extends Middleware {
    public boolean check(int width, int height) {
        /*产品宽度未检验通过   产品宽度检验通过*/
        /********** Begin *********/
         if (width > 50 && width < 100) {
            System.out.println("产品宽度检验通过");
            return checkNext(width, height);
        } else {
            System.out.println("产品宽度未检验通过");
            return false;
        }


        /********** End *********/
    }
}

客户端类

package step1;

import java.io.IOException;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) throws IOException {
        // 创建一个扫描器对象，用于读取用户输入的宽度和高度
        Scanner scanner = new Scanner(System.in);
        int width = scanner.nextInt(); // 读取用户输入的宽度
        int height = scanner.nextInt(); // 读取用户输入的高度
        Product product = new Product(width,height); // 创建一个产品对象，传入宽度和高度

        // 构建检测链
        Middleware middleware = Middleware.link(
                new WidthCheckMiddleware(), // 创建一个宽度检查中间件对象
                new HeightCheckMiddleware() // 创建一个高度检查中间件对象
        );
        // 将检测链的首节点设置为产品对象的中间件
        product.setMiddleware(middleware);
        // 启动产品对象的检测链
        product.doProcess();
    }
}

四、状态模式实验

环境（Context）角色

package step1;

public class clubAccount {

    private String name; // 姓名
    private AbstractState state; // 当前状态

    public clubAccount(String name) {
        this.name = name;
        // 初始化账户状态为普通状态
        this.state = new CommonState(this);
        System.out.println(this.name + "注册成功！");
    }

    // 设置账户状态
    public void setState(AbstractState state) {
        this.state = state;
    }

    // 消费
    public void Consume(double money) {
        /********** Begin *********/
        // 调用当前状态的消费方法
        state.Consume(money);
        /********** End *********/
    }
}

 抽象状态（State）角色

package step1;

public abstract class AbstractState {
    protected  clubAccount account;//账户
    protected double discount;//折扣比例
    protected int userPoints;//积分
    protected String stateName;//状态名


    
    public void Consume(double money)
    {
        /********** Begin *********/
       
         userPoints += (int)(money*discount);
         checkState();
        /********** End *********/
        ///现金消费
        System.out.println(stateName+"本次消费金额:"+money+",折扣后:"+String.format("%.1f",money*discount)+",当前积分:"+userPoints);
    }
    ///若有积分抵现金或领取礼物则需要修改checkState原型，请自由扩展积分消费函数
    public abstract void checkState();
}

 具体状态（State）角色

package step1;

// 定义一个名为CommonState的类，继承自AbstractState类
public class CommonState extends AbstractState {
    // 构造方法1：接收一个AbstractState类型的参数state
    public CommonState(AbstractState state) {
        // 将传入的state对象的userPoints属性赋值给当前对象的userPoints属性
        this.userPoints = state.userPoints;
        // 设置当前对象的状态名称为"普通会员"
        this.stateName = "普通会员";
        // 将传入的state对象的account属性赋值给当前对象的account属性
        this.account = state.account;
        // 设置当前对象的折扣为1
        this.discount = 1;
    }

    // 构造方法2：接收一个clubAccount类型的参数account
    public CommonState(clubAccount account) {
        // 将传入的account对象的account属性赋值给当前对象的account属性
        this.account = account;
        // 设置当前对象的用户积分为0
        this.userPoints = 0;
        // 设置当前对象的状态名称为"普通会员"
        this.stateName = "普通会员";
        // 设置当前对象的折扣为1
        this.discount = 1;
    }

    // 重写checkState方法
    @Override
    public void checkState() {
        /********** Begin *********/
        // 如果用户积分大于等于2000，将账户状态设置为VIPState
        if (userPoints >= 2000) {
            account.setState(new VIPState(this));
        }
        // 如果用户积分大于等于500，将账户状态设置为GoldState
        else if (userPoints >= 500) {
            account.setState(new GoldState(this));
        }
        /********** End *********/
    }
}

package step1;

public class GoldState extends AbstractState{
    public GoldState(AbstractState state)
    {
        this.userPoints=state.userPoints;
        this.stateName="黄金会员";
        this.account= state.account;
        this.discount=0.95;
    }
    @Override
    public void checkState() {
        /********** Begin *********/
        if (userPoints >= 2000) {
            account.setState(new VIPState(this));
        }


        /********** End *********/
    }
}

package step1;

public class VIPState extends AbstractState{
    public VIPState(AbstractState state)
    {
        this.userPoints=state.userPoints;
        this.stateName="VIP会员";
        this.account= state.account;
        this.discount=0.85;
    }
    @Override
    public void checkState() {

    }
}

客户端类 

package step1;

import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        // 创建一个扫描器对象，用于读取用户输入
        Scanner scanner = new Scanner(System.in);
        
        // 读取用户输入的姓名
        String name = scanner.next();
        
        // 根据姓名创建一个俱乐部账户对象
        clubAccount account = new clubAccount(name);
        
        // 读取用户输入的消费次数
        int n = scanner.nextInt();
        
        // 定义一个变量用于存储每次消费的金额
        float money;
        
        // 循环n次，每次读取用户输入的消费金额并调用Consume方法进行消费操作
        for (int i = 0; i < n; i++) {
            money = scanner.nextFloat();
            account.Consume(money);
        }
    }
}