State trong Java là mẫu thiết kế dùng để cho object thay đổi hành vi khi trạng thái bên trong của nó thay đổi.
Nói rất dễ hiểu:
State = cùng một object, nhưng ở trạng thái khác nhau thì hành xử khác nhau.
- 1. Ý tưởng cốt lõi
- 2. Hình dung đời thường
- 3. Khi nào cần State
- 4. Vấn đề nếu không dùng State
- 5. Cấu trúc của State
- 6. Ví dụ cơ bản nhất: Traffic Light
- 7. Điều gì đang xảy ra
- 8. Điểm quan trọng nhất của State
- 9. Ví dụ thực tế hơn: Order State
- 10. Điều hay ở ví dụ này
- 11. State khác Strategy thế nào
- 12. Ví dụ phân biệt nhanh
- 13. State khác if/else như thế nào
- 14. Lợi ích của State
- 15. Nhược điểm
- 16. Khi nào nên dùng State
- 17. Khi nào không nên dùng
- 18. Ví dụ rất thực tế: Media Player
- 19. State có thể tự chuyển trạng thái
- 20. Có nên dùng Singleton cho state không
- 21. Sai lầm người mới hay gặp
- 22. Mẫu code ngắn gọn dễ nhớ
- 23. Công thức nhớ 1 câu
- 24. Chốt cực ngắn
- 25. Bảng nhớ nhanh đến hiện tại
- 26. Kết luận
flowchart TD
A[Object / Context] --> B[Đang giữ state hiện tại]
B --> C[Nhận request từ client]
C --> D[Ủy quyền hành vi cho state hiện tại]
D --> E[ConcreteState xử lý]
E --> F[Có thể đổi sang state khác]
F --> A
Giả sử bạn có một máy bán hàng.
Máy có thể ở các trạng thái như:
- chưa có tiền
- đã có tiền
- đang giao hàng
- hết hàng
Khi người dùng bấm nút selectProduct():
- nếu chưa có tiền → báo lỗi
- nếu đã có tiền → cho chọn hàng
- nếu hết hàng → báo hết hàng
Tức là:
- cùng một method
- nhưng hành vi khác nhau tùy trạng thái
Đó chính là State.
Ví dụ bạn có một chiếc đèn giao thông.
Nó có các trạng thái:
- đỏ
- vàng
- xanh
Cùng một sự kiện “đến chu kỳ tiếp theo”, nhưng kết quả khác nhau tùy trạng thái hiện tại:
- đỏ → xanh
- xanh → vàng
- vàng → đỏ
Đèn giao thông là một object.
Nhưng hành vi của nó phụ thuộc vào state hiện tại.
stateDiagram-v2
[*] --> Red
Red --> Green: next()
Green --> Yellow: next()
Yellow --> Red: next()
Dùng khi:
- object có nhiều trạng thái rõ ràng
- hành vi thay đổi mạnh theo trạng thái
- code đang đầy
if/elsehoặcswitchdựa trên state - state có thể chuyển đổi qua lại theo quy tắc
Ví dụ rất hợp:
- đơn hàng
- máy bán hàng
- media player
- tài khoản người dùng
- document workflow
- game character state
- TCP connection
- traffic light
Không dùng State, code thường kiểu này:
public class Order {
private String status;
public void next() {
if (status.equals("NEW")) {
System.out.println("Move to PAID");
status = "PAID";
} else if (status.equals("PAID")) {
System.out.println("Move to SHIPPED");
status = "SHIPPED";
} else if (status.equals("SHIPPED")) {
System.out.println("Move to DELIVERED");
status = "DELIVERED";
} else {
System.out.println("No next state");
}
}
}Vấn đề:
- nhiều
if/else - thêm trạng thái mới phải sửa code cũ
- logic chuyển trạng thái và hành vi bị dồn vào một chỗ
- class phình to, khó bảo trì
State pattern giúp tách từng trạng thái ra thành class riêng.
flowchart LR
A[Không dùng State] --> A1[if else / switch lớn]
A --> A2[logic dồn vào 1 class]
A --> A3[khó mở rộng]
B[Dùng State] --> B1[mỗi state là 1 class]
B --> B2[ủy quyền hành vi]
B --> B3[dễ mở rộng hơn]
State pattern thường có 3 phần chính:
Interface chung cho các trạng thái.
Các trạng thái cụ thể.
Object chính, giữ state hiện tại và ủy quyền hành vi cho state đó.
classDiagram
class Context {
-State state
+setState(State)
+request()
}
class State {
<<interface>>
+handle(Context)
}
class ConcreteStateA {
+handle(Context)
}
class ConcreteStateB {
+handle(Context)
}
Context --> State : delegates to
State <|.. ConcreteStateA
State <|.. ConcreteStateB
public interface TrafficLightState {
void next(TrafficLight context);
String getColor();
}public class RedState implements TrafficLightState {
@Override
public void next(TrafficLight context) {
System.out.println("Red -> Green");
context.setState(new GreenState());
}
@Override
public String getColor() {
return "Red";
}
}public class GreenState implements TrafficLightState {
@Override
public void next(TrafficLight context) {
System.out.println("Green -> Yellow");
context.setState(new YellowState());
}
@Override
public String getColor() {
return "Green";
}
}public class YellowState implements TrafficLightState {
@Override
public void next(TrafficLight context) {
System.out.println("Yellow -> Red");
context.setState(new RedState());
}
@Override
public String getColor() {
return "Yellow";
}
}public class TrafficLight {
private TrafficLightState state;
public TrafficLight() {
this.state = new RedState();
}
public void setState(TrafficLightState state) {
this.state = state;
}
public void change() {
state.next(this);
}
public void show() {
System.out.println("Current color: " + state.getColor());
}
}public class Main {
public static void main(String[] args) {
TrafficLight light = new TrafficLight();
light.show();
light.change();
light.show();
light.change();
light.show();
light.change();
light.show();
}
}sequenceDiagram
participant Client
participant TrafficLight
participant State
Client->>TrafficLight: change()
TrafficLight->>State: next(this)
State-->>TrafficLight: setState(new NextState)
Client->>TrafficLight: show()
TrafficLight-->>Client: Current color
TrafficLight không tự viết if state == RED, if state == GREEN...
Nó chỉ gọi:
state.next(this);Mỗi state tự biết:
- nó làm gì
- state tiếp theo là gì
Đây là tinh thần của State:
đẩy logic hành vi và chuyển trạng thái vào từng state cụ thể.
Một object ở trạng thái khác nhau thì:
- method giống nhau
- nhưng kết quả khác nhau
Ví dụ cùng là pressPlay() trên media player:
- nếu đang
Stopped→ phát nhạc - nếu đang
Playing→ tạm dừng - nếu đang
Paused→ tiếp tục phát
Đây là ví dụ rất hay trong backend.
Đơn hàng có thể ở các trạng thái:
NEWPAIDSHIPPEDDELIVEREDCANCELLED
Mỗi trạng thái sẽ quyết định:
- có cho thanh toán không
- có cho gửi hàng không
- có cho hủy không
stateDiagram-v2
[*] --> NEW
NEW --> PAID: pay()
NEW --> CANCELLED: cancel()
PAID --> SHIPPED: ship()
PAID --> CANCELLED: cancel()
SHIPPED --> SHIPPED: ship() / already shipped
SHIPPED --> SHIPPED: pay() / cannot pay
SHIPPED --> SHIPPED: cancel() / cannot cancel
CANCELLED --> CANCELLED: pay()/ship()/cancel() invalid
public interface OrderState {
void pay(Order context);
void ship(Order context);
void cancel(Order context);
String getStatus();
}public class NewOrderState implements OrderState {
@Override
public void pay(Order context) {
System.out.println("Payment successful. Order moves to PAID");
context.setState(new PaidOrderState());
}
@Override
public void ship(Order context) {
System.out.println("Cannot ship. Order is not paid yet");
}
@Override
public void cancel(Order context) {
System.out.println("Order cancelled");
context.setState(new CancelledOrderState());
}
@Override
public String getStatus() {
return "NEW";
}
}public class PaidOrderState implements OrderState {
@Override
public void pay(Order context) {
System.out.println("Order already paid");
}
@Override
public void ship(Order context) {
System.out.println("Order shipped");
context.setState(new ShippedOrderState());
}
@Override
public void cancel(Order context) {
System.out.println("Order cancelled after payment");
context.setState(new CancelledOrderState());
}
@Override
public String getStatus() {
return "PAID";
}
}public class ShippedOrderState implements OrderState {
@Override
public void pay(Order context) {
System.out.println("Order already shipped, cannot pay");
}
@Override
public void ship(Order context) {
System.out.println("Order already shipped");
}
@Override
public void cancel(Order context) {
System.out.println("Cannot cancel shipped order");
}
@Override
public String getStatus() {
return "SHIPPED";
}
}public class CancelledOrderState implements OrderState {
@Override
public void pay(Order context) {
System.out.println("Cancelled order cannot be paid");
}
@Override
public void ship(Order context) {
System.out.println("Cancelled order cannot be shipped");
}
@Override
public void cancel(Order context) {
System.out.println("Order already cancelled");
}
@Override
public String getStatus() {
return "CANCELLED";
}
}public class Order {
private OrderState state;
public Order() {
this.state = new NewOrderState();
}
public void setState(OrderState state) {
this.state = state;
}
public void pay() {
state.pay(this);
}
public void ship() {
state.ship(this);
}
public void cancel() {
state.cancel(this);
}
public void showStatus() {
System.out.println("Current status: " + state.getStatus());
}
}public class Main {
public static void main(String[] args) {
Order order = new Order();
order.showStatus();
order.ship();
order.pay();
order.showStatus();
order.ship();
order.showStatus();
order.cancel();
}
}Order không cần viết:
if state == NEWif state == PAIDif state == SHIPPED
Nó chỉ ủy quyền:
state.pay(this);
state.ship(this);
state.cancel(this);Từng state chịu trách nhiệm cho hành vi hợp lệ của nó.
Đây là cặp dễ nhầm nhất.
Về cấu trúc code, chúng rất giống nhau:
- đều có interface
- đều có các class cụ thể
- đều có context giữ một object hành vi
Nhưng mục đích khác nhau.
Mục tiêu:
- chọn một cách làm
Ví dụ:
- thanh toán bằng thẻ hay PayPal
- sắp xếp bằng quicksort hay mergesort
Context thường không tự đổi strategy trừ khi client đổi.
Mục tiêu:
- object thay đổi hành vi theo trạng thái nội bộ
Ví dụ:
- order từ NEW sang PAID
- traffic light từ RED sang GREEN
Context hoặc state có thể tự chuyển state.
- Strategy = “chọn cách làm”
- State = “đang ở trạng thái nào thì cư xử theo kiểu đó”
flowchart TB
S[Strategy] --> S1[Chọn 1 cách làm]
S --> S2[Thường do client chọn]
S --> S3[Ít nhấn mạnh transition]
T[State] --> T1[Hành vi đổi theo trạng thái]
T --> T2[Context / state có thể tự đổi]
T --> T3[Nhấn mạnh transition]
Bạn chọn:
- đi xe máy
- đi ô tô
- đi xe buýt
Đây là lựa chọn cách làm.
Bạn là:
- đang ngủ
- đang làm việc
- đang nghỉ
Cùng một người, nhưng hành vi tùy trạng thái.
Bạn vẫn có thể làm bằng if/else, nhưng State có lợi khi:
- số trạng thái nhiều
- mỗi trạng thái có nhiều hành vi
- logic chuyển trạng thái phức tạp
- muốn mở rộng thêm state mới
Lúc đó State giúp:
- tách logic rõ ràng
- tránh một class khổng lồ đầy điều kiện
Mỗi state là một class riêng.
Thêm state mới ít ảnh hưởng code cũ hơn.
Logic của từng trạng thái nằm đúng chỗ của nó.
Rất tự nhiên.
Mỗi state thường là một class.
Nếu chỉ có 2 trạng thái đơn giản, if/else có thể đủ.
Nhất là khi state chuyển qua lại phức tạp.
Nên dùng khi:
- object có nhiều trạng thái rõ ràng
- hành vi thay đổi theo trạng thái
- transition giữa các state là phần quan trọng của bài toán
- code hiện tại đang đầy điều kiện theo state
Ví dụ:
- workflow đơn hàng
- trạng thái ticket
- media player
- TCP connection
- workflow document
- game AI state
- vending machine
Không nên dùng khi:
- chỉ có 1-2 trạng thái đơn giản
- logic cực nhỏ
- việc tạo nhiều class làm code dài hơn giá trị mang lại
Trình phát nhạc có thể ở:
- Stopped
- Playing
- Paused
Cùng method pressPlay() nhưng:
Stopped→ bắt đầu phátPlaying→ tạm dừngPaused→ tiếp tục phát
Đây là bài toán State điển hình.
stateDiagram-v2
[*] --> STOPPED
STOPPED --> PLAYING: pressPlay()
PLAYING --> PAUSED: pressPlay()
PAUSED --> PLAYING: pressPlay()
public interface PlayerState {
void pressPlay(MediaPlayer player);
String getName();
}public class PlayingState implements PlayerState {
@Override
public void pressPlay(MediaPlayer player) {
System.out.println("Pause music");
player.setState(new PausedState());
}
@Override
public String getName() {
return "PLAYING";
}
}public class PausedState implements PlayerState {
@Override
public void pressPlay(MediaPlayer player) {
System.out.println("Resume music");
player.setState(new PlayingState());
}
@Override
public String getName() {
return "PAUSED";
}
}public class StoppedState implements PlayerState {
@Override
public void pressPlay(MediaPlayer player) {
System.out.println("Start music");
player.setState(new PlayingState());
}
@Override
public String getName() {
return "STOPPED";
}
}public class MediaPlayer {
private PlayerState state = new StoppedState();
public void setState(PlayerState state) {
this.state = state;
}
public void pressPlay() {
state.pressPlay(this);
}
public void showState() {
System.out.println("Current state: " + state.getName());
}
}Điểm rất đặc trưng của State là:
context.setState(new AnotherState());Tức là state hiện tại có thể quyết định:
- sau hành động này thì context nên chuyển sang state nào
Đây là điều Strategy thường không nhấn mạnh.
Nhiều state là stateless, ví dụ:
RedStateGreenStatePausedState
Nếu state không chứa dữ liệu riêng, bạn có thể tái sử dụng một instance duy nhất cho mỗi state để tiết kiệm object.
Ví dụ ý tưởng:
public class RedState implements TrafficLightState {
public static final RedState INSTANCE = new RedState();
private RedState() {}
}Đây là tối ưu thêm, không bắt buộc cho người mới học.
Nhớ rằng State gắn với trạng thái nội bộ và transition.
Như vậy mất ý nghĩa của pattern.
State nên chứa logic thuộc về trạng thái đó, nhưng không nên ôm mọi thứ linh tinh.
Dẫn đến luồng workflow khó hiểu.
interface State {
void handle(Context context);
}
class StateA implements State {
@Override
public void handle(Context context) {
System.out.println("Handling in State A");
context.setState(new StateB());
}
}
class StateB implements State {
@Override
public void handle(Context context) {
System.out.println("Handling in State B");
context.setState(new StateA());
}
}
class Context {
private State state;
public Context(State state) {
this.state = state;
}
public void setState(State state) {
this.state = state;
}
public void request() {
state.handle(this);
}
}
public class Main {
public static void main(String[] args) {
Context context = new Context(new StateA());
context.request();
context.request();
context.request();
}
}stateDiagram-v2
[*] --> StateA
StateA --> StateB: handle()
StateB --> StateA: handle()
State cho phép một object thay đổi hành vi khi trạng thái bên trong của nó thay đổi.
- Strategy: một việc, nhiều cách làm
- State: một object, nhiều trạng thái hành vi
- Observer: một thay đổi, nhiều nơi được báo
| Mẫu | Ý tưởng chính |
|---|---|
| Singleton | Chỉ có 1 object duy nhất |
| Factory Method | Tạo 1 loại object linh hoạt |
| Abstract Factory | Tạo cả họ object liên quan |
| Builder | Tạo object từng bước |
| Prototype | Sao chép object từ mẫu có sẵn |
| Adapter | Chuyển interface không tương thích |
| Bridge | Tách abstraction và implementation |
| Decorator | Bọc thêm chức năng cho object |
| Facade | Đơn giản hóa hệ thống phức tạp |
| Proxy | Đại diện và kiểm soát truy cập |
| Composite | Biểu diễn cấu trúc cây |
| Flyweight | Chia sẻ trạng thái chung để tiết kiệm bộ nhớ |
| Observer | Một thay đổi, nhiều nơi được thông báo |
| Strategy | Một việc, nhiều cách làm |
| State | Một object, nhiều trạng thái hành vi |
State trong Java rất hữu ích khi object của bạn có nhiều trạng thái và hành vi thay đổi theo từng trạng thái đó. Nó giúp:
- code sạch hơn
- tách logic theo state rõ ràng
- dễ mở rộng
- tránh
if/elserối rắm
Điểm cốt lõi phải nhớ là:
trạng thái không chỉ là dữ liệu; trạng thái còn quyết định cách object hành xử.
Bước tiếp theo hợp lý nhất là Template Method hoặc Command. Nếu học liền mạch thì Template Method rất dễ so với Strategy và State.