Android 设计模式实战手册（Kotlin 实战版）

Jeled
56 阅读9分钟

​

 目录

创建型模式（5种）

  1. 单例模式（Singleton）
  2. 工厂方法模式（Factory Method）
  3. 抽象工厂模式（Abstract Factory）
  4. 建造者模式（Builder）
  5. 原型模式（Prototype）

结构型模式（7种）

  1. 适配器模式（Adapter）
  2. 装饰器模式（Decorator）
  3. 代理模式（Proxy）
  4. 外观模式（Facade）
  5. 桥接模式（Bridge）
  6. 组合模式（Composite）
  7. 享元模式（Flyweight）

行为型模式（11种）

  1. 观察者模式（Observer）
  2. 策略模式（Strategy）
  3. 命令模式（Command）
  4. 模板方法模式（Template Method）
  5. 责任链模式（Chain of Responsibility）
  6. 状态模式（State）
  7. 解释器模式（Interpreter）
  8. 中介者模式（Mediator）
  9. 访问者模式（Visitor）
  10. 备忘录模式（Memento）
  11. 迭代器模式（Iterator）

第一部分：创建型模式

序号模式Android 实例
1单例模式 (Singleton)Retrofit、Glide
2工厂方法模式 (Factory Method)Fragment.newInstance()
3抽象工厂模式 (Abstract Factory)不同 Theme 创建 View
4建造者模式 (Builder)AlertDialog、OkHttp
5原型模式 (Prototype)Bundle、Intent.clone

1️⃣ 单例模式（Singleton）

设计意图：保证一个类只有一个实例，并提供全局访问点。

Android 场景：

  • Retrofit 单例管理网络请求
  • Glide 图片加载单例
  • App 全局配置对象

Kotlin 实战示例：

// Retrofit 单例封装
object RetrofitManager {
    val retrofit by lazy {
        retrofit2.Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .addConverterFactory(retrofit2.converter.gson.GsonConverterFactory.create())
            .build()
    }

    val apiService by lazy { retrofit.create(ApiService::class.java) }
}

优缺点：

  • ✅ 优点：全局唯一，节省资源，懒加载可提高性能
  • ❌ 缺点：难以单元测试，可能隐藏全局状态依赖

2️⃣ 工厂方法模式（Factory Method）

设计意图：定义一个创建对象的接口，由子类决定实例化哪一个类。

Android 场景：

  • Fragment.newInstance()
  • 不同类型 View / ViewHolder 创建

Kotlin 实战示例：

// Fragment 工厂方法
class UserFragment : Fragment() {
    companion object {
        fun newInstance(userId: String): UserFragment {
            val fragment = UserFragment()
            val bundle = Bundle()
            bundle.putString("userId", userId)
            fragment.arguments = bundle
            return fragment
        }
    }
}

优缺点：

  • ✅ 优点：解耦对象创建逻辑，增加扩展性
  • ❌ 缺点：增加类的复杂度

3️⃣ 抽象工厂模式（Abstract Factory）

设计意图：提供一个创建一系列相关或依赖对象的接口，而无需指定具体类。

Android 场景：

  • 不同主题风格下创建 Button / TextView / RecyclerView

Kotlin 实战示例：

interface ThemeFactory {
    fun createButton(): Button
    fun createTextView(): TextView
}

class LightThemeFactory(val context: Context): ThemeFactory {
    override fun createButton() = Button(context).apply { setBackgroundColor(Color.WHITE) }
    override fun createTextView() = TextView(context).apply { setTextColor(Color.BLACK) }
}

class DarkThemeFactory(val context: Context): ThemeFactory {
    override fun createButton() = Button(context).apply { setBackgroundColor(Color.BLACK) }
    override fun createTextView() = TextView(context).apply { setTextColor(Color.WHITE) }
}

优缺点：

  • ✅ 优点：易于切换产品族
  • ❌ 缺点：增加类数量，使用复杂

4️⃣ 建造者模式（Builder）

设计意图：将复杂对象的构建与表示分离，使同样的构建过程可以创建不同表示。

Android 场景：

  • AlertDialog.Builder
  • OkHttpClient.Builder

Kotlin 实战示例：

// AlertDialog 示例
val dialog = AlertDialog.Builder(context)
    .setTitle("提示")
    .setMessage("是否退出?")
    .setPositiveButton("确认") { _, _ -> }
    .setNegativeButton("取消") { _, _ -> }
    .create()
dialog.show()

优缺点：

  • ✅ 优点：可读性好，易于扩展
  • ❌ 缺点：构建步骤多，增加代码量

5️⃣ 原型模式（Prototype）

设计意图：通过复制已有对象来创建新对象，减少重复初始化。

Android 场景：

  • Intent / Bundle 克隆
  • 数据对象复制

Kotlin 实战示例：

data class User(val name: String, val age: Int): Cloneable {
    public override fun clone(): User {
        return copy()
    }
}

val user1 = User("Tom", 18)
val user2 = user1.clone()

优缺点：

  • ✅ 优点：快速创建对象，避免重复初始化
  • ❌ 缺点：深拷贝复杂对象时需要额外处理

第二部分：结构型模式（7种）

序号模式Android 实例
6适配器模式 (Adapter)RecyclerView.Adapter
7装饰器模式 (Decorator)ContextWrapper、InputStream
8代理模式 (Proxy)Retrofit 动态代理
9外观模式 (Facade)LiveData 封装、Room
10桥接模式 (Bridge)View 与 Drawable
11组合模式 (Composite)ViewGroup、布局树
12享元模式 (Flyweight)Bitmap 复用、String 常量池

6️⃣ 适配器模式（Adapter）

设计意图：将一个类的接口转换成客户端期望的接口，使原本接口不兼容的类可以一起工作。

Android 场景：

  • RecyclerView.Adapter 对不同数据源适配
  • 第三方 SDK 接口封装

Kotlin 实战示例：

// 第三方数据模型
data class ThirdPartyUser(val username: String, val email: String)

// 项目内部数据模型
data class User(val name: String, val mail: String)

// Adapter 将 ThirdPartyUser 转换成 User
class UserAdapter(private val thirdPartyUsers: List<ThirdPartyUser>) {
    fun getUsers(): List<User> {
        return thirdPartyUsers.map { User(it.username, it.email) }
    }
}

优缺点：

  • ✅ 优点：提高兼容性，复用已有类
  • ❌ 缺点：增加适配层，复杂性略高

7️⃣ 装饰器模式（Decorator）

设计意图：动态地给对象添加额外职责，而不改变原对象结构。

Android 场景：

  • TextView 或 ImageView 增加动态效果
  • 网络请求添加日志、缓存

Kotlin 实战示例：

interface ImageLoader {
    fun load(url: String)
}

// 基本实现
class BasicImageLoader: ImageLoader {
    override fun load(url: String) {
        println("Load image: $url")
    }
}

// 装饰器
class CacheImageLoader(private val loader: ImageLoader): ImageLoader {
    private val cache = mutableMapOf<String, String>()
    override fun load(url: String) {
        if (cache.containsKey(url)) {
            println("Load from cache: $url")
        } else {
            loader.load(url)
            cache[url] = url
        }
    }
}

// 使用
val loader = CacheImageLoader(BasicImageLoader())
loader.load("https://example.com/img.png")

优缺点：

  • ✅ 优点：灵活扩展对象功能
  • ❌ 缺点：多层装饰可能难以管理

8️⃣ 代理模式（Proxy）

设计意图：为其他对象提供一种代理以控制对这个对象的访问。

Android 场景：

  • 图片延迟加载 / 缓存代理
  • 权限控制 / 网络请求代理

Kotlin 实战示例：

interface NetworkService {
    fun request(url: String)
}

class RealNetworkService: NetworkService {
    override fun request(url: String) {
        println("Requesting $url")
    }
}

// 代理
class NetworkProxy(private val realService: NetworkService): NetworkService {
    private val cache = mutableMapOf<String, String>()
    override fun request(url: String) {
        if (cache.containsKey(url)) {
            println("Return cached: $url")
        } else {
            realService.request(url)
            cache[url] = url
        }
    }
}

val service = NetworkProxy(RealNetworkService())
service.request("https://example.com")
service.request("https://example.com") // 使用缓存

优缺点：

  • ✅ 优点：增强对象功能，控制访问
  • ❌ 缺点：增加代理层

9️⃣ 外观模式（Facade）

设计意图：为子系统的一组接口提供一个统一的高层接口，使子系统更易使用。

Android 场景：

  • 多个 SDK 统一封装
  • ViewModel 与 Repository 交互

Kotlin 实战示例：

class VideoSDK {
    fun init() = println("VideoSDK init")
    fun play() = println("VideoSDK play")
}

class AudioSDK {
    fun init() = println("AudioSDK init")
    fun play() = println("AudioSDK play")
}

// 外观
class MediaFacade(private val video: VideoSDK, private val audio: AudioSDK) {
    fun playAll() {
        video.init()
        audio.init()
        video.play()
        audio.play()
    }
}

val facade = MediaFacade(VideoSDK(), AudioSDK())
facade.playAll()

优缺点：

  • ✅ 优点：简化复杂系统接口
  • ❌ 缺点：降低系统灵活性

1️⃣0️⃣ 桥接模式（Bridge）

设计意图：将抽象部分与实现部分分离，使它们可以独立变化。

Android 场景：

  • 多种主题皮肤 + 多种控件实现

Kotlin 实战示例：

// 抽象
abstract class Shape(protected val drawAPI: DrawAPI) {
    abstract fun draw()
}

// 实现接口
interface DrawAPI {
    fun drawShape(shape: String)
}

// 具体实现
class RedCircle: DrawAPI {
    override fun drawShape(shape: String) {
        println("Draw Red $shape")
    }
}

class Circle(drawAPI: DrawAPI): Shape(drawAPI) {
    override fun draw() {
        drawAPI.drawShape("Circle")
    }
}

val circle = Circle(RedCircle())
circle.draw() // Draw Red Circle

优缺点：

  • ✅ 优点：抽象与实现独立扩展
  • ❌ 缺点：增加类数量

1️⃣1️⃣ 组合模式（Composite）

设计意图：将对象组合成树形结构以表示“部分-整体”的层次结构。

Android 场景：

  • ViewGroup 与 View 关系
  • RecyclerView 多级列表

Kotlin 实战示例：

interface Component {
    fun show()
}

class Leaf(val name: String): Component {
    override fun show() = println("Leaf $name")
}

class Composite: Component {
    private val children = mutableListOf<Component>()
    fun add(child: Component) = children.add(child)
    override fun show() = children.forEach { it.show() }
}

// 使用
val root = Composite()
root.add(Leaf("A"))
root.add(Leaf("B"))
val sub = Composite()
sub.add(Leaf("C"))
root.add(sub)
root.show()

优缺点：

  • ✅ 优点：处理树形结构灵活
  • ❌ 缺点：设计复杂，调试难

1️⃣2️⃣ 享元模式（Flyweight）

设计意图：通过共享对象减少内存开销。

Android 场景：

  • 大量重复图像 / 字符对象
  • RecyclerView 图片复用

Kotlin 实战示例：

class Flyweight(val intrinsic: String)

class FlyweightFactory {
    private val pool = mutableMapOf<String, Flyweight>()
    fun getFlyweight(key: String): Flyweight {
        return pool.getOrPut(key) { Flyweight(key) }
    }
}

val factory = FlyweightFactory()
val fw1 = factory.getFlyweight("A")
val fw2 = factory.getFlyweight("A") // 同一个实例
println(fw1 === fw2) // true

优缺点：

  • ✅ 优点：节省内存，提高性能
  • ❌ 缺点：增加管理复杂度

第三部分：行为型模式（11种）

序号模式Android 实例
13观察者模式 (Observer)LiveData、EventBus、RxJava
14策略模式 (Strategy)图片加载策略、LayoutManager
15命令模式 (Command)点击事件、Handler Message
16模板方法模式 (Template Method)BaseActivity、AsyncTask
17责任链模式 (Chain of Responsibility)OkHttp 拦截器、事件分发
18状态模式 (State)MediaPlayer 状态管理
19解释器模式 (Interpreter)正则、XML 解析
20中介者模式 (Mediator)ViewModel + View
21访问者模式 (Visitor)View 树遍历
22备忘录模式 (Memento)onSaveInstanceState()
23迭代器模式 (Iterator)Cursor、集合遍历

1️⃣3️⃣模板方法模式（Template Method）

设计意图：在父类中定义算法骨架，将部分步骤延迟到子类实现。

Android 场景：

  • 自定义网络请求模板
  • Activity / Fragment 生命周期统一处理

Kotlin 实战示例：

abstract class NetworkRequest {
    fun execute() {
        onStart()
        request()
        onEnd()
    }

    abstract fun request()
    open fun onStart() = println("Request start")
    open fun onEnd() = println("Request end")
}

class GetUserRequest: NetworkRequest() {
    override fun request() {
        println("GET /user")
    }
}

val req = GetUserRequest()
req.execute()
// Output:
// Request start
// GET /user
// Request end

1️⃣4️⃣ 策略模式（Strategy）

设计意图：定义一系列算法，将每个算法封装起来，使它们可互换。

Android 场景：

  • 图片加载策略（Glide / Coil）
  • 支付方式策略（微信 / 支付宝 / 银联）

Kotlin 实战示例：

interface PaymentStrategy {
    fun pay(amount: Double)
}

class WeChatPay: PaymentStrategy {
    override fun pay(amount: Double) = println("WeChat pay $amount")
}

class Alipay: PaymentStrategy {
    override fun pay(amount: Double) = println("Alipay pay $amount")
}

class PaymentContext(private var strategy: PaymentStrategy) {
    fun setStrategy(strategy: PaymentStrategy) { this.strategy = strategy }
    fun pay(amount: Double) = strategy.pay(amount)
}

val context = PaymentContext(WeChatPay())
context.pay(100.0)
context.setStrategy(Alipay())
context.pay(200.0)

1️⃣5️⃣ 观察者模式（Observer）

设计意图：对象间一对多依赖，当对象状态变化时，所有依赖者自动收到通知。

Android 场景：

  • LiveData / StateFlow
  • EventBus

Kotlin 实战示例：

interface Observer {
    fun update(message: String)
}

class UserObserver(val name: String): Observer {
    override fun update(message: String) = println("$name received: $message")
}

class Subject {
    private val observers = mutableListOf<Observer>()
    fun addObserver(o: Observer) = observers.add(o)
    fun removeObserver(o: Observer) = observers.remove(o)
    fun notify(message: String) = observers.forEach { it.update(message) }
}

val subject = Subject()
val user1 = UserObserver("User1")
val user2 = UserObserver("User2")
subject.addObserver(user1)
subject.addObserver(user2)
subject.notify("Hello observers!")

1️⃣6️⃣ 迭代器模式（Iterator）

设计意图：提供一种方法顺序访问集合对象，而不暴露其内部表示。

Android 场景：

  • RecyclerView 数据迭代
  • 自定义集合遍历

Kotlin 实战示例：

class MyCollection(private val items: List<String>) {
    fun iterator(): Iterator<String> = items.iterator()
}

val collection = MyCollection(listOf("A", "B", "C"))
val it = collection.iterator()
while (it.hasNext()) println(it.next())

1️⃣7️⃣ 命令模式（Command）

设计意图：将请求封装成对象，从而使你可用不同请求、队列或日志请求。

Android 场景：

  • 按钮点击操作封装
  • Undo/Redo 功能

Kotlin 实战示例：

interface Command {
    fun execute()
}

class Light {
    fun on() = println("Light ON")
    fun off() = println("Light OFF")
}

class LightOnCommand(private val light: Light): Command {
    override fun execute() = light.on()
}

class LightOffCommand(private val light: Light): Command {
    override fun execute() = light.off()
}

// 使用
val light = Light()
val onCmd = LightOnCommand(light)
val offCmd = LightOffCommand(light)
onCmd.execute()  // Light ON
offCmd.execute() // Light OFF

1️⃣8️⃣ 状态模式（State）

设计意图：允许对象在内部状态改变时改变行为，表现为不同状态的行为切换。

Android 场景：

  • 播放器状态（播放、暂停、停止）
  • 登录状态

Kotlin 实战示例：

interface State {
    fun handle(context: Player)
}

class PlayingState: State {
    override fun handle(context: Player) = println("Player is playing")
}

class PausedState: State {
    override fun handle(context: Player) = println("Player is paused")
}

class Player {
    var state: State = PausedState()
    fun pressPlay() = state.handle(this)
}

val player = Player()
player.pressPlay() // Player is paused
player.state = PlayingState()
player.pressPlay() // Player is playing

1️⃣9️⃣ 中介者模式（Mediator）

设计意图：用一个中介对象来封装一系列对象交互，降低耦合。

Android 场景：

  • UI 控件交互
  • 消息中心

Kotlin 实战示例：

interface Mediator {
    fun notify(sender: Component, event: String)
}

open class Component(protected val mediator: Mediator)

class Button(mediator: Mediator): Component(mediator) {
    fun click() = mediator.notify(this, "click")
}

class TextView(mediator: Mediator): Component(mediator) {
    fun update(text: String) = println("TextView updated: $text")
}

class ConcreteMediator: Mediator {
    lateinit var button: Button
    lateinit var textView: TextView
    override fun notify(sender: Component, event: String) {
        if (event == "click") textView.update("Button clicked")
    }
}

val mediator = ConcreteMediator()
val button = Button(mediator)
val textView = TextView(mediator)
mediator.button = button
mediator.textView = textView
button.click() // TextView updated: Button clicked

2️⃣0 备忘录模式（Memento）

设计意图：在不暴露对象实现细节的情况下，捕获对象状态，以便恢复。

Android 场景：

  • 编辑器撤销/重做
  • 游戏存档

Kotlin 实战示例：

data class Memento(val state: String)

class Editor(var state: String) {
    fun save(): Memento = Memento(state)
    fun restore(m: Memento) { state = m.state }
}

val editor = Editor("State1")
val memento = editor.save()
editor.state = "State2"
editor.restore(memento)
println(editor.state) // State1

2️⃣1️⃣ 解释器模式（Interpreter）

设计意图：给定一个语言，定义它的文法，并实现解释器。

Android 场景：

  • 表达式计算
  • 自定义 DSL

Kotlin 实战示例：

interface Expression {
    fun interpret(): Int
}

class Number(private val number: Int): Expression {
    override fun interpret() = number
}

class Add(private val left: Expression, private val right: Expression): Expression {
    override fun interpret() = left.interpret() + right.interpret()
}

// 使用
val expression = Add(Number(1), Add(Number(2), Number(3)))
println(expression.interpret()) // 6

2️⃣2️⃣ 访问者模式（Visitor）

设计意图：封装作用于对象结构的操作，使得在不修改结构的情况下可以增加新操作。

Android 场景：

  • 数据结构操作
  • JSON/XML 解析

Kotlin 实战示例：

interface Visitor {
    fun visit(element: Element)
}

interface Element {
    fun accept(visitor: Visitor)
}

class FileElement(val name: String): Element {
    override fun accept(visitor: Visitor) = visitor.visit(this)
}

class PrintVisitor: Visitor {
    override fun visit(element: Element) {
        if (element is FileElement) println("Visiting file: ${element.name}")
    }
}

// 使用
val file = FileElement("test.txt")
file.accept(PrintVisitor())

2️⃣3️⃣ 职责链模式（Chain of Responsibility）

设计意图：使多个对象都有机会处理请求，避免请求发送者和接收者耦合。

Android 场景：

  • 网络请求拦截器
  • 日志处理链

Kotlin 实战示例：

abstract class Handler {
    var next: Handler? = null
    abstract fun handle(request: Int)
}

class PositiveHandler: Handler() {
    override fun handle(request: Int) {
        if (request > 0) println("PositiveHandler: $request")
        else next?.handle(request)
    }
}

class NegativeHandler: Handler() {
    override fun handle(request: Int) {
        if (request < 0) println("NegativeHandler: $request")
        else next?.handle(request)
    }
}

// 使用
val pos = PositiveHandler()
val neg = NegativeHandler()
pos.next = neg
pos.handle(-1) // NegativeHandler: -1
pos.handle(10) // PositiveHandler: 10

​

avatar
文章
阅读
粉丝