设计原则 ⭐⭐

// ❌ 反面案例：一个 Activity 承担了至少 4 种职责
// 这是 Android 开发中最常见的"大泥球"模式
class UserProfileActivity : AppCompatActivity() {
 
    // ---- 职责1: UI 状态管理 ----
    private lateinit var tvUserName: TextView       // 用户名文本
    private lateinit var tvEmail: TextView           // 邮箱文本
    private lateinit var ivAvatar: ImageView         // 头像图片
    private lateinit var progressBar: ProgressBar    // 加载动画
 
    // ---- 职责2: 网络请求（数据获取）----
    private val httpClient = OkHttpClient()          // 直接持有网络客户端
 
    // ---- 职责3: 本地缓存（数据持久化）----
    private lateinit var database: SQLiteDatabase    // 直接持有数据库引用
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_user_profile)
 
        // 初始化视图（职责1）
        tvUserName = findViewById(R.id.tv_user_name)
        tvEmail = findViewById(R.id.tv_email)
        ivAvatar = findViewById(R.id.iv_avatar)
        progressBar = findViewById(R.id.progress_bar)
 
        // 加载用户数据：同时涉及网络请求 + 缓存 + UI 更新
        loadUserProfile()
    }
 
    // 这个方法混合了网络请求、JSON解析、数据库操作、UI更新 —— 4种职责纠缠在一起
    private fun loadUserProfile() {
        progressBar.visibility = View.VISIBLE       // UI操作：显示加载中
 
        // 职责2: 构建网络请求
        val request = Request.Builder()
            .url("https://api.example.com/user/profile")
            .build()
 
        // 职责2: 发起异步网络调用
        httpClient.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                // 职责3: 网络失败时尝试从本地数据库读取缓存
                val cursor = database.rawQuery(
                    "SELECT * FROM user_profile LIMIT 1", null
                )
                if (cursor.moveToFirst()) {
                    val name = cursor.getString(cursor.getColumnIndex("name"))
                    val email = cursor.getString(cursor.getColumnIndex("email"))
                    // 职责1 + 职责4(线程切换): 切回主线程更新 UI
                    runOnUiThread {
                        tvUserName.text = name
                        tvEmail.text = email
                        progressBar.visibility = View.GONE
                    }
                }
                cursor.close()
            }
 
            override fun onResponse(call: Call, response: Response) {
                // 职责2: 手动解析 JSON（职责4: 数据转换）
                val json = JSONObject(response.body?.string() ?: "")
                val name = json.getString("name")
                val email = json.getString("email")
                val avatarUrl = json.getString("avatar_url")
 
                // 职责3: 写入本地缓存
                database.execSQL(
                    "INSERT OR REPLACE INTO user_profile(name, email, avatar) VALUES(?, ?, ?)",
                    arrayOf(name, email, avatarUrl)
                )
 
                // 职责1: 主线程更新 UI
                runOnUiThread {
                    tvUserName.text = name
                    tvEmail.text = email
                    progressBar.visibility = View.GONE
                    // 职责1: 图片加载（又混入了图片加载库的调用）
                    Glide.with(this@UserProfileActivity)
                        .load(avatarUrl)
                        .into(ivAvatar)
                }
            }
        })
    }
 
    // 职责5: 数据校验逻辑也放在 Activity 里
    private fun isValidEmail(email: String): Boolean {
        return Patterns.EMAIL_ADDRESS.matcher(email).matches()
    }
}

// ✅ 正面案例 — 第1层：数据模型（职责：定义数据结构）
// 变化原因：后端 API 返回字段变化时才需修改
data class UserProfile(
    val name: String,       // 用户名
    val email: String,      // 邮箱地址
    val avatarUrl: String   // 头像链接
)

// ✅ 正面案例 — 第2层：网络数据源（职责：纯粹负责网络请求）
// 变化原因：API 接口地址/协议变化时才需修改
class UserRemoteDataSource(
    private val apiService: UserApiService  // Retrofit 接口，由外部注入
) {
    // 仅负责从远端获取用户数据，不关心缓存、不关心 UI
    suspend fun fetchUserProfile(): UserProfile {
        // Retrofit 自动处理 JSON -> UserProfile 的转换
        return apiService.getUserProfile()
    }
}

// ✅ 正面案例 — 第3层：本地数据源（职责：纯粹负责本地持久化）
// 变化原因：数据库 schema 或缓存策略变化时才需修改
class UserLocalDataSource(
    private val userDao: UserDao    // Room DAO，由外部注入
) {
    // 仅负责从本地数据库读取用户数据
    suspend fun getCachedProfile(): UserProfile? {
        return userDao.getUser()?.toUserProfile()   // Entity -> Domain Model
    }
 
    // 仅负责将用户数据写入本地数据库
    suspend fun cacheProfile(profile: UserProfile) {
        userDao.insertUser(profile.toUserEntity())   // Domain Model -> Entity
    }
}

// ✅ 正面案例 — 第4层：Repository（职责：协调远程与本地数据源的策略）
// 变化原因：数据获取策略（先缓存还是先网络）变化时才需修改
class UserRepository(
    private val remoteDataSource: UserRemoteDataSource,  // 远程数据源
    private val localDataSource: UserLocalDataSource     // 本地数据源
) {
    // 策略：优先网络 -> 成功后缓存 -> 网络失败时回退缓存
    suspend fun getUserProfile(): Result<UserProfile> {
        return try {
            // 尝试从网络获取最新数据
            val profile = remoteDataSource.fetchUserProfile()
            // 获取成功后写入本地缓存（不阻塞返回）
            localDataSource.cacheProfile(profile)
            // 返回成功结果
            Result.success(profile)
        } catch (e: Exception) {
            // 网络失败，尝试从本地缓存读取
            val cached = localDataSource.getCachedProfile()
            if (cached != null) {
                Result.success(cached)  // 缓存命中
            } else {
                Result.failure(e)       // 缓存也没有，返回失败
            }
        }
    }
}

// ✅ 正面案例 — 第5层：ViewModel（职责：管理 UI 状态 + 连接业务逻辑）
// 变化原因：UI 需要展示的状态字段变化时才需修改
class UserProfileViewModel(
    private val repository: UserRepository  // Repository 由外部注入
) : ViewModel() {
 
    // 用 sealed class 明确定义 UI 的所有可能状态
    sealed class UiState {
        object Loading : UiState()                          // 加载中
        data class Success(val profile: UserProfile) : UiState()  // 加载成功
        data class Error(val message: String) : UiState()   // 加载失败
    }
 
    // 使用 StateFlow 暴露 UI 状态（替代 LiveData，更适合 Kotlin 协程）
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
 
    // 加载用户资料 —— ViewModel 不知道数据来自网络还是缓存
    fun loadProfile() {
        viewModelScope.launch {                             // 在 ViewModel 作用域启动协程
            _uiState.value = UiState.Loading                // 发射加载中状态
            val result = repository.getUserProfile()        // 调用 Repository
            _uiState.value = result.fold(                   // 根据结果映射为 UI 状态
                onSuccess = { UiState.Success(it) },        // 成功
                onFailure = { UiState.Error(it.message ?: "Unknown error") }  // 失败
            )
        }
    }
}

// ✅ 正面案例 — 第6层：Activity（职责：纯粹负责 UI 渲染 + 用户交互）
// 变化原因：UI布局/交互方式变化时才需修改
class UserProfileActivity : AppCompatActivity() {
 
    // ViewModel 通过 Activity 扩展函数懒加载
    private val viewModel: UserProfileViewModel by viewModels()
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_user_profile)
 
        // 观察 UI 状态变化并渲染 —— Activity 只做"展示"
        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.uiState.collect { state ->        // 收集 StateFlow
                    when (state) {
                        is UiState.Loading -> showLoading()  // 显示加载动画
                        is UiState.Success -> showProfile(state.profile)  // 渲染数据
                        is UiState.Error -> showError(state.message)      // 显示错误
                    }
                }
            }
        }
 
        // 触发加载
        viewModel.loadProfile()
    }
 
    // 以下都是纯 UI 操作方法，不包含任何业务逻辑
    private fun showLoading() {
        findViewById<ProgressBar>(R.id.progress_bar).visibility = View.VISIBLE
    }
 
    private fun showProfile(profile: UserProfile) {
        findViewById<ProgressBar>(R.id.progress_bar).visibility = View.GONE
        findViewById<TextView>(R.id.tv_user_name).text = profile.name
        findViewById<TextView>(R.id.tv_email).text = profile.email
        Glide.with(this).load(profile.avatarUrl)
            .into(findViewById(R.id.iv_avatar))
    }
 
    private fun showError(message: String) {
        findViewById<ProgressBar>(R.id.progress_bar).visibility = View.GONE
        Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
    }
}

// ❌ 反面案例：每次新增一种消息类型，都必须修改这个函数
// 这违反了 OCP —— 对修改"敞开大门"
class NotificationHandler {
 
    // 处理推送通知 —— 用 if-else / when 硬编码所有类型
    fun handleNotification(type: String, data: Bundle) {
        when (type) {
            "chat" -> {
                // 聊天消息的处理逻辑：解析发送者、消息内容...
                val sender = data.getString("sender")
                val message = data.getString("message")
                showChatNotification(sender, message)
            }
            "order" -> {
                // 订单消息的处理逻辑：解析订单号、状态...
                val orderId = data.getString("order_id")
                val status = data.getString("status")
                showOrderNotification(orderId, status)
            }
            "promotion" -> {
                // 促销消息的处理逻辑
                val title = data.getString("title")
                showPromotionNotification(title)
            }
            // ❌ 每新增一种通知类型（如 "system", "payment", "logistics"...）
            //    都必须在这里添加新的分支，修改已有代码
            //    如果这个类已经上线并稳定运行，每次修改都有引入 bug 的风险
        }
    }
 
    private fun showChatNotification(sender: String?, message: String?) { /* ... */ }
    private fun showOrderNotification(orderId: String?, status: String?) { /* ... */ }
    private fun showPromotionNotification(title: String?) { /* ... */ }
}

// ✅ 正面案例 — Step 1: 定义通知处理器的抽象接口
// 这是"稳定的抽象层" —— 一旦定义好就不需要修改
interface NotificationProcessor {
    // 该处理器支持的通知类型
    val supportedType: String
 
    // 处理通知的具体逻辑
    fun process(data: Bundle)
}

// ✅ 正面案例 — Step 2: 各类型通知处理器分别实现（对扩展开放）
// 聊天通知处理器
class ChatNotificationProcessor : NotificationProcessor {
    override val supportedType: String = "chat"    // 声明自己处理 "chat" 类型
 
    override fun process(data: Bundle) {
        val sender = data.getString("sender")       // 解析发送者
        val message = data.getString("message")     // 解析消息内容
        // 构建并显示聊天通知...
        NotificationCompat.Builder(/* ... */)
            .setContentTitle(sender)
            .setContentText(message)
            .build()
    }
}
 
// 订单通知处理器
class OrderNotificationProcessor : NotificationProcessor {
    override val supportedType: String = "order"   // 声明自己处理 "order" 类型
 
    override fun process(data: Bundle) {
        val orderId = data.getString("order_id")    // 解析订单号
        val status = data.getString("status")       // 解析订单状态
        // 构建并显示订单通知...
    }
}
 
// ✅ 未来新增 "logistics" 类型时，只需新增一个类：
class LogisticsNotificationProcessor : NotificationProcessor {
    override val supportedType: String = "logistics"
 
    override fun process(data: Bundle) {
        // 物流通知的处理逻辑...
    }
}

// ✅ 正面案例 — Step 3: 通知分发器（对修改关闭）
// 这个类一旦写好，不管新增多少种通知类型，都不需要修改它
class NotificationDispatcher {
 
    // 注册表：type -> processor 的映射
    private val processorMap = mutableMapOf<String, NotificationProcessor>()
 
    // 注册处理器 —— 通过"注册"而非"硬编码"来添加新类型
    fun register(processor: NotificationProcessor) {
        processorMap[processor.supportedType] = processor
    }
 
    // 分发通知 —— 永远不需要修改这个方法
    fun dispatch(type: String, data: Bundle) {
        val processor = processorMap[type]           // 从注册表查找
            ?: throw IllegalArgumentException("Unknown notification type: $type")
        processor.process(data)                       // 委托给具体处理器
    }
}

// ✅ 正面案例 — Step 4: 组装（通常在 Application 或 DI 模块中）
class MyApplication : Application() {
    lateinit var notificationDispatcher: NotificationDispatcher
 
    override fun onCreate() {
        super.onCreate()
        // 创建分发器
        notificationDispatcher = NotificationDispatcher()
 
        // 注册所有处理器 —— 新增类型只需在这里多加一行注册
        notificationDispatcher.register(ChatNotificationProcessor())
        notificationDispatcher.register(OrderNotificationProcessor())
        notificationDispatcher.register(LogisticsNotificationProcessor())
        // 未来新增: notificationDispatcher.register(PaymentNotificationProcessor())
    }
}

// ❌ 反面案例：经典的 LSP 违反 —— 正方形继承矩形
// 从数学角度看，正方形 IS-A 矩形，但从行为角度看，这个继承关系是有问题的
 
open class Rectangle(                   // 矩形：宽和高可以独立变化
    open var width: Int,                // 宽度
    open var height: Int                // 高度
) {
    // 计算面积
    open fun area(): Int = width * height
}
 
class Square(side: Int) : Rectangle(side, side) {  // 正方形继承矩形
    // 正方形的约束：宽 == 高，所以设置宽度时必须同步高度
    override var width: Int
        get() = super.width
        set(value) {
            super.width = value         // 设置宽度
            super.height = value        // ❌ 同步修改高度（改变了父类的行为契约！）
        }
 
    // 同理，设置高度时也必须同步宽度
    override var height: Int
        get() = super.height
        set(value) {
            super.height = value        // 设置高度
            super.width = value         // ❌ 同步修改宽度
        }
}

// 调用方代码 —— 按照 Rectangle 的行为契约编写
fun testArea(rect: Rectangle) {
    rect.width = 5                      // 只修改宽度
    rect.height = 4                     // 只修改高度
    // 按照矩形的语义，面积应该是 5 * 4 = 20
    assert(rect.area() == 20)           // ✅ Rectangle → 20，通过
                                        // ❌ Square → 4 * 4 = 16，断言失败！
}
 
fun main() {
    testArea(Rectangle(0, 0))           // ✅ 正确
    testArea(Square(0))                 // ❌ 失败！LSP 被违反
}

// ✅ 正面案例：用接口定义"形状"的抽象行为
// 不使用继承，避免行为契约被子类破坏
 
interface Shape {
    fun area(): Int                     // 所有形状都能计算面积
}
 
// 矩形：独立的宽和高
class Rectangle(
    val width: Int,                     // 宽度（val，不可变，避免状态变异问题）
    val height: Int                     // 高度
) : Shape {
    override fun area(): Int = width * height
}
 
// 正方形：只有边长
class Square(
    val side: Int                       // 边长
) : Shape {
    override fun area(): Int = side * side
}
 
// 调用方依赖抽象接口，不做任何"宽高可独立修改"的假设
fun printArea(shape: Shape) {
    println("面积 = ${shape.area()}")    // ✅ Rectangle 和 Square 都能正确工作
}

// ✅ 正确的自定义 View —— 遵守 View 的测量契约
class CircleView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {
 
    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        // ✅ 关键：必须调用 setMeasuredDimension()，这是 View 的行为契约
        // 如果不调用，父类会抛出 IllegalStateException
        val size = minOf(
            MeasureSpec.getSize(widthMeasureSpec),
            MeasureSpec.getSize(heightMeasureSpec)
        )
        setMeasuredDimension(size, size)  // ✅ 遵守契约：必须设置测量结果
    }
 
    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)             // ✅ 调用父类方法，保持契约链
        // 绘制圆形...
        val radius = width / 2f
        canvas.drawCircle(radius, radius, radius, Paint().apply {
            color = Color.BLUE
            isAntiAlias = true
        })
    }
}

// ❌ 违反 LSP 的自定义 View
class BrokenView(context: Context) : View(context) {
 
    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        // ❌ 忘记调用 setMeasuredDimension() —— 违反了 View.onMeasure 的行为契约
        // 虽然编译通过，但运行时 ViewGroup 调用 child.getMeasuredWidth() 会得到错误结果
    }
 
    override fun setVisibility(visibility: Int) {
        // ❌ 覆写 setVisibility 但不调用 super —— 破坏了父类的可见性管理契约
        // 其他代码调用 view.visibility = View.GONE 时预期 View 会消失，但实际不会
        // 违反了"子类可替换父类"的原则
        if (visibility == GONE) return    // 忽略 GONE 请求
        super.setVisibility(visibility)
    }
}

// ❌ 反面案例：一个"万能"的用户操作接口
// 强迫所有实现类都实现所有方法
interface UserAction {
    fun login(username: String, password: String)    // 登录
    fun logout()                                      // 登出
    fun updateProfile(name: String, avatar: String)   // 更新资料
    fun deleteAccount()                               // 注销账号
    fun exportData(): ByteArray                       // 导出数据
    fun sendMessage(to: String, content: String)      // 发送消息
    fun blockUser(userId: String)                     // 拉黑用户
}
 
// 一个"访客"模块只需要登录功能，但被迫实现所有方法
class GuestModule : UserAction {
    override fun login(username: String, password: String) {
        // ✅ 这是访客唯一需要的功能
    }
 
    // ❌ 以下所有方法对访客毫无意义，但必须实现
    override fun logout() { /* 空实现 */ }
    override fun updateProfile(name: String, avatar: String) {
        throw UnsupportedOperationException("访客不能修改资料")  // ❌ 被迫抛异常
    }
    override fun deleteAccount() {
        throw UnsupportedOperationException("访客不能注销")
    }
    override fun exportData(): ByteArray = byteArrayOf()
    override fun sendMessage(to: String, content: String) {
        throw UnsupportedOperationException("访客不能发消息")
    }
    override fun blockUser(userId: String) {
        throw UnsupportedOperationException("访客不能拉黑")
    }
}

// ✅ 正面案例：将一个胖接口拆分为多个小接口
 
// 认证相关操作
interface Authenticatable {
    fun login(username: String, password: String)    // 登录
    fun logout()                                      // 登出
}
 
// 资料管理操作
interface ProfileManageable {
    fun updateProfile(name: String, avatar: String)   // 更新资料
    fun deleteAccount()                               // 注销账号
    fun exportData(): ByteArray                       // 导出数据
}
 
// 社交操作
interface Socializable {
    fun sendMessage(to: String, content: String)      // 发送消息
    fun blockUser(userId: String)                     // 拉黑用户
}
 
// 访客模块：只实现需要的认证接口
class GuestModule : Authenticatable {
    override fun login(username: String, password: String) {
        // ✅ 只实现自己需要的方法，干净利落
    }
    override fun logout() {
        // ✅ 清理访客会话
    }
}
 
// 正式用户模块：实现所有相关接口
class RegisteredUserModule : Authenticatable, ProfileManageable, Socializable {
    override fun login(username: String, password: String) { /* ... */ }
    override fun logout() { /* ... */ }
    override fun updateProfile(name: String, avatar: String) { /* ... */ }
    override fun deleteAccount() { /* ... */ }
    override fun exportData(): ByteArray = byteArrayOf(/* ... */)
    override fun sendMessage(to: String, content: String) { /* ... */ }
    override fun blockUser(userId: String) { /* ... */ }
}

// Android SDK 中的接口设计 —— 每个接口只关注一种事件
view.setOnClickListener { /* 点击 */ }           // View.OnClickListener —— 1 个方法
view.setOnLongClickListener { /* 长按 */ }       // View.OnLongClickListener —— 1 个方法
view.setOnTouchListener { _, _ -> false }         // View.OnTouchListener —— 1 个方法
view.setOnDragListener { _, _ -> false }          // View.OnDragListener —— 1 个方法
view.setOnKeyListener { _, _, _ -> false }        // View.OnKeyListener —— 1 个方法

// Android SDK 中的 TextWatcher —— 包含 3 个方法
public interface TextWatcher extends NoCopySpan {
    void beforeTextChanged(CharSequence s, int start, int count, int after);
    void onTextChanged(CharSequence s, int start, int before, int count);
    void afterTextChanged(Editable s);
}

// Kotlin 中声明 SAM 接口
fun interface OnItemSelected {
    fun onSelected(position: Int)       // 只有一个抽象方法
}
 
// 使用时可以直接用 lambda 替代
adapter.setOnItemSelectedListener { position ->
    // 处理选中事件
}

// ❌ 反面案例：ViewModel 直接依赖具体的数据库实现类
class UserViewModel : ViewModel() {
 
    // 直接 new 出具体的数据库 Helper —— 高层直接依赖低层
    private val dbHelper = UserDatabaseHelper()     // ❌ 硬编码依赖
 
    fun getUser(id: String): LiveData<User> {
        val user = dbHelper.queryUserById(id)       // 直接调用具体方法
        return MutableLiveData(user)
    }
}
 
// 问题：
// 1. 如果要从 SQLite 换成 Room —— 必须修改 ViewModel
// 2. 如果要加网络缓存层 —— 必须修改 ViewModel
// 3. 单元测试时无法 mock 数据源 —— 因为是 new 出来的，无法替换
// 4. ViewModel（高层业务逻辑）和 SQLite（低层存储细节）紧密耦合

// ✅ 正面案例 — Step 1: 定义抽象接口（高层与低层之间的契约）
// 这个接口由"高层"定义，表达的是高层需要什么能力
interface UserRepository {
    suspend fun getUserById(id: String): User?       // 获取用户
    suspend fun saveUser(user: User)                 // 保存用户
    suspend fun deleteUser(id: String)               // 删除用户
}

// ✅ 正面案例 — Step 2: 低层模块实现抽象接口
// Room 实现
class RoomUserRepository(
    private val userDao: UserDao                     // Room DAO
) : UserRepository {
    override suspend fun getUserById(id: String): User? {
        return userDao.findById(id)?.toDomainModel() // Entity -> Domain Model
    }
    override suspend fun saveUser(user: User) {
        userDao.insert(user.toEntity())              // Domain Model -> Entity
    }
    override suspend fun deleteUser(id: String) {
        userDao.deleteById(id)
    }
}
 
// 网络实现（同一个接口，不同的底层技术）
class RemoteUserRepository(
    private val apiService: UserApiService           // Retrofit 接口
) : UserRepository {
    override suspend fun getUserById(id: String): User? {
        return apiService.fetchUser(id)              // 从网络获取
    }
    override suspend fun saveUser(user: User) {
        apiService.updateUser(user)                  // 上传到服务器
    }
    override suspend fun deleteUser(id: String) {
        apiService.deleteUser(id)                    // 远程删除
    }
}

// ✅ 正面案例 — Step 3: 高层模块依赖抽象（通过构造函数注入）
class UserViewModel(
    private val repository: UserRepository           // ✅ 依赖抽象接口，不依赖具体实现
) : ViewModel() {
 
    private val _user = MutableStateFlow<User?>(null)
    val user: StateFlow<User?> = _user.asStateFlow()
 
    fun loadUser(id: String) {
        viewModelScope.launch {
            _user.value = repository.getUserById(id) // 调用抽象方法
            // ViewModel 完全不知道数据来自 Room 还是网络
            // 未来切换数据源时，这里的代码零修改
        }
    }
}

// ✅ 正面案例 — Step 4: 在 DI 层（Hilt/Koin）进行装配
// 使用 Hilt 的示例
@Module
@InstallIn(SingletonComponent::class)               // 全局单例作用域
abstract class RepositoryModule {
 
    @Binds                                            // 告诉 Hilt：当需要 UserRepository 时
    @Singleton                                        // 单例
    abstract fun bindUserRepository(
        impl: RoomUserRepository                      // 注入 RoomUserRepository 实现
    ): UserRepository                                 // 返回抽象接口类型
}
 
// 切换实现只需修改 DI 配置，ViewModel 和所有调用方代码零改动：
// impl: RoomUserRepository → impl: RemoteUserRepository

// ❌ 违反迪米特法则：链式穿透访问
// Activity 直接"穿透"了 UserManager → User → Address → city
// Activity 不仅知道 UserManager，还知道 User 的内部结构，甚至 Address 的字段
val cityName = userManager.getCurrentUser().getAddress().getCity()

// === 数据层：Address 类 ===
data class Address(
    val city: String,       // 城市名
    val district: String    // 区县名
)
 
// === 数据层：User 类 ===
// User 封装了从自身获取城市的能力，外部无需知道 Address 的存在
data class User(
    val name: String,       // 用户名
    val address: Address    // 地址（内部细节）
) {
    // ✅ User 自己提供 "获取城市" 的方法
    // 外部无需知道 address 字段的结构
    fun getCity(): String = address.city
}
 
// === 业务层：UserManager ===
// UserManager 对外只暴露"最终结果"，隐藏 User 的获取细节
class UserManager(
    private val userRepository: UserRepository  // 数据仓库（直接朋友）
) {
    // ✅ 封装了获取当前用户城市的完整链路
    // Activity 只需调用这一个方法即可
    fun getCurrentUserCity(): String {
        val user = userRepository.getCurrentUser()  // 获取用户对象
        return user.getCity()                        // 委托 User 获取城市
    }
}
 
// === 表现层：Activity ===
class ProfileActivity : AppCompatActivity() {
 
    // UserManager 是 Activity 的"直接朋友"
    private lateinit var userManager: UserManager
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
 
        // ✅ 只与直接朋友通信，一步到位
        // Activity 完全不知道 User、Address 的存在
        val city = userManager.getCurrentUserCity()
        binding.tvCity.text = city  // 直接展示
    }
}

// ✅ 通过 Context 这个"直接朋友"获取系统服务
// 你不需要了解 ServiceManager、IBinder、AIDL Proxy 等底层细节
val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE)
    as ConnectivityManager

// === 基础网络请求类 ===
open class BaseHttpClient {
    // 发送 GET 请求
    open fun get(url: String): String {
        println("HTTP GET: $url")  // 日志输出
        return "response"           // 模拟返回
    }
 
    // 发送 POST 请求
    open fun post(url: String, body: String): String {
        println("HTTP POST: $url") // 日志输出
        return "response"           // 模拟返回
    }
}
 
// ❌ 通过继承来添加"缓存"功能
// CachedHttpClient "is-a" BaseHttpClient？语义上不太对
// 缓存和 HTTP 请求是两个独立的关注点
class CachedHttpClient : BaseHttpClient() {
 
    private val cache = mutableMapOf<String, String>()  // 简单内存缓存
 
    // 覆写 get，加入缓存逻辑
    override fun get(url: String): String {
        // 先查缓存
        cache[url]?.let { return it }
        // 缓存未命中，调用父类实际请求
        val response = super.get(url)
        cache[url] = response  // 写入缓存
        return response
    }
}
 
// ❌ 再通过继承添加"认证"功能
// AuthCachedHttpClient 同时需要缓存和认证
// 必须继承 CachedHttpClient，形成脆弱的层级链
class AuthCachedHttpClient : CachedHttpClient() {
 
    private var token: String = ""  // 认证令牌
 
    // 覆写 get，加入认证 Header
    override fun get(url: String): String {
        println("Adding auth token: $token")  // 注入认证信息
        return super.get(url)                  // 委托给带缓存的父类
    }
}

// === 拦截器接口：定义统一的"处理切面" ===
// 每个拦截器只负责一个关注点
interface Interceptor {
    // 拦截处理，chain 允许将请求传递给下一个拦截器
    fun intercept(chain: Chain): Response
 
    // 链接口，负责串联多个拦截器
    interface Chain {
        fun request(): Request           // 获取当前请求
        fun proceed(request: Request): Response  // 传递给下一个拦截器
    }
}
 
// === 缓存拦截器：只负责缓存 ===
class CacheInterceptor(
    private val cache: Cache  // 通过构造器注入缓存实现（又是组合！）
) : Interceptor {
 
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()                   // 获取请求
        val cachedResponse = cache.get(request)         // 查询缓存
 
        if (cachedResponse != null) {
            return cachedResponse                       // 命中缓存，直接返回
        }
 
        val response = chain.proceed(request)           // 未命中，传递给下一个拦截器
        cache.put(request, response)                    // 将结果写入缓存
        return response                                 // 返回响应
    }
}
 
// === 认证拦截器：只负责认证 ===
class AuthInterceptor(
    private val tokenProvider: () -> String  // 令牌提供者（函数式组合）
) : Interceptor {
 
    override fun intercept(chain: Interceptor.Chain): Response {
        val originalRequest = chain.request()           // 获取原始请求
 
        // 在请求头中添加认证令牌
        val authenticatedRequest = originalRequest.newBuilder()
            .addHeader("Authorization", "Bearer ${tokenProvider()}")  // 注入 token
            .build()
 
        return chain.proceed(authenticatedRequest)      // 传递修改后的请求
    }
}
 
// === 日志拦截器：只负责日志 ===
class LogInterceptor : Interceptor {
 
    override fun intercept(chain: Interceptor.Chain): Response {
        val request = chain.request()
        println("➡️ Sending: ${request.url}")           // 打印请求日志
 
        val startTime = System.nanoTime()               // 记录开始时间
        val response = chain.proceed(request)           // 传递给下一个拦截器
        val duration = (System.nanoTime() - startTime) / 1e6  // 计算耗时
 
        println("⬅️ Received: ${response.code} in ${duration}ms")  // 打印响应日志
        return response
    }
}

// === 使用组合构建 HttpClient ===
val client = OkHttpClient.Builder()
    .addInterceptor(LogInterceptor())                       // ✅ 添加日志
    .addInterceptor(AuthInterceptor { "my-secret-token" })  // ✅ 添加认证
    .addInterceptor(CacheInterceptor(diskCache))            // ✅ 添加缓存
    .build()
 
// 想要一个不带缓存的客户端？直接去掉那一行即可！
val noCacheClient = OkHttpClient.Builder()
    .addInterceptor(LogInterceptor())                       // ✅ 只要日志
    .addInterceptor(AuthInterceptor { "my-secret-token" })  // ✅ 和认证
    .build()

// === Android Framework: Window.java（简化）===
// Window 类通过组合持有 Callback，而非要求 Activity 继承 Window
public abstract class Window {
 
    // ✅ 组合：Window 持有一个 Callback 接口引用
    // Activity 实现此接口，Window 通过组合调用 Activity 的回调
    private Callback mCallback;  // "has-a" 关系
 
    // Callback 接口定义了 Window 与上层的通信协议
    public interface Callback {
        boolean dispatchKeyEvent(KeyEvent event);     // 按键事件分发
        boolean dispatchTouchEvent(MotionEvent event); // 触摸事件分发
        void onWindowFocusChanged(boolean hasFocus);   // 焦点变化通知
    }
 
    // 设置回调——运行时可替换！
    public void setCallback(Callback callback) {
        mCallback = callback;  // 动态绑定
    }
}
 
// Activity 实现 Window.Callback，而非继承 Window
// 这正是"组合优于继承"的体现
// public class Activity extends ContextThemeWrapper
//     implements Window.Callback, ... { }

// ✅ 正确使用继承：真正的 "is-a" 关系
// AppCompatActivity 确实"是一个" Activity
class MainActivity : AppCompatActivity() { /* ... */ }
 
// ✅ 正确使用继承：框架要求的模板方法模式
// 自定义 View 确实"是一个" View
class CircleImageView : ImageView(context, attrs) {
    override fun onDraw(canvas: Canvas) {  // 模板方法
        // 自定义绘制逻辑
    }
}
 
// ✅ 正确使用继承：密封类层级（Kotlin Sealed Class）
// 代表有限的、封闭的类型集合
sealed class UiState {               // 密封类定义状态集
    object Loading : UiState()        // 加载中——"是一种" UiState
    data class Success(val data: Any) : UiState()  // 成功
    data class Error(val msg: String) : UiState()  // 失败
}

// === 1. 委托模式：by 关键字 ===
// Kotlin 的 "by" 可以零成本实现组合式委托
// 不需要手动编写所有委托方法
interface Logger {
    fun log(message: String)  // 日志接口
}
 
// 具体日志实现
class ConsoleLogger : Logger {
    override fun log(message: String) {
        println("[LOG] $message")  // 控制台输出
    }
}
 
// ✅ UserService 通过 "by" 委托给 consoleLogger
// 编译器自动生成所有接口方法的委托代码
// 这既是组合（has-a ConsoleLogger），又拥有继承的便捷语法
class UserService(
    consoleLogger: ConsoleLogger  // 通过构造器注入
) : Logger by consoleLogger {
    // UserService 自动拥有 log() 方法
    // 但无需手写 override fun log(msg) = consoleLogger.log(msg)
 
    fun createUser(name: String) {
        log("Creating user: $name")  // 直接调用委托方法
    }
}
 
// === 2. 扩展函数：不修改原类即可"添加"功能 ===
// 这也是组合思想的体现——不通过继承来扩展类
fun ImageView.loadUrl(url: String) {
    Glide.with(this.context)    // 获取 Glide 实例
        .load(url)              // 加载图片 URL
        .into(this)             // 设置到当前 ImageView
}
// 使用：imageView.loadUrl("https://example.com/photo.jpg")
 
// === 3. 高阶函数：行为参数化 ===
// 将"行为"作为参数传入，而非通过继承覆写
inline fun <T> measureTimeAndExecute(
    tag: String,           // 标签名
    block: () -> T         // 要执行的代码块（行为参数化）
): T {
    val start = System.currentTimeMillis()  // 记录开始时间
    val result = block()                     // 执行代码块
    val elapsed = System.currentTimeMillis() - start  // 计算耗时
    Log.d(tag, "Executed in ${elapsed}ms")   // 输出日志
    return result                             // 返回结果
}
 
// 使用
val users = measureTimeAndExecute("DB") {
    database.userDao().getAllUsers()  // 实际的数据库操作
}

class OrderActivity : AppCompatActivity() {
    fun showPrice() {
        val price = orderManager.getOrder().getItem().getPrice()
        binding.tvPrice.text = price.toString()
    }
}

// ❌ 坏味道 1：God Class（违反 SRP）
// 一个 Activity 同时处理 UI、网络请求、数据库操作、业务逻辑
class OrderActivity : AppCompatActivity() {
    // 500 行 UI 代码...
    // 300 行网络请求代码...
    // 200 行数据库代码...
    // 400 行业务逻辑代码...
}
 
// ❌ 坏味道 2：Switch/When 类型判断泛滥（违反 OCP）
// 每新增一种消息类型，都必须修改这个函数
fun handleMessage(type: Int) {
    when (type) {
        1 -> handleText()
        2 -> handleImage()
        3 -> handleVideo()
        // 新增类型 4, 5, 6... 无限 case
    }
}
 
// ❌ 坏味道 3：火车残骸（Train Wreck，违反迪米特法则）
// 调用链暴露了内部结构，任何中间层的改动都会波及这里
val cityName = order.getCustomer().getAddress().getCity().getName()
 
// ❌ 坏味道 4：继承仅为复用代码（违反合成复用 + LSP）
// BaseActivity 塞满各种工具方法，子类"是一个"关系根本不成立
open class BaseActivity : AppCompatActivity() {
    fun showToast(msg: String) { /* ... */ }       // 工具方法
    fun checkNetwork(): Boolean { /* ... */ }       // 工具方法
    fun logEvent(event: String) { /* ... */ }       // 工具方法
    // 30 个与 Activity 生命周期无关的工具方法...
}

// ✅ 修正方向汇总
 
// SRP：拆分到 ViewModel + UseCase + Repository
// OCP：用多态（策略模式/工厂模式）替代 when
// 迪米特：提供高层方法 order.getCityName()，封装内部链路
// 合成复用：把工具方法提取为独立工具类，通过组合注入使用
 
// 例：用组合替代 BaseActivity 里的工具方法
class ToastHelper @Inject constructor(           // 独立的 Toast 工具
    private val context: Context                  // 只依赖必要的 Context
) {
    fun show(msg: String) {                       // 单一职责：只管 Toast
        Toast.makeText(context, msg, Toast.LENGTH_SHORT).show()
    }
}
 
class NetworkChecker @Inject constructor(        // 独立的网络检测工具
    private val connectivityManager: ConnectivityManager
) {
    fun isAvailable(): Boolean {                  // 单一职责：只管网络状态
        return connectivityManager.activeNetwork != null
    }
}
 
// Activity 通过组合使用，而非继承获取
class OrderActivity : AppCompatActivity() {
    @Inject lateinit var toastHelper: ToastHelper          // 组合注入
    @Inject lateinit var networkChecker: NetworkChecker     // 组合注入
 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (!networkChecker.isAvailable()) {               // 清晰使用
            toastHelper.show("No network")                 // 职责明确
        }
    }
}

class UserManager {
    fun login(username: String, password: String) { /* 网络请求登录 */ }
    fun saveUserToDb(user: User) { /* 操作数据库 */ }
    fun formatUserName(name: String): String { /* 格式化展示 */ }
    fun sendAnalyticsEvent(event: String) { /* 发送埋点 */ }
}