行为型模式 ⭐⭐⭐

// 一个 Subject 对应多个 Observer 的内存关系
// WeatherStation (Subject)
//    ├── PhoneDisplay (Observer 1)
//    ├── WidgetDisplay (Observer 2)
//    └── WearDisplay  (Observer 3)

// ==================== 抽象层 ====================
 
// 观察者接口：泛型 T 表示接收的数据类型
interface Observer<T> {
    // 当被观察者状态变化时，此方法被回调
    fun update(data: T)
}
 
// 被观察者接口：定义注册、移除、通知的契约
interface Subject<T> {
    // 注册一个观察者
    fun registerObserver(observer: Observer<T>)
    // 移除一个观察者
    fun removeObserver(observer: Observer<T>)
    // 通知所有已注册的观察者
    fun notifyObservers()
}
 
// ==================== 具体实现层 ====================
 
// 具体被观察者：天气数据站
class WeatherStation : Subject<Float> {
 
    // 内部维护的观察者列表（线程安全可使用 CopyOnWriteArrayList）
    private val observers = mutableListOf<Observer<Float>>()
 
    // 内部状态：当前温度
    var temperature: Float = 0f
        // 自定义 setter：每次赋值时自动通知所有观察者
        set(value) {
            field = value            // 更新内部状态
            notifyObservers()        // 状态变化 -> 触发通知
        }
 
    // 将观察者加入列表
    override fun registerObserver(observer: Observer<Float>) {
        observers.add(observer)      // 添加到列表末尾
    }
 
    // 将观察者从列表移除
    override fun removeObserver(observer: Observer<Float>) {
        observers.remove(observer)   // 从列表中删除
    }
 
    // 遍历列表，逐一通知
    override fun notifyObservers() {
        // toList() 创建快照，防止遍历中修改列表导致 ConcurrentModificationException
        observers.toList().forEach { observer ->
            observer.update(temperature) // 推送最新温度值
        }
    }
}
 
// 具体观察者：手机显示面板
class PhoneDisplay(private val name: String) : Observer<Float> {
    // 收到通知时的处理逻辑
    override fun update(data: Float) {
        println("[$name] 收到新温度: ${data}°C")  // 展示最新数据
    }
}

fun main() {
    val station = WeatherStation()          // 创建被观察者
 
    val phone = PhoneDisplay("手机")         // 创建观察者 A
    val widget = PhoneDisplay("桌面小组件")   // 创建观察者 B
 
    station.registerObserver(phone)          // 注册观察者 A
    station.registerObserver(widget)         // 注册观察者 B
 
    station.temperature = 25.5f              // 状态变化 -> 自动通知
    // 输出:
    // [手机] 收到新温度: 25.5°C
    // [桌面小组件] 收到新温度: 25.5°C
 
    station.removeObserver(widget)           // 注销观察者 B
    station.temperature = 30.0f              // 再次变化 -> 只通知 A
    // 输出:
    // [手机] 收到新温度: 30.0°C
}

// Android Framework 源码简化版 —— LiveData.observe()
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    // 强制在主线程调用
    assertMainThread("observe");
    // 如果 LifecycleOwner 已经 DESTROYED，直接忽略本次注册
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        return;                          // 防止对已销毁组件注册观察者
    }
    // 将 Observer 包裹为具有生命周期感知能力的 LifecycleBoundObserver
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
    // 存入 Map，如果已存在则返回旧值
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    // 如果该 Observer 已经绑定了其他 LifecycleOwner，抛出异常
    if (existing != null && !existing.isAttachedTo(owner)) {
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    if (existing != null) {
        return;                          // 已经注册过，直接返回
    }
    // 将 wrapper 注册为 Lifecycle 的观察者，监听生命周期事件
    owner.getLifecycle().addObserver(wrapper);
}

class MyViewModel : ViewModel() {
    // 对外暴露不可变的 LiveData（封装原则）
    private val _userName = MutableLiveData<String>()  // 内部可变
    val userName: LiveData<String> get() = _userName    // 外部只读
 
    // 主线程更新数据 —— 同步分发
    fun updateNameOnMain(name: String) {
        _userName.value = name         // 等价于 setValue()，必须在主线程
    }
 
    // 子线程更新数据 —— 通过 Handler 切换到主线程后分发
    fun updateNameFromBackground(name: String) {
        _userName.postValue(name)      // 内部通过主线程 Handler post Runnable
    }
}
 
// Activity 中注册观察者
class MyActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by viewModels()  // 获取 ViewModel 实例
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // observe() 传入 this（LifecycleOwner），绑定生命周期
        viewModel.userName.observe(this) { name ->
            // 只在 STARTED / RESUMED 时回调
            binding.tvName.text = name   // 安全更新 UI
        }
    }
}

// RxJava 在 Android 中的典型使用模式
class UserRepository @Inject constructor(
    private val apiService: ApiService       // Retrofit 接口
) {
    // 返回 Observable 数据流
    fun fetchUsers(): Observable<List<User>> {
        return apiService.getUsers()          // Retrofit 返回 Observable
            .map { response ->                // map 操作符：变换数据
                response.data                 // 从 Response 中提取 data 字段
            }
            .filter { users ->                // filter 操作符：过滤
                users.isNotEmpty()            // 只放行非空列表
            }
            .subscribeOn(Schedulers.io())     // 指定上游在 IO 线程执行
            .observeOn(AndroidSchedulers.mainThread()) // 指定下游在主线程回调
    }
}
 
// 在 ViewModel 或 Activity 中订阅
class UserViewModel : ViewModel() {
 
    private val compositeDisposable = CompositeDisposable() // 统一管理所有订阅
 
    fun loadUsers() {
        val disposable = repository.fetchUsers()
            .subscribe(                          // 订阅 = 建立观察关系
                { users ->                       // onNext：成功接收数据
                    _usersLiveData.value = users // 更新 LiveData
                },
                { error ->                       // onError：异常处理
                    Log.e("VM", "加载失败", error)
                },
                {                                // onComplete：流结束
                    Log.d("VM", "数据加载完成")
                }
            )
        compositeDisposable.add(disposable)      // 加入管理容器
    }
 
    override fun onCleared() {
        super.onCleared()
        compositeDisposable.clear()              // ViewModel 销毁时取消所有订阅，防止内存泄漏
    }
}

// ========== Step 1: 定义事件类 ==========
// 事件就是一个普通的数据类，无需继承任何基类
data class MessageEvent(
    val message: String,        // 消息内容
    val timestamp: Long         // 时间戳
)
 
// ========== Step 2: 在接收端注册 / 注销 ==========
class ChatActivity : AppCompatActivity() {
 
    override fun onStart() {
        super.onStart()
        // 注册当前 Activity 为订阅者
        EventBus.getDefault().register(this)
    }
 
    override fun onStop() {
        super.onStop()
        // 注销订阅，防止内存泄漏（必须与 register 配对）
        EventBus.getDefault().unregister(this)
    }
 
    // 使用 @Subscribe 注解标记事件处理方法
    // threadMode 指定回调线程：MAIN 表示在主线程执行
    @Subscribe(threadMode = ThreadMode.MAIN)
    fun onMessageReceived(event: MessageEvent) {
        // 收到事件后更新 UI
        binding.tvMessage.text = event.message
    }
}
 
// ========== Step 3: 在发送端发布事件 ==========
class MessageService : Service() {
    fun handleNewMessage(msg: String) {
        // 发布事件 —— 所有已注册且订阅了 MessageEvent 的组件都会收到
        EventBus.getDefault().post(
            MessageEvent(msg, System.currentTimeMillis())
        )
    }
}

// ========== 方式 1: 动态注册 (推荐，生命周期可控) ==========
class NetworkActivity : AppCompatActivity() {
 
    // 定义 BroadcastReceiver（Observer）
    private val networkReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            // 收到广播时的回调处理
            val isConnected = intent.getBooleanExtra("is_connected", false)
            updateNetworkUI(isConnected)     // 更新 UI 状态
        }
    }
 
    override fun onResume() {
        super.onResume()
        // 创建 IntentFilter，指定要监听的广播 Action
        val filter = IntentFilter("android.net.conn.CONNECTIVITY_CHANGE")
        // 动态注册广播接收器
        registerReceiver(networkReceiver, filter)
    }
 
    override fun onPause() {
        super.onPause()
        // 动态注册必须手动注销，否则内存泄漏
        unregisterReceiver(networkReceiver)
    }
}
 
// ========== 方式 2: 静态注册 (AndroidManifest.xml) ==========
// 适用于即使 App 未运行也需要接收的广播 (Android 8.0+ 严格限制)

<!-- AndroidManifest.xml 中静态注册 -->
<receiver
    android:name=".BootReceiver"
    android:exported="true">
    <intent-filter>
        <!-- 监听开机完成广播 -->
        <action android:name="android.intent.action.BOOT_COMPLETED"/>
    </intent-filter>
</receiver>

// 经典写法
val button = findViewById<Button>(R.id.btn_submit)  // 获取 View（Subject）
 
// 设置点击监听器 —— 注册 Observer
button.setOnClickListener { view ->
    // 这里是 Observer 的 update() 回调
    handleSubmit()                                   // 处理点击事件
}

// android.view.View 源码（简化版）
public class View {
    // View 内部持有的 ListenerInfo 对象，集中管理所有监听器
    ListenerInfo mListenerInfo;
 
    // 获取或创建 ListenerInfo
    ListenerInfo getListenerInfo() {
        if (mListenerInfo != null) {
            return mListenerInfo;                    // 已存在直接返回
        }
        mListenerInfo = new ListenerInfo();          // 延迟初始化
        return mListenerInfo;
    }
 
    // 注册点击监听器 —— 观察者模式的 registerObserver
    public void setOnClickListener(OnClickListener l) {
        if (!isClickable()) {
            setClickable(true);                      // 如果 View 不可点击，自动设为可点击
        }
        getListenerInfo().mOnClickListener = l;      // 保存监听器引用
    }
 
    // 执行点击回调 —— 观察者模式的 notifyObservers
    public boolean performClick() {
        final boolean result;
        final ListenerInfo li = mListenerInfo;       // 取出 ListenerInfo
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK); // 播放点击音效
            li.mOnClickListener.onClick(this);        // 回调 Observer 的 onClick()
            result = true;
        } else {
            result = false;
        }
        return result;
    }
}

// ViewTreeObserver —— 真正的一对多观察者
val view = findViewById<View>(R.id.my_view)
// 添加全局布局监听器（一对多：可以 add 多个）
view.viewTreeObserver.addOnGlobalLayoutListener {
    // 当 View Tree 完成布局计算后回调
    val width = view.measuredWidth                   // 此时可以获取到真实宽高
    val height = view.measuredHeight
}

// 一对一观察（set 语义）
// view.setOnClickListener { }        // 点击
// view.setOnLongClickListener { }    // 长按
// view.setOnTouchListener { }        // 触摸
 
// 一对多观察（add 语义）
// viewTreeObserver.addOnGlobalLayoutListener { }         // 布局完成
// viewTreeObserver.addOnPreDrawListener { }              // 绘制前
// animation.addListener(object : AnimatorListener { })   // 动画状态

// ❌ 反面示例：所有折扣逻辑混在一起
class PriceCalculator {
 
    // 根据用户类型计算最终价格
    fun calculate(type: String, originalPrice: Double): Double {
        return when (type) {
            "normal"  -> originalPrice                           // 普通用户：原价
            "vip"     -> originalPrice * 0.8                     // VIP：8 折
            "svip"    -> originalPrice * 0.7                     // SVIP：7 折
            "new"     -> if (originalPrice > 100)                // 新用户：满100减20
                             originalPrice - 20 
                         else originalPrice
            else      -> originalPrice
        }
    }
}

// ============================================
// 1. 定义策略接口（算法的"契约"）
// ============================================
interface DiscountStrategy {
    // 唯一的算法方法：接收原价，返回折后价
    fun calculate(originalPrice: Double): Double
}
 
// ============================================
// 2. 具体策略：普通用户 — 不打折
// ============================================
class NormalDiscount : DiscountStrategy {
    override fun calculate(originalPrice: Double): Double {
        return originalPrice  // 原价直接返回
    }
}
 
// ============================================
// 3. 具体策略：VIP — 打 8 折
// ============================================
class VipDiscount : DiscountStrategy {
    override fun calculate(originalPrice: Double): Double {
        return originalPrice * 0.8  // 原价 × 0.8
    }
}
 
// ============================================
// 4. 具体策略：SVIP — 打 7 折
// ============================================
class SvipDiscount : DiscountStrategy {
    override fun calculate(originalPrice: Double): Double {
        return originalPrice * 0.7  // 原价 × 0.7
    }
}
 
// ============================================
// 5. 具体策略：新用户 — 满100减20
// ============================================
class NewUserDiscount : DiscountStrategy {
    override fun calculate(originalPrice: Double): Double {
        // 满 100 减 20，否则原价
        return if (originalPrice > 100) originalPrice - 20.0
               else originalPrice
    }
}

继承方式:   Context ──extends──▶ ConcreteContextA / ConcreteContextB
策略方式:   Context ──has-a──▶ Strategy（可在运行时替换）

// ============================================
// Context（上下文）：持有策略引用并委托执行
// ============================================
class PriceCalculator(
    // 通过构造器注入一个默认策略
    private var strategy: DiscountStrategy = NormalDiscount()
) {
    // 运行时切换策略的 setter
    fun setDiscountStrategy(newStrategy: DiscountStrategy) {
        this.strategy = newStrategy  // 替换为新的策略对象
    }
 
    // 对外暴露的计算方法 —— 完全委托给策略
    fun calculate(originalPrice: Double): Double {
        return strategy.calculate(originalPrice)  // 具体算法由策略决定
    }
}

fun main() {
    val calculator = PriceCalculator()           // 默认普通用户策略
 
    // —— 场景 1：普通用户下单 ——
    val price1 = calculator.calculate(200.0)     // 200.0（原价）
    println("普通用户: $price1")
 
    // —— 场景 2：运行时切换为 VIP 策略 ——
    calculator.setDiscountStrategy(VipDiscount()) // 动态替换！
    val price2 = calculator.calculate(200.0)      // 160.0（8折）
    println("VIP 用户: $price2")
 
    // —— 场景 3：再切换为新用户策略 ——
    calculator.setDiscountStrategy(NewUserDiscount())
    val price3 = calculator.calculate(200.0)      // 180.0（满100减20）
    println("新用户: $price3")
}

// ============================================
// 用函数类型代替策略接口
// ============================================
class PriceCalculatorLambda(
    // 策略直接用 (Double) -> Double 函数类型表示
    private var strategy: (Double) -> Double = { it }  // 默认：原价返回
) {
    // 运行时切换
    fun setStrategy(newStrategy: (Double) -> Double) {
        this.strategy = newStrategy
    }
 
    // 委托计算
    fun calculate(price: Double): Double = strategy(price)
}
 
fun main() {
    val calc = PriceCalculatorLambda()
 
    // 传入 Lambda 作为策略
    calc.setStrategy { price -> price * 0.8 }        // VIP 8 折
    println(calc.calculate(200.0))                    // 160.0
 
    calc.setStrategy { price ->                       // 新用户满100减20
        if (price > 100) price - 20 else price 
    }
    println(calc.calculate(200.0))                    // 180.0
}

// ❌ 令人窒息的 if-else 地狱
class PaymentService {
 
    fun pay(channel: String, amount: Double) {
        if (channel == "alipay") {
            // 支付宝：30 行复杂逻辑...
            println("调用支付宝 SDK，金额：$amount")
        } else if (channel == "wechat") {
            // 微信支付：40 行复杂逻辑...
            println("调用微信支付 SDK，金额：$amount")
        } else if (channel == "unionpay") {
            // 银联支付：50 行复杂逻辑...
            println("调用银联 SDK，金额：$amount")
        } else if (channel == "paypal") {
            // PayPal：35 行复杂逻辑...
            println("调用 PayPal SDK，金额：$amount")
        }
        // 每增加一种支付渠道，这里就要再加一个 else-if...
    }
}

// ============================================
// Step 1: 策略接口
// ============================================
interface PaymentStrategy {
    fun pay(amount: Double)  // 执行支付
}
 
// ============================================
// Step 2: 各渠道具体策略
// ============================================
class AlipayStrategy : PaymentStrategy {
    override fun pay(amount: Double) {
        // 调用支付宝 SDK 的完整逻辑
        println("✅ 支付宝支付：$amount 元")
    }
}
 
class WechatPayStrategy : PaymentStrategy {
    override fun pay(amount: Double) {
        // 调用微信支付 SDK 的完整逻辑
        println("✅ 微信支付：$amount 元")
    }
}
 
class UnionPayStrategy : PaymentStrategy {
    override fun pay(amount: Double) {
        // 调用银联 SDK 的完整逻辑
        println("✅ 银联支付：$amount 元")
    }
}
 
// ============================================
// Step 3: 策略注册表（消除选择分支）
// ============================================
object PaymentStrategyFactory {
    // 用 Map 把 channel 名称映射到具体策略实例
    private val strategies = mutableMapOf<String, PaymentStrategy>(
        "alipay"   to AlipayStrategy(),      // 注册支付宝
        "wechat"   to WechatPayStrategy(),   // 注册微信
        "unionpay" to UnionPayStrategy()     // 注册银联
    )
 
    // 支持动态注册新渠道（不修改任何已有代码！）
    fun register(channel: String, strategy: PaymentStrategy) {
        strategies[channel] = strategy
    }
 
    // 根据 channel 获取对应策略
    fun get(channel: String): PaymentStrategy {
        return strategies[channel]
            ?: throw IllegalArgumentException("未知支付渠道: $channel")
    }
}
 
// ============================================
// Step 4: 重构后的 PaymentService（零 if-else！）
// ============================================
class PaymentService {
    fun pay(channel: String, amount: Double) {
        // 从工厂获取策略 → 直接执行，没有任何条件判断
        val strategy = PaymentStrategyFactory.get(channel)
        strategy.pay(amount)
    }
}

// 枚举自身就是策略！
enum class Discount : DiscountStrategy {
    NORMAL {
        override fun calculate(originalPrice: Double) = originalPrice
    },
    VIP {
        override fun calculate(originalPrice: Double) = originalPrice * 0.8
    },
    SVIP {
        override fun calculate(originalPrice: Double) = originalPrice * 0.7
    };
}
 
// 使用时直接：
val price = Discount.VIP.calculate(200.0)  // 160.0

// android.animation.TimeInterpolator
// Framework 策略接口：只有一个方法
public interface TimeInterpolator {
    /**
     * @param input  动画的时间进度，范围 [0.0, 1.0]
     *               0.0 = 动画开始，1.0 = 动画结束
     * @return       映射后的插值结果，决定动画的实际位置/透明度/缩放等
     *               通常也在 [0.0, 1.0]，但可超出（如 Overshoot）
     */
    float getInterpolation(float input);
}

// 策略A：线性插值器 —— 匀速运动
// android.view.animation.LinearInterpolator
public class LinearInterpolator implements Interpolator {
    public float getInterpolation(float input) {
        return input;  // y = x，完全线性
    }
}
 
// 策略B：加速插值器 —— 越来越快
// android.view.animation.AccelerateInterpolator
public class AccelerateInterpolator implements Interpolator {
    private final float mFactor;       // 加速因子
    private final double mDoubleFactor; // 加速因子 × 2
 
    public AccelerateInterpolator(float factor) {
        mFactor = factor;                        // 保存加速因子
        mDoubleFactor = 2 * factor;              // 预计算
    }
 
    public float getInterpolation(float input) {
        // 当 factor = 1.0 时：y = x²（标准二次加速）
        // 当 factor 更大时：加速效果更明显
        if (mFactor == 1.0f) {
            return input * input;                // x² 曲线
        } else {
            return (float) Math.pow(input, mDoubleFactor); // x^(2f) 曲线
        }
    }
}
 
// 策略C：弹跳插值器 —— 像皮球落地一样弹跳
// android.view.animation.BounceInterpolator
public class BounceInterpolator implements Interpolator {
    public float getInterpolation(float t) {
        // 分段函数模拟弹跳物理效果
        t *= 1.1226f;                            // 缩放时间参数
        if (t < 0.3535f) {
            return bounce(t);                    // 第一次弹跳
        } else if (t < 0.7408f) {
            return bounce(t - 0.54719f) + 0.7f;  // 第二次弹跳
        } else if (t < 0.9644f) {
            return bounce(t - 0.8526f) + 0.9f;   // 第三次弹跳
        } else {
            return bounce(t - 1.0435f) + 0.95f;  // 最后一次弹跳
        }
    }
 
    private static float bounce(float t) {
        return t * t * 8.0f;                     // 弹跳核心公式
    }
}

// ============================================
// 运行时切换动画插值器策略
// ============================================
val animator = ObjectAnimator.ofFloat(
    myView,          // 目标 View
    "translationY",  // 动画属性
    0f,              // 起始值
    500f             // 终点值
).apply {
    duration = 1000  // 动画时长 1 秒
}
 
// —— 策略 1：线性匀速 ——
animator.interpolator = LinearInterpolator()
animator.start()
 
// —— 策略 2：切换为加速效果 ——
animator.interpolator = AccelerateInterpolator(1.5f)  // 运行时切换！
animator.start()
 
// —— 策略 3：切换为弹跳效果 ——
animator.interpolator = BounceInterpolator()          // 再次切换！
animator.start()

// ============================================
// 自定义弹性插值器（模拟弹簧效果）
// ============================================
class SpringInterpolator(
    private val factor: Float = 0.4f  // 弹簧张力因子
) : TimeInterpolator {
 
    override fun getInterpolation(input: Float): Float {
        // 指数衰减 × 正弦波 = 弹簧效果
        // pow(2, -10 * input) * sin((input - factor/4) * (2*PI) / factor) + 1
        return (Math.pow(2.0, -10.0 * input)               // 指数衰减
                * Math.sin((input - factor / 4.0)           // 正弦波相位
                * (2.0 * Math.PI) / factor)                 // 正弦波周期
                + 1.0).toFloat()                            // 偏移到 1.0
    }
}
 
// 使用自定义策略
animator.interpolator = SpringInterpolator(0.3f)

// android.animation.ValueAnimator 核心源码（简化版）
// 每一帧回调此方法
void animateValue(float fraction) {
    // ① 将时间进度交给插值器策略 —— 策略模式的调用点！
    fraction = mInterpolator.getInterpolation(fraction);
    
    // ② 用插值后的 fraction 计算属性值
    mCurrentFraction = fraction;
    int numValues = mValues.length;
    for (int i = 0; i < numValues; ++i) {
        // 将插值结果传递给 PropertyValuesHolder 计算最终属性值
        mValues[i].calculateValue(fraction);
    }
    
    // ③ 通知监听器（观察者模式 + 策略模式的联合使用）
    if (mUpdateListeners != null) {
        int numListeners = mUpdateListeners.size();
        for (int i = 0; i < numListeners; ++i) {
            mUpdateListeners.get(i).onAnimationUpdate(this);
        }
    }
}

// androidx.recyclerview.widget.RecyclerView.LayoutManager（简化）
public abstract static class LayoutManager {
    
    // 核心策略方法：负责布局所有子 View
    public void onLayoutChildren(Recycler recycler, State state) {
        // 默认空实现，子类必须重写
    }
 
    // 是否支持水平滚动
    public boolean canScrollHorizontally() {
        return false;  // 默认不支持
    }
 
    // 是否支持垂直滚动
    public boolean canScrollVertically() {
        return false;  // 默认不支持
    }
 
    // 处理垂直滚动
    public int scrollVerticallyBy(int dy, Recycler recycler, State state) {
        return 0;      // 默认不滚动
    }
 
    // 生成默认的 LayoutParams
    public abstract LayoutParams generateDefaultLayoutParams();
}

val recyclerView = findViewById<RecyclerView>(R.id.recycler_view)
 
// ============================================
// 策略 1：线性列表（纵向滚动）
// ============================================
recyclerView.layoutManager = LinearLayoutManager(
    this,                             // Context
    LinearLayoutManager.VERTICAL,     // 方向：纵向
    false                             // 是否反转
)
 
// ============================================
// 策略 2：运行时切换为网格布局（3列）
// ============================================
recyclerView.layoutManager = GridLayoutManager(
    this,                             // Context
    3                                 // 列数
)
 
// ============================================
// 策略 3：运行时切换为瀑布流布局（2列）
// ============================================
recyclerView.layoutManager = StaggeredGridLayoutManager(
    2,                                           // 列数
    StaggeredGridLayoutManager.VERTICAL          // 方向
)

// ============================================
// 自定义：轮播/旋转木马布局管理器（简化示意）
// ============================================
class CarouselLayoutManager : RecyclerView.LayoutManager() {
 
    // 必须实现：生成默认布局参数
    override fun generateDefaultLayoutParams(): RecyclerView.LayoutParams {
        return RecyclerView.LayoutParams(
            RecyclerView.LayoutParams.WRAP_CONTENT,    // 宽度自适应
            RecyclerView.LayoutParams.WRAP_CONTENT     // 高度自适应
        )
    }
 
    // 核心：自定义布局逻辑
    override fun onLayoutChildren(
        recycler: RecyclerView.Recycler,    // 回收复用器
        state: RecyclerView.State           // 列表状态
    ) {
        detachAndScrapAttachedViews(recycler)   // 1. 先回收所有已 attached 的 View
 
        val itemCount = state.itemCount          // 2. 获取数据总数
        if (itemCount == 0) return               // 3. 无数据直接返回
 
        val centerX = width / 2                  // 4. 计算 RecyclerView 中心 X
        val centerY = height / 2                 // 5. 计算 RecyclerView 中心 Y
 
        for (i in 0 until itemCount) {
            val view = recycler.getViewForPosition(i)  // 6. 从回收池获取 View
            addView(view)                               // 7. 添加到 RecyclerView
            measureChildWithMargins(view, 0, 0)         // 8. 测量 View
 
            // 9. 计算圆形排列的角度和位置
            val angle = Math.toRadians(360.0 / itemCount * i)
            val radius = width / 3                      // 旋转半径
            val x = centerX + (radius * Math.cos(angle)).toInt()
            val y = centerY + (radius * Math.sin(angle)).toInt()
 
            val w = getDecoratedMeasuredWidth(view)     // 10. 获取装饰后宽度
            val h = getDecoratedMeasuredHeight(view)    // 11. 获取装饰后高度
 
            // 12. 布局 View 到计算出的位置
            layoutDecorated(view, x - w / 2, y - h / 2, x + w / 2, y + h / 2)
        }
    }
 
    // 支持水平滚动
    override fun canScrollHorizontally(): Boolean = true
}
 
// 使用自定义策略 —— 无需修改 RecyclerView 的任何代码
recyclerView.layoutManager = CarouselLayoutManager()

// androidx.recyclerview.widget.RecyclerView（简化核心链路）
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    // 委托给 dispatchLayout()
    dispatchLayout();
}
 
void dispatchLayout() {
    // ...
    if (mState.mLayoutStep == State.STEP_START) {
        dispatchLayoutStep1();    // 处理 Adapter 更新和预布局动画
        dispatchLayoutStep2();    // 真正的布局 ← 策略调用点
    }
    dispatchLayoutStep3();        // 处理动画
}
 
private void dispatchLayoutStep2() {
    // ...
    mState.mInPreLayout = false;
    
    // ★★★ 策略模式核心调用 ★★★
    // RecyclerView 将真正的布局工作完全委托给 LayoutManager
    mLayout.onLayoutChildren(mRecycler, mState);
    // mLayout 就是通过 setLayoutManager() 注入的策略对象
    // ...
}

/**
 * 抽象基类：热饮料制作模板
 * 定义了制作饮料的完整算法骨架
 */
abstract class HotBeverage {
 
    /**
     * 模板方法 —— 定义算法骨架
     * 注意：在 Kotlin 中方法默认是 final 的，子类无法覆盖此方法
     * 这保证了流程的不可篡改性
     */
    fun prepare() {
        boilWater()       // 第1步：烧水（具体方法，所有饮料一样）
        brew()            // 第2步：冲泡（抽象方法，子类必须实现）
        pourInCup()       // 第3步：倒入杯中（具体方法，所有饮料一样）
        if (wantCondiments()) { // 钩子方法控制是否执行第4步
            addCondiments()     // 第4步：加配料（抽象方法，子类必须实现）
        }
    }
 
    // ============ 具体方法（Concrete Method）============
    // 所有子类共享的固定实现，子类直接继承即可
 
    /** 烧水 —— 所有饮料都需要烧开水，逻辑完全一致 */
    private fun boilWater() {
        println("将水煮沸至100°C")
    }
 
    /** 倒入杯中 —— 统一操作 */
    private fun pourInCup() {
        println("将饮料倒入杯中")
    }
 
    // ============ 抽象方法（Abstract Method）============
    // 子类 **必须** 实现的步骤，代表算法中的「可变部分」
 
    /** 冲泡方式 —— 咖啡用滤泡，茶用浸泡，各不相同 */
    protected abstract fun brew()
 
    /** 添加配料 —— 咖啡加糖和牛奶，茶加柠檬，各不相同 */
    protected abstract fun addCondiments()
 
    // ============ 钩子方法（Hook Method）============
    // 提供默认实现，子类 **可选** 覆盖来改变部分流程行为
 
    /** 是否需要配料 —— 默认需要，子类可覆盖为 false 来跳过 */
    protected open fun wantCondiments(): Boolean = true
}

/**
 * 具体子类A：咖啡
 * 只需关注"怎么冲泡"和"加什么配料"，不需要关心整体流程
 */
class Coffee : HotBeverage() {
 
    /** 咖啡的冲泡方式：用滤纸滴漏 */
    override fun brew() {
        println("用滤纸滴漏冲泡咖啡粉")
    }
 
    /** 咖啡的配料：糖和牛奶 */
    override fun addCondiments() {
        println("加入糖和牛奶")
    }
}
 
/**
 * 具体子类B：茶
 * 同样只需实现差异化步骤
 */
class Tea : HotBeverage() {
 
    /** 茶的冲泡方式：浸泡茶叶 */
    override fun brew() {
        println("将茶叶浸泡在热水中 3 分钟")
    }
 
    /** 茶的配料：柠檬 */
    override fun addCondiments() {
        println("加入柠檬片")
    }
 
    /**
     * 覆盖钩子方法 —— 这杯茶不需要配料
     * 通过返回 false，跳过 addCondiments() 的调用
     */
    override fun wantCondiments(): Boolean = false
}
 
// ============ 客户端调用 ============
fun main() {
    println("--- 制作咖啡 ---")
    val coffee = Coffee()    // 创建咖啡实例
    coffee.prepare()         // 调用模板方法，框架自动编排流程
 
    println("\n--- 制作茶 ---")
    val tea = Tea()          // 创建茶实例
    tea.prepare()            // 同样的模板方法，不同的具体步骤
}

--- 制作咖啡 ---
将水煮沸至100°C
用滤纸滴漏冲泡咖啡粉
将饮料倒入杯中
加入糖和牛奶
 
--- 制作茶 ---
将水煮沸至100°C
将茶叶浸泡在热水中 3 分钟
将饮料倒入杯中

/**
 * android.app.Activity（Framework 源码简化版）
 * Activity 本身就是一个"抽象基类"角色（虽然它不是 abstract class）
 * 它定义了生命周期回调方法作为"钩子"，子类选择性覆盖
 */
public class Activity extends ContextThemeWrapper {
 
    // ========== 模板方法的"骨架"并不在 Activity 内部 ==========
    // 真正的骨架在 ActivityThread.performLaunchActivity() 中
    // Activity 本身提供的是"步骤方法"
 
    /**
     * 生命周期回调 —— 钩子方法（Hook Method）
     * 提供了空实现或基础实现，子类"可选"覆盖
     * 注意：你必须调用 super.onCreate()，否则会抛异常
     */
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        // ... 恢复 Fragment 状态、恢复 Window 状态等基础逻辑
        // 这些逻辑是"具体方法"的部分，子类通过 super 继承
        mCalled = true;  // 标记 super 被调用，用于检测子类是否遗漏 super 调用
    }
 
    protected void onStart() {
        mCalled = true;  // 同上，确保 super 被调用
        // ... 启动相关的 Fragment、分发 onStart 给 Fragment
    }
 
    protected void onResume() {
        mCalled = true;
        // ... 恢复暂停的 Fragment
    }
 
    protected void onPause() {
        mCalled = true;
        // ... 暂停 Fragment、提交未完成的事务
    }
 
    protected void onStop() {
        mCalled = true;
        // ... 停止 Fragment
    }
 
    protected void onDestroy() {
        mCalled = true;
        // ... 关闭对话框、销毁 Fragment、释放资源
    }
}

/**
 * android.app.ActivityThread（Framework 源码简化版）
 * 这里才是真正的"模板方法"所在
 * performLaunchActivity() 定义了启动 Activity 的算法骨架
 */
public final class ActivityThread {
 
    /**
     * 模板方法：启动一个 Activity 的完整流程
     * 此方法严格控制了各步骤的执行顺序，应用开发者无法修改
     */
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        // Step 1：创建 Activity 实例（具体方法 —— 固定逻辑）
        Activity activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
 
        // Step 2：创建 Application（如果还没有的话）
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
 
        // Step 3：创建 Context
        ContextImpl appContext = createBaseContextForActivity(r);
 
        // Step 4：attach —— 关联 Window、Token 等核心组件（具体方法）
        activity.attach(appContext, this, getInstrumentation(),
                r.token, r.ident, app, r.intent, r.activityInfo, ...);
 
        // Step 5：调用 onCreate —— 回调到你的子类（抽象/钩子步骤）
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
        } else {
            mInstrumentation.callActivityOnCreate(activity, r.state);
        }
 
        // Step 6：调用 onStart（如果 Activity 不是仅部分创建）
        if (!r.activity.mFinished) {
            activity.performStart("performLaunchActivity");
        }
 
        return activity;
    }
 
    /**
     * 模板方法：恢复 Activity 的流程
     * onStart -> onResume 的顺序在此被严格保证
     */
    public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest, ...) {
        // Step 1：执行 performResume（内部会调用 onResume）
        if (!performResumeActivity(r, finalStateRequest, reason)) {
            return;
        }
 
        // Step 2：让 Window 可见（具体方法 —— 固定逻辑）
        if (r.activity.mVisibleFromClient) {
            r.activity.makeVisible();
        }
 
        // Step 3：通知 Looper 空闲时执行 GC 等（具体方法）
        Looper.myQueue().addIdleHandler(new Idler());
    }
}

// Activity 内部的防御性校验
protected void onStart() {
    mCalled = true;  // 标记 super.onStart() 被调用
}
 
// ActivityThread 或 Instrumentation 在调用完 onStart() 后会检查：
if (!activity.mCalled) {
    throw new SuperNotCalledException(
        "Activity " + activity.getLocalClassName() +
        " did not call through to super.onStart()");
}

/**
 * android.os.AsyncTask（Framework 源码简化版）
 * 这是一个泛型抽象类，三个泛型参数分别代表：
 * Params  —— 输入参数类型
 * Progress —— 进度更新类型
 * Result  —— 返回结果类型
 */
public abstract class AsyncTask<Params, Progress, Result> {
 
    /**
     * 模板方法：execute() 定义了异步任务的完整执行骨架
     * 调用者只需 execute()，内部按固定顺序编排各步骤
     */
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);  // 委托给线程池
    }
 
    /**
     * 真正的模板方法骨架（简化版）
     * 注意内部编排逻辑：
     * 1. onPreExecute()     —— 主线程，任务开始前
     * 2. doInBackground()   —— 工作线程，执行耗时操作
     * 3. onPostExecute()    —— 主线程，任务完成后
     */
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(
            Executor exec, Params... params) {
 
        // Step 1：在主线程执行预处理（钩子方法）
        onPreExecute();
 
        // Step 2：封装 Worker，交给线程池（具体方法 —— 固定逻辑）
        mWorker.mParams = params;
        exec.execute(mFuture);
 
        return this;
    }
 
    // ========== 抽象方法：子类必须实现 ==========
 
    /**
     * 在后台线程执行的核心逻辑
     * 这是唯一一个在工作线程运行的方法
     * @param params 输入参数
     * @return 执行结果
     */
    @WorkerThread
    protected abstract Result doInBackground(Params... params);
 
    // ========== 钩子方法：子类可选覆盖 ==========
 
    /** 任务执行前调用（主线程），常用于显示 ProgressDialog */
    @MainThread
    protected void onPreExecute() {
        // 默认空实现 —— 典型的钩子方法
    }
 
    /** 任务执行完成后调用（主线程），接收 doInBackground 的返回值 */
    @MainThread
    protected void onPostExecute(Result result) {
        // 默认空实现 —— 典型的钩子方法
    }
 
    /** 进度更新时调用（主线程），由 publishProgress() 触发 */
    @MainThread
    protected void onProgressUpdate(Progress... values) {
        // 默认空实现 —— 典型的钩子方法
    }
 
    /** 任务被取消时调用（主线程） */
    @MainThread
    protected void onCancelled(Result result) {
        // 默认空实现 —— 典型的钩子方法
    }
 
    // ========== 具体方法：线程切换的核心机制 ==========
 
    /**
     * 内部使用 Handler 将结果从工作线程投递到主线程
     * 这段逻辑子类完全不需要关心，由框架保证
     */
    private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);  // 绑定主线程 Looper
        }
 
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // 框架在此调用 onPostExecute 或 onCancelled
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    // 框架在此调用 onProgressUpdate
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }
}

/**
 * 具体子类：下载文件的异步任务
 * 泛型参数: <输入URL: String, 进度: Int, 结果: ByteArray?>
 */
@Suppress("DEPRECATION") // 仅用于演示模板方法模式，实际开发请用协程
class DownloadTask(
    private val callback: (ByteArray?) -> Unit  // 下载完成的回调
) : AsyncTask<String, Int, ByteArray?>() {
 
    /** 钩子方法覆盖：任务开始前显示加载状态 */
    override fun onPreExecute() {
        super.onPreExecute()
        showLoadingDialog()  // 显示加载弹窗
    }
 
    /** 抽象方法实现：在后台线程执行下载（必须实现） */
    override fun doInBackground(vararg params: String?): ByteArray? {
        val url = params[0] ?: return null  // 获取第一个参数作为 URL
        return try {
            val connection = URL(url).openConnection()  // 建立网络连接
            val totalSize = connection.contentLength     // 获取文件总大小
            val inputStream = connection.getInputStream()
            val buffer = ByteArrayOutputStream()
 
            val data = ByteArray(1024)  // 1KB 缓冲区
            var count: Int              // 每次读取的字节数
            var downloadedSize = 0      // 已下载大小
 
            // 循环读取数据
            while (inputStream.read(data).also { count = it } != -1) {
                buffer.write(data, 0, count)  // 写入缓冲区
                downloadedSize += count
                // 发布进度 —— 会触发 onProgressUpdate（通过 Handler 切换到主线程）
                publishProgress((downloadedSize * 100) / totalSize)
            }
 
            buffer.toByteArray()  // 返回结果
        } catch (e: Exception) {
            null  // 下载失败返回 null
        }
    }
 
    /** 钩子方法覆盖：更新进度条 */
    override fun onProgressUpdate(vararg values: Int?) {
        val progress = values[0] ?: return  // 获取当前进度百分比
        updateProgressBar(progress)          // 更新 UI 上的进度条
    }
 
    /** 钩子方法覆盖：下载完成后处理结果 */
    override fun onPostExecute(result: ByteArray?) {
        dismissLoadingDialog()  // 关闭加载弹窗
        callback(result)        // 将结果回调给调用方
    }
}

/**
 * android.view.View.draw() —— 模板方法
 * 定义了 View 绘制的完整算法骨架（6步）
 */
public void draw(Canvas canvas) {
    // Step 1: 绘制背景（具体方法 —— 固定逻辑）
    drawBackground(canvas);
 
    // Step 2: 保存 canvas 层（如果需要 fading edge）
    // ... 省略
 
    // Step 3: 绘制内容 —— 钩子方法，子类覆盖此方法来绘制自定义内容
    onDraw(canvas);
 
    // Step 4: 绘制子 View（具体方法 —— 遍历子 View 并调用其 draw）
    dispatchDraw(canvas);
 
    // Step 5: 绘制前景、滚动条等装饰（具体方法）
    onDrawForeground(canvas);
 
    // Step 6: 绘制高亮（焦点状态）
    drawDefaultFocusHighlight(canvas);
}

class SplashActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        setContentView(R.layout.activity_splash)
        initViews()
    }
    
    private fun initViews() { /* ... */ }
}

/**
 * 抽象处理者 (Abstract Handler)
 * 定义了处理请求的接口，并持有下一个处理者的引用
 */
abstract class Handler {
 
    // 指向链条中下一个处理者的引用，可为 null 表示链尾
    protected var nextHandler: Handler? = null
 
    /**
     * 设置下一个处理者，返回 nextHandler 以支持链式调用
     * 例如: handlerA.setNext(handlerB).setNext(handlerC)
     */
    fun setNext(handler: Handler): Handler {
        this.nextHandler = handler  // 将传入的 handler 设为下一个节点
        return handler              // 返回 handler 本身，方便链式构建
    }
 
    /**
     * 处理请求的核心方法
     * @param request 待处理的请求对象
     */
    abstract fun handleRequest(request: Request)
}
 
/**
 * 请求数据类，封装了请求的类型和内容
 */
data class Request(
    val type: String,       // 请求类型，用于匹配处理者
    val content: String     // 请求内容
)

/**
 * 具体处理者 A：只处理 type 为 "AUTH" 的请求
 */
class AuthHandler : Handler() {
    override fun handleRequest(request: Request) {
        if (request.type == "AUTH") {
            // 条件匹配，自己处理这个请求
            println("AuthHandler 处理了认证请求: ${request.content}")
        } else {
            // 条件不匹配，传递给链条中的下一个处理者
            println("AuthHandler 无法处理，传递给下一个...")
            nextHandler?.handleRequest(request)  // 如果有下一个节点就传递
                ?: println("链条结束，无人处理该请求")  // 链尾，无人处理
        }
    }
}
 
/**
 * 具体处理者 B：只处理 type 为 "LOG" 的请求
 */
class LogHandler : Handler() {
    override fun handleRequest(request: Request) {
        if (request.type == "LOG") {
            // 自己处理日志请求
            println("LogHandler 处理了日志请求: ${request.content}")
        } else {
            // 传递给下一个
            println("LogHandler 无法处理，传递给下一个...")
            nextHandler?.handleRequest(request)
                ?: println("链条结束，无人处理该请求")
        }
    }
}
 
/**
 * 具体处理者 C：只处理 type 为 "DATA" 的请求
 */
class DataHandler : Handler() {
    override fun handleRequest(request: Request) {
        if (request.type == "DATA") {
            // 自己处理数据请求
            println("DataHandler 处理了数据请求: ${request.content}")
        } else {
            println("DataHandler 无法处理，传递给下一个...")
            nextHandler?.handleRequest(request)
                ?: println("链条结束，无人处理该请求")
        }
    }
}

fun main() {
    // ① 创建各个处理者节点
    val authHandler = AuthHandler()   // 认证处理者
    val logHandler = LogHandler()     // 日志处理者
    val dataHandler = DataHandler()   // 数据处理者
 
    // ② 构建链条: Auth -> Log -> Data
    authHandler.setNext(logHandler).setNext(dataHandler)
 
    // ③ 发送不同类型的请求
    println("===== 发送 LOG 请求 =====")
    authHandler.handleRequest(Request("LOG", "用户登录日志"))
    // 输出:
    // AuthHandler 无法处理，传递给下一个...
    // LogHandler 处理了日志请求: 用户登录日志
 
    println("\n===== 发送 DATA 请求 =====")
    authHandler.handleRequest(Request("DATA", "查询用户列表"))
    // 输出:
    // AuthHandler 无法处理，传递给下一个...
    // LogHandler 无法处理，传递给下一个...
    // DataHandler 处理了数据请求: 查询用户列表
 
    println("\n===== 发送 UNKNOWN 请求 =====")
    authHandler.handleRequest(Request("UNKNOWN", "未知操作"))
    // 输出:
    // AuthHandler 无法处理，传递给下一个...
    // LogHandler 无法处理，传递给下一个...
    // DataHandler 无法处理，传递给下一个...
    // 链条结束，无人处理该请求
}

/**
 * 不纯责任链示例：每个 Handler 都参与处理，然后继续传递
 * 类似 OkHttp 的拦截器机制
 */
abstract class ImpureHandler {
 
    protected var nextHandler: ImpureHandler? = null
 
    fun setNext(handler: ImpureHandler): ImpureHandler {
        this.nextHandler = handler
        return handler
    }
 
    /**
     * 处理请求 —— 注意：处理完之后仍然传递给下一个
     */
    fun handleRequest(request: Request) {
        // 第一步：自己先做预处理 (intercept)
        doHandle(request)
        // 第二步：无论是否处理，都传递给下一个节点
        nextHandler?.handleRequest(request)
    }
 
    // 子类实现自己的处理逻辑
    protected abstract fun doHandle(request: Request)
}

// ========= 反面示例：不用责任链，硬编码 if-else =========
class RequestProcessor {
    /**
     * 所有逻辑耦合在一个巨大的方法中
     * 每新增一种请求类型，就要修改这个方法 —— 违反开闭原则
     */
    fun process(request: Request) {
        if (request.type == "AUTH") {           // 认证逻辑
            println("处理认证: ${request.content}")
        } else if (request.type == "LOG") {     // 日志逻辑
            println("处理日志: ${request.content}")
        } else if (request.type == "DATA") {    // 数据逻辑
            println("处理数据: ${request.content}")
        } else if (request.type == "CACHE") {   // 又加了缓存逻辑...
            println("处理缓存: ${request.content}")
        }
        // 每次新增类型都要改这个类 → 高耦合、难测试、易出错
    }
}
 
// ========= 正面示例：使用责任链，职责分离 =========
fun buildChain(): Handler {
    val auth = AuthHandler()
    val log = LogHandler()
    val data = DataHandler()
    val cache = CacheHandler()      // 新增节点，只需创建类 + 挂到链上
    auth.setNext(log).setNext(data).setNext(cache)
    return auth                     // 返回链首
}
// Client 只需: buildChain().handleRequest(request)
// 新增处理逻辑 = 新增一个 Handler 类 + 链条中多挂一个节点
// 完全无需修改已有的任何 Handler 代码

// frameworks/base/core/java/android/app/Activity.java
public boolean dispatchTouchEvent(MotionEvent ev) {
    // ACTION_DOWN 表示一次新的触摸序列开始
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        // 空方法，子类可覆写以感知用户交互（如重置超时计时器）
        onUserInteraction();
    }
    // 将事件交给 Window（实际是 PhoneWindow）处理
    // PhoneWindow 内部会将事件转发给 DecorView（顶层 ViewGroup）
    if (getWindow().superDispatchTouchEvent(ev)) {
        // 如果 ViewGroup 树中的某个 View 消费了事件，直接返回 true
        return true;
    }
    // 没有任何 View 消费事件，Activity 自己兜底处理
    return onTouchEvent(ev);
}

// frameworks/base/core/java/android/view/ViewGroup.java (精简核心逻辑)
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    boolean handled = false;        // 最终返回值：事件是否被处理
    final int action = ev.getAction();
 
    // ===== 第一步：判断是否拦截 =====
    boolean intercepted;
    if (action == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
        // 检查子 View 是否通过 requestDisallowInterceptTouchEvent()
        // 请求父容器不要拦截
        final boolean disallowIntercept =
            (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
        if (!disallowIntercept) {
            // 调用 onInterceptTouchEvent() 询问自己是否拦截
            intercepted = onInterceptTouchEvent(ev);
        } else {
            intercepted = false;    // 子 View 要求不拦截，尊重子 View
        }
    } else {
        // 非 DOWN 事件且没有 touch target，说明之前已拦截，继续拦截
        intercepted = true;
    }
 
    // ===== 第二步：如果不拦截，寻找能处理事件的子 View =====
    if (!intercepted) {
        if (action == MotionEvent.ACTION_DOWN) {
            // 遍历所有子 View（按 Z 轴顺序，从最上层开始）
            for (int i = childrenCount - 1; i >= 0; i--) {
                final View child = children[i];
                // 检查触摸点是否在子 View 的范围内
                if (!child.canReceivePointerEvents()
                    || !isTransformedTouchPointInView(x, y, child, null)) {
                    continue;   // 触摸点不在这个 child 上，跳过
                }
                // 将事件分发给子 View
                if (dispatchTransformedTouchEvent(ev, child)) {
                    // 子 View 消费了事件，记录为 touch target
                    mFirstTouchTarget = addTouchTarget(child);
                    handled = true;
                    break;      // 找到消费者，停止遍历
                }
            }
        }
    }
 
    // ===== 第三步：如果没有子 View 消费，自己处理 =====
    if (mFirstTouchTarget == null) {
        // 没有子 View 消费事件 → 调用自己的 onTouchEvent()
        // 传入 child=null，最终会执行 super.dispatchTouchEvent(ev)
        // 即调用 View.dispatchTouchEvent() → View.onTouchEvent()
        handled = dispatchTransformedTouchEvent(ev, null);
    }
 
    return handled;
}

// frameworks/base/core/java/android/view/View.java
public boolean dispatchTouchEvent(MotionEvent event) {
    boolean result = false;
 
    // 优先级 1：OnTouchListener（如果设置了的话）
    // 注意：OnTouchListener 的优先级高于 onTouchEvent()
    if (mOnTouchListener != null
        && (mViewFlags & ENABLED_MASK) == ENABLED     // View 是 enabled 状态
        && mOnTouchListener.onTouch(this, event)) {   // listener 返回 true
        result = true;  // OnTouchListener 消费了事件，不再调用 onTouchEvent
    }
 
    // 优先级 2：onTouchEvent()
    // 只有 OnTouchListener 未消费时才会走到这里
    if (!result && onTouchEvent(event)) {
        result = true;  // onTouchEvent() 消费了事件
    }
    // 注意：OnClickListener 是在 onTouchEvent() 的 ACTION_UP 中触发的
    // 所以 OnClickListener 的优先级最低
 
    return result;
}

/**
 * 自定义 ViewGroup：演示外部拦截法解决滑动冲突
 * 场景：外层是横向滑动的 ViewPager，内层是纵向滑动的 RecyclerView
 */
class ConflictResolverLayout @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : FrameLayout(context, attrs) {
 
    // 记录上一次触摸的 X/Y 坐标
    private var lastInterceptX = 0f
    private var lastInterceptY = 0f
 
    /**
     * 外部拦截法的核心：在父容器的 onInterceptTouchEvent 中判断
     */
    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
        var intercepted = false                // 默认不拦截
        val x = ev.x                          // 当前触摸点 X
        val y = ev.y                          // 当前触摸点 Y
 
        when (ev.action) {
            MotionEvent.ACTION_DOWN -> {
                // DOWN 事件必须返回 false，否则后续事件无法传递给子 View
                intercepted = false
                lastInterceptX = x             // 记录起始触摸点
                lastInterceptY = y
            }
            MotionEvent.ACTION_MOVE -> {
                val deltaX = Math.abs(x - lastInterceptX)  // 水平滑动距离
                val deltaY = Math.abs(y - lastInterceptY)  // 垂直滑动距离
                if (deltaX > deltaY) {
                    // 水平滑动距离大于垂直距离 → 父容器（横向滑动）拦截
                    intercepted = true
                } else {
                    // 垂直滑动距离更大 → 不拦截，让子 View（纵向滑动）处理
                    intercepted = false
                }
            }
            MotionEvent.ACTION_UP -> {
                // UP 事件一般不拦截
                intercepted = false
            }
        }
 
        // 更新上次的坐标
        lastInterceptX = x
        lastInterceptY = y
        return intercepted
    }
}