Java: State Pattern

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 状态模式 State Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 * javadoc - -encoding Utf-8 -d apidoc Player.java
 * Interface
 * Record
 * Annotation
 * Enum
 *from: https://refactoringguru.cn/design-patterns/state/java/example#example-0--ui-Player-java
 * */
 
 
package com.javapatterns.state.UI;
 
import java.util.ArrayList;
import java.util.List;
import com.javapatterns.state.states.*;
/**
 *
 *
 * */
public class Player {
    private State state;
    private boolean playing = false;
    private List<String> playlist = new ArrayList<>();
    private int currentTrack = 0;
    /**
     *
     *
     * */
    public Player() {
        this.state = new ReadyState(this);
        setPlaying(true);
        for (int i = 1; i <= 12; i++) {
            playlist.add("Track " + i);
        }
    }
    /**
     *
     *
     * */
    public void changeState(State state) {
        this.state = state;
    }
    /**
     *
     *
     * */
    public State getState() {
        return state;
    }
    /**
     *
     *
     * */
    public void setPlaying(boolean playing) {
        this.playing = playing;
    }
    /**
     *
     *
     * */
    public boolean isPlaying() {
        return playing;
    }
    /**
     *
     *
     * */
    public String startPlayback() {
        return "Playing " + playlist.get(currentTrack);
    }
    /**
     *
     *
     * */
    public String nextTrack() {
        currentTrack++;
        if (currentTrack > playlist.size() - 1) {
            currentTrack = 0;
        }
        return "Playing " + playlist.get(currentTrack);
    }
    /**
     *
     *
     * */
    public String previousTrack() {
        currentTrack--;
        if (currentTrack < 0) {
            currentTrack = playlist.size() - 1;
        }
        return "Playing " + playlist.get(currentTrack);
    }
    /**
     *
     *
     * */
    public void setCurrentTrackAfterStop() {
        this.currentTrack = 0;
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 状态模式 State Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 * javadoc - -encoding Utf-8 -d apidoc UI.java
 * Interface
 * Record
 * Annotation
 * Enum
 *
 * */
 
 
 
package com.javapatterns.state.UI;
 
import javax.swing.*;
import java.awt.*;
import com.javapatterns.state.states.*;
/**
 *
 *
 * */
public class UI {
    private Player player;
    private static JTextField textField = new JTextField();
    /**
     *
     *
     * */
    public UI(Player player) {
        this.player = player;
    }
    /**
     *
     *
     * */
    public void init() {
        JFrame frame = new JFrame("Test player");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JPanel context = new JPanel();
        context.setLayout(new BoxLayout(context, BoxLayout.Y_AXIS));
        frame.getContentPane().add(context);
        JPanel buttons = new JPanel(new FlowLayout(FlowLayout.CENTER));
        context.add(textField);
        context.add(buttons);
 
        // Context delegates handling user's input to a state object. Naturally,
        // the outcome will depend on what state is currently active, since all
        // states can handle the input differently.
        JButton play = new JButton("Play");
        play.addActionListener(e -> textField.setText(player.getState().onPlay()));
        JButton stop = new JButton("Stop");
        stop.addActionListener(e -> textField.setText(player.getState().onLock()));
        JButton next = new JButton("Next");
        next.addActionListener(e -> textField.setText(player.getState().onNext()));
        JButton prev = new JButton("Prev");
        prev.addActionListener(e -> textField.setText(player.getState().onPrevious()));
        frame.setVisible(true);
        frame.setSize(300, 100);
        buttons.add(play);
        buttons.add(stop);
        buttons.add(next);
        buttons.add(prev);
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 状态模式 State Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 * javadoc - -encoding Utf-8 -d apidoc State.java
 * Interface
 * Record
 * Annotation
 * Enum
 *
 * */
 
package com.javapatterns.state.states;
 
import com.javapatterns.state.UI.*;
 
 
/**
 * Common interface for all states.
 */
public abstract class State {
    Player player;
 
    /**
     * Context passes itself through the state constructor. This may help a
     * state to fetch some useful context data if needed.
     */
    State(Player player) {
        this.player = player;
    }
    /**
     *
     *
     * */
    public abstract String onLock();
    /**
     *
     *
     * */
    public abstract String onPlay();
    /**
     *
     *
     * */
    public abstract String onNext();
    /**
     *
     *
     * */
    public abstract String onPrevious();
 
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 状态模式 State Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 * javadoc - -encoding Utf-8 -d apidoc LockedState.java
 * Interface
 * Record
 * Annotation
 * Enum
 *
 * */
package com.javapatterns.state.states;
 
import com.javapatterns.state.UI.*;
/**
 * Concrete states provide the special implementation for all interface methods.
 */
public class LockedState extends State {
    /**
     *
     *
     * */
    LockedState(Player player) {
        super(player);
        player.setPlaying(false);
    }
    /**
     *
     *
     * */
    @Override
    public String onLock() {
        if (player.isPlaying()) {
            player.changeState(new ReadyState(player));
            return "Stop playing";
        } else {
            return "Locked...";
        }
    }
    /**
     *
     *
     * */
    @Override
    public String onPlay() {
        player.changeState(new ReadyState(player));
        return "Ready";
    }
    /**
     *
     *
     * */
    @Override
    public String onNext() {
        return "Locked...";
    }
    /**
     *
     *
     * */
    @Override
    public String onPrevious() {
        return "Locked...";
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 状态模式 State Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 * javadoc - -encoding Utf-8 -d apidoc ReadyState.java
 * Interface
 * Record
 * Annotation
 * Enum
 *
 * */
package com.javapatterns.state.states;
 
import com.javapatterns.state.UI.*;
 
 
/**
 * They can also trigger state transitions in the context.
 */
public class ReadyState extends State {
    /**
     *
     *
     * */
    public ReadyState(Player player) {
        super(player);
    }
    /**
     *
     *
     * */
    @Override
    public String onLock() {
        player.changeState(new LockedState(player));
        return "Locked...";
    }
    /**
     *
     *
     * */
    @Override
    public String onPlay() {
        String action = player.startPlayback();
        player.changeState(new PlayingState(player));
        return action;
    }
    /**
     *
     *
     * */
    @Override
    public String onNext() {
        return "Locked...";
    }
    /**
     *
     *
     * */
    @Override
    public String onPrevious() {
        return "Locked...";
    }
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
/**
 * 版权所有 2022 涂聚文有限公司
 * 许可信息查看：
 * 描述：
 * 状态模式 State Pattern
 * 历史版本： JDK 14.02
 * 2022-09-12 创建者 geovindu
 * 2022-09-12 添加 Lambda
 * 2022-09-12 修改：date
 * 接口类
 * 2022-09-12 修改者：Geovin Du
 * 生成API帮助文档的指令：
 * javadoc - -encoding Utf-8 -d apidoc PlayingState.java
 * Interface
 * Record
 * Annotation
 * Enum
 *
 * */
package com.javapatterns.state.states;
 
import com.javapatterns.state.UI.*;
/**
 *
 *
 * */
public class PlayingState extends State {
    /**
     *
     *
     * */
    PlayingState(Player player) {
        super(player);
    }
    /**
     *
     *
     * */
    @Override
    public String onLock() {
        player.changeState(new LockedState(player));
        player.setCurrentTrackAfterStop();
        return "Stop playing";
    }
    /**
     *
     *
     * */
    @Override
    public String onPlay() {
        player.changeState(new ReadyState(player));
        return "Paused...";
    }
    /**
     *
     *
     * */
    @Override
    public String onNext() {
        return player.nextTrack();
    }
    /**
     *
     *
     * */
    @Override
    public String onPrevious() {
        return player.previousTrack();
    }
}

　调用：

?
1
2
3
4
// 状诚模式
     com.javapatterns.state.UI.Player player = new com.javapatterns.state.UI.Player();
      UI ui = new UI(player);
      ui.init();

　　

输出：

 

 

 

 

 

　

 

posted @   ®Geovin Du Dream Park™  阅读(34)  评论(0)  编辑  收藏  举报
相关博文：
·  Java: Command Pattern
·  java: Adapter Pattern
·  Java设计模式-状态模式State
·  状态模式-22
·  23种设计模式之状态模式（State）
阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 零经验选手，Compose 一天开发一款小游戏！
· 一起来玩mcp_server_sqlite，让AI帮你做增删改查！！
< 2025年3月 >
日 一 二 三 四 五 六
23 24 25 26 27 28 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 1 2 3 4 5
点击右上角即可分享
微信分享提示