Android常用的设计模式及其应用场景

原创已于 2025-10-21 13:36:24 修改 · 置顶 · 2k 阅读

29 ·

CC 4.0 BY-SA版权

文章标签：

#android

于 2025-10-16 00:13:21 首次发布

一、创建型模式

1. 单例模式（Singleton）

定义：确保一个类只有一个实例，并提供全局访问点。
应用场景：
- 全局状态管理（如用户信息、配置信息）。
- 资源密集型对象（如网络请求客户端、数据库连接）。
- Android中的Application类本质是单例。

示例代码：

class NetworkManager private constructor() {
    companion object {
        val instance: NetworkManager by lazy { NetworkManager() }
    }
    // 网络请求相关方法
}

2. 工厂模式（Factory）

定义：定义一个创建对象的接口，由子类决定实例化哪个类。
应用场景：
- BitmapFactory用于创建Bitmap对象。
- 自定义组件时，通过工厂创建不同类型的View。

示例代码：

interface ViewFactory {
    fun createView(): View
}
class TextViewFactory : ViewFactory {
    override fun createView(): View = TextView(context)
}

3. 建造者模式（Builder）

定义：分步骤构建复杂对象，隐藏创建细节。
应用场景：
- Android中的AlertDialog.Builder。
- 自定义复杂对象的构建过程（如Request对象）。

示例代码：

class AlertDialogBuilder {
    private var title: String = ""
    private var message: String = ""
    fun setTitle(title: String): AlertDialogBuilder {
        this.title = title
        return this
    }
    fun setMessage(message: String): AlertDialogBuilder {
        this.message = message
        return this
    }
    fun build(): AlertDialog {
        return AlertDialog(title, message)
    }
}

二、结构型模式

4. 适配器模式（Adapter）

定义：将一个接口转换为另一个接口，使不兼容的类可以协作。
应用场景：
- RecyclerView.Adapter将数据转换为UI组件。
- 适配第三方库与Android原生API的差异。

示例代码：

class MyAdapter(private val dataList: List<String>) : RecyclerView.Adapter<MyAdapter.ViewHolder>() {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        // 创建ViewHolder
    }
    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        holder.bind(dataList[position])
    }
    override fun getItemCount(): Int = dataList.size
}

5. 代理模式（Proxy）

定义：为其他对象提供一种代理以控制对这个对象的访问。
应用场景：
- Android中的Binder机制（AIDL实现跨进程通信）。
- 权限检查代理（如网络请求前检查权限）。

示例代码：

class ImageLoaderProxy(private val realImageLoader: ImageLoader) : ImageLoader {
    override fun loadImage(url: String) {
        if (hasPermission()) {
            realImageLoader.loadImage(url)
        } else {
            requestPermission()
        }
    }
}

6. 组合模式（Composite）

定义：将对象组合成树形结构，表示“部分-整体”的层次结构。
应用场景：
- Android的View和ViewGroup层级关系。

示例代码：

abstract class View {
    abstract fun render()
}
class TextView(context: Context) : View() {
    override fun render() { /* 渲染文本 */ }
}
class LinearLayout(context: Context) : View() {
    private val children = mutableListOf<View>()
    fun addView(view: View) { children.add(view) }
    override fun render() {
        for (child in children) {
            child.render()
        }
    }
}

三、行为型模式

7. 观察者模式（Observer）

定义：定义对象间的一对多依赖关系，当一个对象状态变化时，所有依赖者自动更新。
应用场景：
- LiveData与ViewModel的协同工作。
- 广播接收器（BroadcastReceiver）。

示例代码：

class NewsSubject {
    private val observers = mutableListOf<NewsObserver>()
    fun addObserver(observer: NewsObserver) {
        observers.add(observer)
    }
    fun removeObserver(observer: NewsObserver) {
        observers.remove(observer)
    }
    fun notifyObservers() {
        for (observer in observers) {
            observer.update()
        }
    }
}
interface NewsObserver {
    fun update()
}

8. 策略模式（Strategy）

定义：定义一系列算法，将每个算法封装起来并使其可互换。
应用场景：
- 支付方式切换（如支付宝、微信支付）。
- 排序算法动态选择。

示例代码：

interface PaymentStrategy {
    fun pay(amount: Double)
}
class AlipayStrategy : PaymentStrategy {
    override fun pay(amount: Double) { /* 支付宝支付逻辑 */ }
}
class WeChatPayStrategy : PaymentStrategy {
    override fun pay(amount: Double) { /* 微信支付逻辑 */ }
}
class PaymentContext(private var strategy: PaymentStrategy) {
    fun executePayment(amount: Double) {
        strategy.pay(amount)
    }
}

9. 责任链模式（Chain of Responsibility）

定义：将请求的发送者和接收者解耦，使多个对象都有机会处理请求。
应用场景：
- Android事件分发机制（onTouchEvent）。
- 日志过滤链。

示例代码：

abstract class Handler {
    private var successor: Handler? = null
    fun setSuccessor(successor: Handler) {
        this.successor = successor
    }
    abstract fun handleRequest(request: String)
}
class ConcreteHandler1 : Handler() {
    override fun handleRequest(request: String) {
        if (/* 条件满足 */) {
            // 处理请求
        } else {
            successor?.handleRequest(request)
        }
    }
}