欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

设计模式之状态

程序员文章站 2022-06-28 17:20:34
一.简介程序设计中有些对象是有状态的对象。当有状态的对象与外部事件产生互动时,其内部状态会发生改变,从而使得其行为也随之发生改变。传统的处理方法是采用if-else 语句判断处理多种状态,状态模式的思想是:把“判断逻辑”提取出来,放到一系列的状态类当中,状态对象在其内部状态发生改变时改变其行为。模式结构:1.环境(Context)角色:它定义了客户感兴趣的接口,维护一个当前状态,并将与状态相关的操作委托给当前状态对象来处理。2.抽象状态(State)角色:定义一个接口,用以封装环境对象中的特定状态...

一.简介

程序设计中有些对象是有状态的对象。当有状态的对象与外部事件产生互动时,其内部状态会发生改变,从而使得其行为也随之发生改变。

传统的处理方法是采用if-else 语句判断处理多种状态,状态模式的思想是:把“判断逻辑”提取出来,放到一系列的状态类当中,状态对象在其内部状态发生改变时改变其行为。

模式结构:
1.环境(Context)角色:它定义了客户感兴趣的接口,维护一个当前状态,并将与状态相关的操作委托给当前状态对象来处理。

2.抽象状态(State)角色:定义一个接口,用以封装环境对象中的特定状态所对应的行为。

3.具体状态(Concrete State)角色:实现抽象状态所对应的行为。

二.实现

线程状态简单转换:新建、就绪、运行、阻塞、停止

package com.vincent;




/**
 * 设计模式
 *
 */
public class App {
    public static void main( String[] args ) throws Exception {
        ThreadContext context = new ThreadContext();
        context.start();
        context.getCpu();
        context.block();
        context.getCpu();
        context.stop();
    }
}



class ThreadContext{
    AbstructThreadState state = new New();


    public AbstructThreadState getState() {
        return state;
    }


    public void setState(AbstructThreadState state) {
        this.state = state;
    }


    public void start(){
        state.start(this);
    }

    public void getCpu(){
        state.getCpu(this);
    }

    public void block(){
        state.block(this);
    }

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



abstract class AbstructThreadState{

    static final int STATUS_NEW = 0;
    static final int STATUS_RUNNABLE = 1;
    static final int STATUS_RUNNING = 2;
    static final int STATUS_BLOCKED = 4;
    static final int STATUS_STOP = 8;

    //运行状态
    int status;

    public void start(ThreadContext context){
        throw new IllegalStateException();
    }

    public void getCpu(ThreadContext context){
        throw new IllegalStateException();
    }

    public void block(ThreadContext context){
        throw new IllegalStateException();
    }

    public void stop(ThreadContext context){
        throw new IllegalStateException();
    }

}


/**
 * 新建状态
 */
class New extends AbstructThreadState{

    @Override
    public void start(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_NEW){
            context.setState(new Runnable());
            context.getState().status = AbstructThreadState.STATUS_RUNNABLE;
            System.out.println("程序处于Runnable状态");
        }
        else{
            throw new IllegalStateException();
        }

    }
}


/**
 * 就绪状态
 */
class Runnable extends AbstructThreadState{
    @Override
    public void getCpu(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_RUNNABLE){
            context.setState(new Running());
            context.getState().status = AbstructThreadState.STATUS_RUNNING;
            System.out.println("程序处于running状态");
        }
        else{
            throw new IllegalStateException();
        }
    }
}


/**
 * 运行状态
 */
class Running extends AbstructThreadState{

    @Override
    public void block(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_RUNNING){
            context.setState(new Block());
            context.getState().status = AbstructThreadState.STATUS_BLOCKED;
            System.out.println("程序处于blocked状态");
        }
        else{
            throw new IllegalStateException();
        }
    }

    @Override
    public void stop(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_RUNNING){
            context.setState(new Stop());
            context.getState().status = AbstructThreadState.STATUS_STOP;
            System.out.println("程序处于stop状态");
        }
        else{
            throw new IllegalStateException();
        }
    }
}

/**
 * 阻塞状态
 */
class Block extends AbstructThreadState{

    @Override
    public void getCpu(ThreadContext context) {
        if(this.status == AbstructThreadState.STATUS_BLOCKED){
            context.setState(new Running());
            context.getState().status = AbstructThreadState.STATUS_RUNNING;
            System.out.println("程序处于running状态");
        }
        else{
            throw new IllegalStateException();
        }
    }
}


/**
 * 停止状态
 */
class Stop extends AbstructThreadState{


}

效果:

设计模式之状态

三.总结

1.状态模式把对象状态变化操作委托给状态类操作

本文地址:https://blog.csdn.net/Zllvincent/article/details/107411515

相关标签: 设计模式