状态模式（State Pattern）

// 手机状态管理器：统一管理所有状态实例
public class PhoneStateManager {
    // 状态池：存储状态标识与实例的映射
    private static final Map<String, PhoneState> STATE_MAP = new HashMap<>();

    // 静态初始化：加载所有状态
    static {
        STATE_MAP.put("POWERED_OFF", PoweredOffState.getInstance());
        STATE_MAP.put("POWERED_ON", PoweredOnState.getInstance());
        STATE_MAP.put("CALLING", CallingState.getInstance());
    }

    // 根据状态标识获取状态实例（如从数据库加载时使用）
    public static PhoneState getState(String stateCode) {
        return STATE_MAP.getOrDefault(stateCode, PoweredOffState.getInstance());
    }
}

// 从数据库加载手机信息时，恢复状态
public Phone loadPhoneFromDB(String phoneId) {
    // 1. 从数据库查询手机信息（phoneId、battery、stateCode）
    String dbStateCode = "POWERED_ON"; // 假设查询结果为“开机”
    int dbBattery = 80; // 假设电量80%

    // 2. 通过状态管理器获取对应状态实例
    PhoneState state = PhoneStateManager.getState(dbStateCode);

    // 3. 构建手机对象并设置状态
    Phone phone = new Phone(phoneId);
    phone.setCurrentState(state);
    phone.setBattery(dbBattery); // 假设Phone有setBattery方法

    return phone;
}

// 父状态：开机状态（包含子状态）
public class PoweredOnState implements PhoneState {
    // 子状态：待机、通话、充电
    private PhoneState subState;

    @Override
    public void handlePowerOff(phone: Phone) {
        // 父状态公共行为：所有开机子状态均可关机
        phone.setCurrentState(PoweredOffState.getInstance());
    }

    // 子状态差异化行为：委托给子状态处理
    @Override
    public void handleMakeCall(phone: Phone) {
        subState.handleMakeCall(phone);
    }
}

// 自定义按钮：支持“加载中”状态
public class LoadingButton extends Button {
    // 自定义状态：加载中
    private boolean isLoading;

    @Override
    protected int[] onCreateDrawableState(int extraSpace) {
        // 1. 扩展状态数组，添加“加载中”状态
        int[] state = super.onCreateDrawableState(extraSpace + 1);
        if (isLoading) {
            mergeDrawableStates(state, new int[]{R.attr.state_loading});
        }
        return state;
    }

    // 切换“加载中”状态
    public void setLoading(boolean loading) {
        isLoading = loading;
        // 2. 状态变化时，刷新View
        refreshDrawableState();
    }
}

// 布局中使用：通过StateListDrawable定义状态对应的背景
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@drawable/loading_bg" android:state_loading="true"/>
    <item android:drawable="@drawable/normal_bg" android:state_loading="false"/>
</selector>

// 抽象状态：定义手机行为的统一接口
public interface PhoneState {
    // 处理开机
    void handlePowerOn(Phone phone);
    // 处理关机
    void handlePowerOff(Phone phone);
    // 处理打电话
    void handleMakeCall(Phone phone);
    // 处理挂断电话
    void handleEndCall(Phone phone);
    // 获取状态名称（辅助打印）
    String getStateName();
}

// 具体状态1：关机状态
public class PoweredOffState implements PhoneState {
    // 单例：避免重复创建状态对象（状态无内部变量，可共享）
    private static final PoweredOffState INSTANCE = new PoweredOffState();

    // 私有构造：防止外部实例化
    private PoweredOffState() {}

    // 全局获取单例
    public static PoweredOffState getInstance() {
        return INSTANCE;
    }

    @Override
    public void handlePowerOn(Phone phone) {
        System.out.println("=== 处理开机操作 ===");
        // 1. 模拟开机逻辑（如加载系统、初始化硬件）
        System.out.println("手机正在开机...");
        // 2. 切换状态为“开机”
        phone.setCurrentState(PoweredOnState.getInstance());
        System.out.println("开机成功！当前状态：" + phone.getCurrentState().getStateName());
    }

    @Override
    public void handlePowerOff(Phone phone) {
        // 关机状态不支持重复关机
        System.err.println("错误：手机当前已关机，无需重复关机！");
    }

    @Override
    public void handleMakeCall(Phone phone) {
        // 关机状态不支持打电话
        System.err.println("错误：手机当前已关机，无法打电话！");
    }

    @Override
    public void handleEndCall(Phone phone) {
        // 关机状态不支持挂断
        System.err.println("错误：手机当前已关机，无通话可挂断！");
    }

    @Override
    public String getStateName() {
        return "关机";
    }
}

// 具体状态2：开机状态（待机）
public class PoweredOnState implements PhoneState {
    private static final PoweredOnState INSTANCE = new PoweredOnState();

    private PoweredOnState() {}

    public static PoweredOnState getInstance() {
        return INSTANCE;
    }

    @Override
    public void handlePowerOn(Phone phone) {
        System.err.println("错误：手机当前已开机，无需重复开机！");
    }

    @Override
    public void handlePowerOff(Phone phone) {
        System.out.println("=== 处理关机操作 ===");
        System.out.println("手机正在关机...");
        phone.setCurrentState(PoweredOffState.getInstance());
        System.out.println("关机成功！当前状态：" + phone.getCurrentState().getStateName());
    }

    @Override
    public void handleMakeCall(Phone phone) {
        System.out.println("=== 处理打电话操作 ===");
        System.out.println("正在拨号...");
        // 切换状态为“通话”
        phone.setCurrentState(CallingState.getInstance());
        System.out.println("通话已接通！当前状态：" + phone.getCurrentState().getStateName());
    }

    @Override
    public void handleEndCall(Phone phone) {
        System.err.println("错误：手机当前无通话，无需挂断！");
    }

    @Override
    public String getStateName() {
        return "开机（待机）";
    }
}

// 具体状态3：通话状态
public class CallingState implements PhoneState {
    private static final CallingState INSTANCE = new CallingState();

    private CallingState() {}

    public static CallingState getInstance() {
        return INSTANCE;
    }

    @Override
    public void handlePowerOn(Phone phone) {
        System.err.println("错误：手机正在通话中，无法开机！");
    }

    @Override
    public void handlePowerOff(Phone phone) {
        System.err.println("错误：手机正在通话中，无法关机！");
    }

    @Override
    public void handleMakeCall(Phone phone) {
        System.err.println("错误：手机正在通话中，无法重复打电话！");
    }

    @Override
    public void handleEndCall(Phone phone) {
        System.out.println("=== 处理挂断操作 ===");
        System.out.println("正在挂断电话...");
        // 切换状态为“开机（待机）”
        phone.setCurrentState(PoweredOnState.getInstance());
        System.out.println("通话已挂断！当前状态：" + phone.getCurrentState().getStateName());
    }

    @Override
    public String getStateName() {
        return "通话中";
    }
}

// 环境类：手机，持有当前状态，委托行为处理
public class Phone {
    private final String phoneId;
    private PhoneState currentState; // 核心：持有当前状态引用
    private int battery = 100; // 默认电量100%

    // 初始化：默认状态为“关机”
    public Phone(String phoneId) {
        this.phoneId = phoneId;
        this.currentState = PoweredOffState.getInstance();
        System.out.println("手机创建成功！" + getPhoneInfo() + "，当前状态：" + currentState.getStateName());
    }

    // 对外接口：开机（委托给当前状态）
    public void powerOn() {
        currentState.handlePowerOn(this);
        // 模拟开机耗电
        battery -= 10;
    }

    // 对外接口：关机（委托给当前状态）
    public void powerOff() {
        currentState.handlePowerOff(this);
    }

    // 对外接口：打电话（委托给当前状态）
    public void makeCall() {
        currentState.handleMakeCall(this);
        // 模拟通话耗电
        battery -= 5;
    }

    // 对外接口：挂断电话（委托给当前状态）
    public void endCall() {
        currentState.handleEndCall(this);
    }

    // 允许状态类修改当前状态（包访问权限，避免外部随意修改）
    void setCurrentState(PhoneState currentState) {
        this.currentState = currentState;
    }

    // 获取当前状态（辅助）
    public PhoneState getCurrentState() {
        return currentState;
    }

    // 获取手机信息（辅助打印）
    public String getPhoneInfo() {
        return "手机ID：" + phoneId + "，电量：" + battery + "%";
    }

    // 设置电量（辅助，如充电逻辑）
    public void setBattery(int battery) {
        this.battery = Math.max(0, Math.min(100, battery));
    }
}

// 客户端：模拟用户操作手机
public class StatePatternTest {
    public static void main(String[] args) {
        // 1. 创建手机（初始状态：关机）
        Phone phone = new Phone("P123456");
        System.out.println("------------------------");

        // 2. 测试1：关机状态下开机
        phone.powerOn();
        System.out.println("当前手机信息：" + phone.getPhoneInfo());
        System.out.println("------------------------");

        // 3. 测试2：开机状态下打电话
        phone.makeCall();
        System.out.println("当前手机信息：" + phone.getPhoneInfo());
        System.out.println("------------------------");

        // 4. 测试3：通话状态下重复打电话（预期失败）
        phone.makeCall();
        System.out.println("------------------------");

        // 5. 测试4：通话状态下挂断
        phone.endCall();
        System.out.println("当前手机信息：" + phone.getPhoneInfo());
        System.out.println("------------------------");

        // 6. 测试5：开机状态下关机
        phone.powerOff();
        System.out.println("------------------------");

        // 7. 测试6：关机状态下打电话（预期失败）
        phone.makeCall();
    }
}

package com.example.orderdemo.data.model;

import android.content.Context;

/**
 * 抽象状态接口：定义所有订单状态的操作
 */
public interface OrderState {
    // 处理支付
    void handlePay(Order order, Context context);

    // 处理取消订单
    void handleCancel(Order order, Context context);

    // 处理发货（商家操作，客户端仅显示）
    void handleShip(Order order, String logisticsNo);

    // 处理确认收货
    void handleReceive(Order order, Context context);

    // 处理退款
    void handleRefund(Order order, Context context);

    // 获取状态名称（用于UI显示）
    String getStateName();

    // 获取状态编码（用于持久化）
    String getStateCode();

    // 获取当前状态下可用的操作按钮
    int[] getAvailableActions();
}

package com.example.orderdemo.data.model;

import android.content.Context;
import android.util.Log;

import androidx.lifecycle.MutableLiveData;

import com.example.orderdemo.util.OrderStateManager;

import java.util.Date;
import java.util.UUID;

/**
 * 订单实体类（环境类）
 */
public class Order {
    private static final String TAG = "Order";
    
    private final String orderId;
    private final String productName;
    private final double price;
    private final Date createTime;
    private String logisticsNo;
    private Date payTime;
    private Date shipTime;
    private Date receiveTime;
    private Date cancelTime;
    private Date refundTime;
    
    // 核心：当前状态（使用LiveData便于UI观察）
    private final MutableLiveData<OrderState> currentState = new MutableLiveData<>();

    public Order(String productName, double price) {
        this.orderId = generateOrderId();
        this.productName = productName;
        this.price = price;
        this.createTime = new Date();
        // 初始状态：待支付
        this.currentState.setValue(OrderStateManager.getPendingPayState());
        Log.d(TAG, "创建新订单: " + orderId);
    }

    // 生成唯一订单ID
    private String generateOrderId() {
        return "ORD" + System.currentTimeMillis() + UUID.randomUUID().toString().substring(0, 6);
    }

    // 对外暴露的操作方法（委托给当前状态）
    public void pay(Context context) {
        OrderState state = currentState.getValue();
        if (state != null) {
            state.handlePay(this, context);
        }
    }

    public void cancel(Context context) {
        OrderState state = currentState.getValue();
        if (state != null) {
            state.handleCancel(this, context);
        }
    }

    public void ship(String logisticsNo) {
        OrderState state = currentState.getValue();
        if (state != null) {
            state.handleShip(this, logisticsNo);
        }
    }

    public void receive(Context context) {
        OrderState state = currentState.getValue();
        if (state != null) {
            state.handleReceive(this, context);
        }
    }

    public void refund(Context context) {
        OrderState state = currentState.getValue();
        if (state != null) {
            state.handleRefund(this, context);
        }
    }

    // 状态切换（由具体状态类调用）
    public void setState(OrderState newState) {
        Log.d(TAG, "订单状态变更: " + currentState.getValue().getStateName() + 
                " -> " + newState.getStateName());
        currentState.setValue(newState);
    }

    // Getters
    public String getOrderId() { return orderId; }
    public String getProductName() { return productName; }
    public double getPrice() { return price; }
    public Date getCreateTime() { return createTime; }
    public String getLogisticsNo() { return logisticsNo; }
    public Date getPayTime() { return payTime; }
    public Date getShipTime() { return shipTime; }
    public Date getReceiveTime() { return receiveTime; }
    public MutableLiveData<OrderState> getCurrentState() { return currentState; }

    // Setters（仅允许状态类设置）
    public void setLogisticsNo(String logisticsNo) { this.logisticsNo = logisticsNo; }
    public void setPayTime(Date payTime) { this.payTime = payTime; }
    public void setShipTime(Date shipTime) { this.shipTime = shipTime; }
    public void setReceiveTime(Date receiveTime) { this.receiveTime = receiveTime; }
    public void setCancelTime(Date cancelTime) { this.cancelTime = cancelTime; }
    public void setRefundTime(Date refundTime) { this.refundTime = refundTime; }
}

package com.example.orderdemo.data.state;

import android.content.Context;
import android.widget.Toast;

import com.example.orderdemo.data.model.Order;
import com.example.orderdemo.data.model.OrderState;
import com.example.orderdemo.util.OrderStateManager;

import java.util.Date;

/**
 * 待支付状态
 */
public class PendingPayState implements OrderState {
    // 单例实例
    private static final PendingPayState INSTANCE = new PendingPayState();

    private PendingPayState() {}

    public static PendingPayState getInstance() {
        return INSTANCE;
    }

    @Override
    public void handlePay(Order order, Context context) {
        // 模拟支付流程
        Toast.makeText(context, "正在发起支付...", Toast.LENGTH_SHORT).show();
        
        // 模拟网络请求延迟
        new Thread(() -> {
            try {
                Thread.sleep(1500); // 模拟支付处理时间
                // 支付成功，切换到已支付状态
                order.setPayTime(new Date());
                order.setState(OrderStateManager.getPaidState());
                
                // 在UI线程显示结果
                ((android.app.Activity) context).runOnUiThread(() -> 
                    Toast.makeText(context, "支付成功！", Toast.LENGTH_SHORT).show());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

    @Override
    public void handleCancel(Order order, Context context) {
        order.setCancelTime(new Date());
        order.setState(OrderStateManager.getCancelledState());
        Toast.makeText(context, "订单已取消", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void handleShip(Order order, String logisticsNo) {
        // 待支付状态不支持发货
    }

    @Override
    public void handleReceive(Order order, Context context) {
        Toast.makeText(context, "请先完成支付", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void handleRefund(Order order, Context context) {
        Toast.makeText(context, "未支付订单无法退款", Toast.LENGTH_SHORT).show();
    }

    @Override
    public String getStateName() {
        return "待支付";
    }

    @Override
    public String getStateCode() {
        return "PENDING_PAY";
    }

    @Override
    public int[] getAvailableActions() {
        // 待支付状态下可用的操作：支付、取消
        return new int[]{Action.PAY, Action.CANCEL};
    }
}

package com.example.orderdemo.data.state;

import android.content.Context;
import android.widget.Toast;

import com.example.orderdemo.data.model.Order;
import com.example.orderdemo.data.model.OrderState;
import com.example.orderdemo.util.OrderStateManager;

import java.util.Date;
import java.util.Random;

/**
 * 已支付状态
 */
public class PaidState implements OrderState {
    private static final PaidState INSTANCE = new PaidState();

    private PaidState() {}

    public static PaidState getInstance() {
        return INSTANCE;
    }

    @Override
    public void handlePay(Order order, Context context) {
        Toast.makeText(context, "已完成支付，无需重复支付", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void handleCancel(Order order, Context context) {
        Toast.makeText(context, "已支付订单请申请退款", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void handleShip(Order order, String logisticsNo) {
        // 生成物流单号（模拟商家操作）
        String logNo = logisticsNo != null ? logisticsNo : generateLogisticsNo();
        order.setLogisticsNo(logNo);
        order.setShipTime(new Date());
        order.setState(OrderStateManager.getShippedState());
    }

    @Override
    public void handleReceive(Order order, Context context) {
        Toast.makeText(context, "商家尚未发货，无法确认收货", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void handleRefund(Order order, Context context) {
        Toast.makeText(context, "正在处理退款...", Toast.LENGTH_SHORT).show();
        
        new Thread(() -> {
            try {
                Thread.sleep(2000);
                order.setRefundTime(new Date());
                order.setState(OrderStateManager.getCancelledState());
                
                ((android.app.Activity) context).runOnUiThread(() -> 
                    Toast.makeText(context, "退款成功", Toast.LENGTH_SHORT).show());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

    // 生成模拟物流单号
    private String generateLogisticsNo() {
        return "SF" + new Random().nextInt(1000000000);
    }

    @Override
    public String getStateName() {
        return "已支付";
    }

    @Override
    public String getStateCode() {
        return "PAID";
    }

    @Override
    public int[] getAvailableActions() {
        // 已支付状态下可用的操作：查看物流（模拟）、申请退款
        return new int[]{Action.VIEW_LOGISTICS, Action.REFUND};
    }
}	

package com.example.orderdemo.util;

import com.example.orderdemo.data.model.OrderState;
import com.example.orderdemo.data.state.CancelledState;
import com.example.orderdemo.data.state.PaidState;
import com.example.orderdemo.data.state.PendingPayState;
import com.example.orderdemo.data.state.ReceivedState;
import com.example.orderdemo.data.state.ShippedState;

/**
 * 订单状态管理器：提供统一的状态实例访问
 */
public class OrderStateManager {
    // 所有状态实例
    private static final OrderState PENDING_PAY = PendingPayState.getInstance();
    private static final OrderState PAID = PaidState.getInstance();
    private static final OrderState SHIPPED = ShippedState.getInstance();
    private static final OrderState RECEIVED = ReceivedState.getInstance();
    private static final OrderState CANCELLED = CancelledState.getInstance();

    // 根据状态编码获取状态实例（用于从网络/数据库恢复）
    public static OrderState getStateByCode(String code) {
        switch (code) {
            case "PAID":
                return PAID;
            case "SHIPPED":
                return SHIPPED;
            case "RECEIVED":
                return RECEIVED;
            case "CANCELLED":
                return CANCELLED;
            default: // 默认待支付
                return PENDING_PAY;
        }
    }

    // 直接获取特定状态
    public static OrderState getPendingPayState() { return PENDING_PAY; }
    public static OrderState getPaidState() { return PAID; }
    public static OrderState getShippedState() { return SHIPPED; }
    public static OrderState getReceivedState() { return RECEIVED; }
    public static OrderState getCancelledState() { return CANCELLED; }
}

package com.example.orderdemo.data.model;

/**
 * 订单支持的操作类型
 */
public class Action {
    // 操作常量
    public static final int PAY = 1;         // 支付
    public static final int CANCEL = 2;      // 取消
    public static final int VIEW_LOGISTICS = 3; // 查看物流
    public static final int RECEIVE = 4;     // 确认收货
    public static final int REFUND = 5;      // 申请退款

    // 操作名称映射
    public static String getActionName(int action) {
        switch (action) {
            case PAY: return "去支付";
            case CANCEL: return "取消订单";
            case VIEW_LOGISTICS: return "查看物流";
            case RECEIVE: return "确认收货";
            case REFUND: return "申请退款";
            default: return "";
        }
    }
}

package com.example.orderdemo.ui;

import android.app.Application;

import androidx.annotation.NonNull;
import androidx.lifecycle.AndroidViewModel;
import androidx.lifecycle.LiveData;

import com.example.orderdemo.data.model.Order;

/**
 * 订单视图模型：管理订单数据，处理业务逻辑
 */
public class OrderViewModel extends AndroidViewModel {
    private Order currentOrder;

    public OrderViewModel(@NonNull Application application) {
        super(application);
        // 模拟创建一个订单
        currentOrder = new Order("无线蓝牙耳机", 299.00);
        
        // 模拟商家发货（实际场景由服务器触发）
        simulateShipAfterDelay();
    }

    // 获取当前订单
    public Order getCurrentOrder() {
        return currentOrder;
    }

    // 模拟支付后一段时间商家发货
    private void simulateShipAfterDelay() {
        new Thread(() -> {
            try {
                Thread.sleep(30000); // 30秒后模拟发货
                if (currentOrder != null && 
                    "PAID".equals(currentOrder.getCurrentState().getValue().getStateCode())) {
                    currentOrder.ship(null); // 自动发货
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

    // 模拟超时未支付自动取消
    public void startPaymentTimeoutCheck() {
        new Thread(() -> {
            try {
                Thread.sleep(60000); // 60秒后检查
                if (currentOrder != null && 
                    "PENDING_PAY".equals(currentOrder.getCurrentState().getValue().getStateCode())) {
                    currentOrder.cancel(getApplication()); // 自动取消
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

package com.example.orderdemo.ui;

import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.ViewModelProvider;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.example.orderdemo.R;
import com.example.orderdemo.data.model.Action;
import com.example.orderdemo.data.model.Order;
import com.example.orderdemo.data.model.OrderState;

import java.text.SimpleDateFormat;

public class OrderActivity extends AppCompatActivity {
    private OrderViewModel orderViewModel;
    private Order currentOrder;
    private TextView tvOrderId;
    private TextView tvProduct;
    private TextView tvPrice;
    private TextView tvState;
    private TextView tvTime;
    private LinearLayout llActions;
    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_order);
        
        // 初始化视图
        initViews();
        
        // 获取ViewModel
        orderViewModel = new ViewModelProvider(this).get(OrderViewModel.class);
        currentOrder = orderViewModel.getCurrentOrder();
        updateOrderInfo();
        
        // 观察状态变化
        observeStateChanges();
        
        // 启动支付超时检查
        orderViewModel.startPaymentTimeoutCheck();
    }

    private void initViews() {
        tvOrderId = findViewById(R.id.tv_order_id);
        tvProduct = findViewById(R.id.tv_product);
        tvPrice = findViewById(R.id.tv_price);
        tvState = findViewById(R.id.tv_state);
        tvTime = findViewById(R.id.tv_time);
        llActions = findViewById(R.id.ll_actions);
    }

    private void observeStateChanges() {
        currentOrder.getCurrentState().observe(this, state -> {
            // 状态变化时更新UI
            updateOrderInfo();
            updateActionButtons(state);
        });
    }

    // 更新订单基本信息
    private void updateOrderInfo() {
        tvOrderId.setText("订单编号: " + currentOrder.getOrderId());
        tvProduct.setText("商品: " + currentOrder.getProductName());
        tvPrice.setText("金额: ¥" + currentOrder.getPrice());
        tvState.setText("当前状态: " + currentOrder.getCurrentState().getValue().getStateName());
        tvTime.setText("创建时间: " + sdf.format(currentOrder.getCreateTime()));
    }

    // 根据当前状态更新操作按钮
    private void updateActionButtons(OrderState state) {
        llActions.removeAllViews();
        int[] actions = state.getAvailableActions();
        
        for (int action : actions) {
            Button button = new Button(this);
            button.setText(Action.getActionName(action));
            button.setOnClickListener(v -> handleAction(action));
            
            // 添加按钮到布局
            LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
                    0, LinearLayout.LayoutParams.WRAP_CONTENT, 1);
            params.setMargins(8, 8, 8, 8);
            llActions.addView(button, params);
        }
    }

    // 处理用户操作
    private void handleAction(int action) {
        switch (action) {
            case Action.PAY:
                currentOrder.pay(this);
                break;
            case Action.CANCEL:
                currentOrder.cancel(this);
                break;
            case Action.VIEW_LOGISTICS:
                String logisticsNo = currentOrder.getLogisticsNo();
                if (logisticsNo != null) {
                    Toast.makeText(this, "物流单号: " + logisticsNo, Toast.LENGTH_LONG).show();
                } else {
                    Toast.makeText(this, "商家尚未发货", Toast.LENGTH_SHORT).show();
                }
                break;
            case Action.RECEIVE:
                currentOrder.receive(this);
                break;
            case Action.REFUND:
                currentOrder.refund(this);
                break;
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="订单详情"
        android:textSize="20sp"
        android:textStyle="bold"/>

    <TextView
        android:id="@+id/tv_order_id"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:textSize="16sp"/>

    <TextView
        android:id="@+id/tv_product"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:textSize="16sp"/>

    <TextView
        android:id="@+id/tv_price"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:textColor="@color/design_default_color_error"
        android:textSize="16sp"/>

    <TextView
        android:id="@+id/tv_state"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:textSize="16sp"/>

    <TextView
        android:id="@+id/tv_time"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="8dp"
        android:textSize="14sp"
        android:textColor="@android:color/darker_gray"/>

    <LinearLayout
        android:id="@+id/ll_actions"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="32dp"
        android:orientation="horizontal"/>

</LinearLayout>