每个 Android 开发者都必须知道的 5 种设计模式！

在这篇文章中，我将解释什么是设计模式，作为一个安卓开发者，无论你是新手、经验丰富还是高手，你都应该了解以下这些设计模式。

设计模式是什么：

设计模式是软件设计中给定上下文中常见问题的通用、可重用解决方案。

设计模式是对经常出现的问题的解决方案。

设计模式不是成品；相反，它们是可以根据上下文应用于多种情况的模板，并且可以随着时间的推移进行改进，从而成为非常强大的软件工程工具。设计模式可帮助开发人员实施经过验证且被广泛采用的解决方案。它有助于提高开发速度，并且使用设计模式模板更快地开发原型解决方案可以提高编码效率、可维护性和代码可读性。

设计模式的类型：

以下是不同类型的设计模式：

1. 创意设计模式
2. 结构设计模式
3. 行为设计模式。

1. 创意：

这些模式是为创建对象或类的方式而设计的。

2.结构：

这些模式是针对类的结构和组成而设计的。

3.行为：

这些模式的设计取决于一个类与其他类的通信方式。

Android 开发者的设计模式：

Android 是一个移动开发者平台，它还提供 API 来开发手表和嵌入式系统的应用程序。就像你是一个安卓开发者一样，你应该知道常见的简单设计模式。

模式 1 Singleton：

这种创建设计模式有助于在应用程序上下文中实例化对象一次且仅一次。单例是一个类，它只允许创建其自身的单个实例并允许访问该创建的实例。当您要创建数据库连接对象以从应用程序创建一个且唯一的会话时，这很有用。

记住以下几点：

1. 私有构造函数
2. 其类的静态引用
3. 一种静态方法
4. 可全局访问的对象引用
5. 跨多个线程的一致性

例子：

public class SingletonInstance {

//A static reference of its class
    private static SingletonInstance instance = null;

//private constructor
    private SingletonInstance() {

    }
//One static method
//Globally accessible object reference

    public static SingletonInstance getInstance() {
        if (instance == null) {

//Consistency across multiple threads

            synchronized (SingletonInstance.class) {
                if (instance == null) {
                    instance = new SingletonInstance();
                }
            }
        }
        return instance;
    }
}

模式 2 Factory：

这也是一种创造设计模式。这确保子类应该决定如何实例化对象。我们在不向客户端公开创建逻辑的情况下创建对象，并且客户端使用相同的通用接口来创建新类型的对象。您可以拥有任意数量的类，但这些隐藏和对象是使用接口或抽象类创建的。

记住以下几点：

1. 执行。
2. 创建一个接口。
3. 创建实现相同接口的具体类。
4. 创建工厂以根据输入生成具体类的对象。
5. 使用工厂获取具体类的对象。

例子：

//CarType.java
public enum CarType {
    SMALL, SEDAN, LUXURY
}

//Car.java
public abstract class Car {

  public Car(CarType model) {
    this.model = model;
    arrangeParts();
  }

  private void arrangeParts() {
    // Do one time processing here
  }

  protected abstract void construct();

  private CarType model = null;

  public CarType getModel() {
    return model;
  }

  public void setModel(CarType model) {
    this.model = model;
  }
}

//LuxuryCar.java

public class LuxuryCar extends Car {

  LuxuryCar() {
    super(CarType.LUXURY);
    construct();
  }

  @Override
  protected void construct() {
    System.out.println("Building luxury car");

  }
}

//SmallCar.java
public class SmallCar extends Car {

  SmallCar() {
    super(CarType.SMALL);
    construct();
  }

  @Override
  protected void construct() {
    System.out.println("Building small car");

  }
}

模式 3 Builder：

构建器模式旨在将复杂对象的构造与其表示分离，以便相同的构造过程可以创建不同的表示。它用于逐步构造一个复杂的对象，最后一步将返回该对象。构建器模式是一种设计模式，旨在为各种对象创建问题提供灵活的解决方案。

记住以下几点：

1. 私有构造函数
2. 通常称为 Builder 的内部类
3. 函数为每个字段设置字段值返回
4. 主类的函数构建返回实例

示例 Kotlin：

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)
    }
}

模式 4 Adapter：

作为一名安卓开发者，你可能已经使用过这种设计模式。这就像 android 开发者的日常面包。适配器模式充当两个不兼容接口之间的桥梁。这种模式涉及一个单一的类，该类负责连接独立或不兼容接口的功能。通过一个真实的示例，您可以将此模式映射到您的手机充电器适配器。这是结构设计模式的类型。

interface Bird
{
    public void fly();
    public void makeSound();
}

class Sparrow implements Bird
{
    public void fly()
    {
        System.out.println("Flying");
    }
    public void makeSound()
    {
        System.out.println("Chirp Chirp");
    }
}

interface ToyDuck
{
    // target interface
    // toyducks dont fly they just make
    // squeaking sound
    public void squeak();
}

class PlasticToyDuck implements ToyDuck
{
    public void squeak()
    {
        System.out.println("Squeak");
    }
}

class BirdAdapter implements ToyDuck
{
    // You need to implement the interface your
    // client expects to use.

    Bird bird;
    public BirdAdapter(Bird bird)
    {
        this.bird = bird;
    }

    public void squeak()
    {
        bird.makeSound();
    }
}

模式5 Facade：

外观设计模式是企业开发中非常重要的设计模式。外观模式提供了一个更高级别的接口，使一组其他接口更易于使用。

Facade 定义了一个新的接口，而 Adapter 使用了一个旧的接口。Facade 处理接口，而不是实现。

例子：

public interface LaptopShop {  
    public void modelNo();  
    public void price();  
}  

public class DellLaptop implements LaptopShop {  
    @Override  
    public void modelNo() {  
        System.out.println(" Dell 6 ");  
    }  
    @Override  
    public void price() {  
    System.out.println(" Rs 65000.00 ");  
    }  
}  

public class Lenovo implements LaptopShop {  
    @Override  
    public void modelNo() {  
    System.out.println(" Lenovo 3 ");  
    }  
    @Override  
    public void price() {  
        System.out.println(" Rs 45000.00 ");  
    }  
}  

public class ShopKeeper {  
    private LaptopShop dell;  
    private LaptopShop lenovo;  

    public ShopKeeper(){  
        dell= new DellLaptop();  
        lenovo=new Lenovo();  

    }  
    public void dellSale(){  
        dell.modelNo();  
        dell.price();  
    }  
        public void lenovoSale(){  
        lenovo.modelNo();  
        lenovo.price();  
    }  
}

结论：

在这篇文章中，我试图解释一个你需要知道的非常基本的列表。本文并不仅仅声称这些设计模式很重要，但这些是您应该熟悉的基础知识。

这只是一个基本列表，还有其他设计和架构模式，例如依赖注入、MVVM、MVP 和 MVC，至少您需要了解。

文章来源：https://techwasti.com/5-design-patterns-every-android-developer-must-know