6个Android开发者不可不知的设计模式

本文介绍6种常见的设计模式，并提供解决问题的方法，帮助您提高代码的可重用性和可维护性。

这是作为Android/ target=_blank class=infotextkey>安卓开发者最重要的设计模式。

1 什么是设计模式

设计模式是一种可以重复使用的解决软件工程问题的方案。与许多特定程序的解决方案不同，设计模式可以应用于许多不同的程序中。设计模式不是一个成品，而是一个可以应用于多种情况并随时间改进的模板，是非常强大的软件工程工具。使用经过验证的原型可以提高开发速度，使用设计模式模板的开发人员可以提高编码效率和最终产品的可读性。

2 模式＃1 单例模式

单例模式是一种允许创建唯一实例并访问该实例的类。它包含一个私有的静态变量，可以容纳该类的唯一实例。在需要限制类的实例化为一个对象时，单例模式通常很有用。通常在需要协调系统中操作的单个对象时使用单例模式。

3 单例类的属性

• 仅一个实例
• 全局可访问

4 制作单例类的规则

制作单例类遵循以下规则：

• 私有构造函数
• 类的静态引用
• 一个静态方法
• 全局可访问的对象引用
• 多线程一致性

5 单例示例

以下是JAVA中Singleton类的示例：

public class Singleton {

    private static Singleton instance = null;

    private Singleton() {
        
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

以下是Kotlin中Singleton类的示例：

Object Singleton {
   init { println("Hello Singleton") }
}

6 模式＃2 工厂模式

工厂模式是一种创建对象的设计模式，其名称源于其类似于工厂的行为。在工厂模式中，工厂类负责控制对象的实例化逻辑。当需要创建多个具有相似行为的对象时，工厂模式非常有用。您可以使用工厂模式来创建对象，而无需指定具体的类。这使代码更加灵活，进行修改和维护变得更轻松。

请看以下代码以便更好地理解：

interface Currency {
    fun symbol(): String
    fun code(): String
}

enum class Country {
    UnitedState, SpAIn
}

class USDollar : Currency {
    override fun symbol(): String {
        return "$"
    }

    override fun code(): String {
        return "USD"
    }
}

class Euro : Currency {
    override fun symbol(): String {
        return "€"
    }

    override fun code(): String {
        return "EUR"
    }
}

object CurrencyFactory {

    fun currency(country: Country): Currency {
        return when (country) {
            Country.UnitedState -> {
                USDollar()
            }
            Country.Spain -> {
                Euro()
            }
        }
    }
}

7 模式＃3  建造者模式

建造者模式旨在“将复杂对象的构建与其表示分离，以便相同的构建过程可以创建不同的表示形式。”它用于逐步构建复杂对象，最后一步将返回对象。

8 制作Builder类的规则

制作Builder类遵循以下规则：

• 私有构造函数
• 通常称为Builder的内部类
• 每个字段的函数设置字段值返回
• 构建函数返回Main类的实例

以下是Kotlin中Builder类的示例：

class Hamburger private constructor(
    val cheese: Boolean,
    val beef: Boolean,
    val onions: Boolean
) {
    class Builder {
        private var cheese: Boolean = true
        private var beef: Boolean = true
        private var onions: Boolean = true

        fun cheese(value: Boolean) = Apply { cheese = value }
        fun beef(value: Boolean) = apply { beef = value }
        fun onions(value: Boolean) = apply { onions = value }

        fun build() = Hamburger(cheese, beef, onions)
    }
}

9 模式＃4 外观模式

外观模式提供一个更高级的接口，使一组其他接口更容易使用。它封装了一组类的复杂性，并提供了一个更高级别的接口，以简化对这些类的访问。以下图表更清楚地说明了这个想法。

interface BooksApi {
  @GET("books")
  fun listBooks(): Call<List<Book>>
}

Square的Retrofit是一种开源的安卓库，可帮助您实现外观模式。您可以创建一个接口，为客户端提供API数据。

10 模式＃5 依赖注入

依赖注入就像搬进一间家具齐全的公寓一样，您需要的一切都已经在那里，不必等待家具送货或遵循家具公司的指令指南来组装它。

在软件方面，依赖注入要求您提供任何所需的对象来实例化新对象。这个新对象不需要自己构建或自定义对象。

在安卓中，您可能会发现需要从应用程序的各个点访问同一复杂对象，例如网络客户端、图像加载器或用于本地存储的SharedPreferences。为了方便访问这些对象，您可以将它们注入到活动和片段中，并直接使用它们。这种方式称为依赖注入，它允许您在应用程序中更容易地管理和共享对象，并提高了代码的可重用性和测试可靠性。

以下示例展示了一个没有使用依赖注入的Car类的代码。在该示例中，Car类正在构建自己的Engine依赖项:

class Car {

    private val engine = Engine()

    fun start() {
        engine.start()
    }
}

fun main(args: Array) {
    val car = Car()
    car.start()
}

这种做法存在问题，因为Car类对Engine类有硬编码的依赖关系，这将导致代码难以维护和测试。如果需要更改Engine实现或使用不同的实现，则需要修改Car类的代码。这可能会导致代码的重构和重新测试，并且可能会影响其他依赖于Car类的代码。因此，使用依赖注入可以解决这个问题，并提高代码的可重用性和可测试性。

使用依赖注入的代码是什么样子？代替每个Car实例在初始化时构建自己的Engine对象，它在构造函数中作为参数接收一个Engine对象：

class Car(private val engine: Engine) {
    fun start() {
        engine.start()
    }
}

fun main(args: Array) {
    val engine = Engine()
    val car = Car(engine)
    car.start()
}

11 模式＃6 适配器模式

适配器模式是一种用于连接两个不兼容接口之间的桥梁模式。

这种模式涉及一个单一的类，该类负责连接独立或不兼容接口的功能。现实生活中的一个例子可能是一个读卡器，它充当内存卡和笔记本电脑之间的适配器。您将记忆卡插入读卡器，将读卡器插入笔记本电脑，以便可以通过笔记本电脑读取记忆卡。

祝您编码愉快！