24种设计模式的定义和使用场合

合集下载

面试常见设计模式

设计模式是软件开发中常用的一种设计思想，它提供了一种解决问题的方法和模板，帮助开发人员在面对各种复杂问题时能够快速有效地进行设计和开发。在面试时，设计模式也是面试官经常会问到的一个重要话题。本文将介绍一些常见的设计模式，并分析其应用场景和优缺点。

1.单例模式

单例模式是一种常见的创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。在多线程环境下，单例模式可以保证线程安全。单例模式常用于需要共享资源或控制资源访问的场景，比如数据库连接池、线程池等。

2.工厂模式

工厂模式是一种创建型设计模式，它定义了一个创建对象的接口，但具体的对象创建由子类决定。工厂模式可以隐藏对象的创建细节，减少依赖，并且提供了一种可扩展的方式来创建对象。工厂模式常用于创建复杂对象或对象组合的场景。

3.观察者模式

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生变化时，其依赖的对象将自动收到通知并进行相应的处理。观察者模式可以实现松耦合，增加对象之间的

协作和交互。观察者模式常用于事件驱动、消息通知等场景。

4.策略模式

策略模式是一种行为型设计模式，它将一组算法封装成一系列可互换的策略，使得算法的变化独立于使用算法的客户端。策略模式可以提高代码的可维护性和可扩展性，减少代码的重复和耦合。策略模式常用于需要根据不同情况选择不同算法的场景。

5.装饰器模式

装饰器模式是一种结构型设计模式，它动态地给一个对象添加一些额外的功能，同时又不改变其原有的结构。装饰器模式可以在不需要子类化的情况下扩展对象的功能，符合开闭原则。装饰器模式常用于动态地给对象添加新的行为或功能。

项目中常用的设计模式

设计模式是在软件开发中经过实践验证的解决问题的经验总结，是一种被广泛应用的软件开发模式。常用的设计模式有以下几种：

1. 单例模式

单例模式是一种创建型设计模式，保证一个类只有一个实例，并提供全局访问点。在需要共享资源、控制资源访问、管理全局状态等场景下，单例模式非常有用。

2. 工厂模式

工厂模式是一种创建型设计模式，定义了一个用于创建对象的接口，但具体创建哪个类的实例由子类决定。工厂模式可以隐藏对象的创建过程，使代码更加灵活可扩展。

3. 观察者模式

观察者模式是一种行为型设计模式，定义了一种一对多的依赖关系，使得当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。观察者模式可以实现松耦合，降低对象之间的依赖程度。

4. 装饰器模式

装饰器模式是一种结构型设计模式，动态地给一个对象添加额外的职责。装饰器模式通过创建一个包装对象来实现，包装对象和原始

对象具有相同的接口，可以透明地增强原始对象的功能。

5. 适配器模式

适配器模式是一种结构型设计模式，将一个类的接口转换成客户端所期望的另一个接口。适配器模式可以解决不兼容接口的问题，使得原本不兼容的类可以合作无间。

6. 策略模式

策略模式是一种行为型设计模式，定义了一系列算法，并将每个算法封装起来，使得它们可以互相替换。策略模式可以使算法的变化独立于使用算法的客户端。

7. 命令模式

命令模式是一种行为型设计模式，将一个请求封装成一个对象，从而使得可以用不同的请求对客户端进行参数化。命令模式可以将请求的发送者和接收者解耦，使得系统更加灵活。

设计模式：24个经典模式在实际项目中的应用

设计模式：24个经典模式在实际项目中的应

用

设计模式是软件开发中一种被广泛采用的行为方案，它们能够解决常见的设计问题，并提供了一种可重用的解决方案。经典的24个设计模式被认为是软件开发中最常用的模式。在实际项目中，这些设计模式可以帮助开发人员提高代码的可维护性、复用性和可扩展性。下面将介绍一些经典的设计模式在实际项目中的应用。

一、创建型模式（Creational Patterns）

1.单例模式（Singleton Pattern）

单例模式在实际项目中的应用非常广泛。例如，在一个多线程的应用中，如果有多个线程同时访问同一个对象，可能会导致数据不一致的问题。使用单例模式可以确保只有一个对象被创建，并提供一个全局访问点，避免了多个对象的创建和同步访问的问题。

2.工厂方法模式（Factory Method Pattern）

工厂方法模式在实际项目中常用于对象的创建和实例化。例如，

一个电商平台需要根据用户的需求创建不同的产品对象，在这种情况下，可以使用工厂方法模式来创建和实例化不同的产品对象。

3.抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式可以用于创建一组相关或相互依赖的对象。在实际

项目中，例如一个软件需要支持不同的操作系统和数据库，可以使用

抽象工厂模式创建适用于不同操作系统和数据库的对象。

二、结构型模式（Structural Patterns）

1.适配器模式（Adapter Pattern）

适配器模式在实际项目中的应用非常常见。例如，当一个已存在

的接口不符合新的系统要求时，可以使用适配器模式来进行接口转换。这样既能够重用已有的代码，又能够满足新的系统要求。

常见设计模式及应用场景

设计模式是一组指南和最佳实践，用于帮助开发人员创建高质量、可维护和可重用的软件。它们描述了在不同领域中的软件设计中常见的问题和解决方案，例如面向对象编程、软件架构和用户界面设计。

以下是一些常见的设计模式及其应用场景:

1. 单例模式：用于确保一个类仅有一个实例，并提供全局访问点。适用于需要确保实例只有一个的情况，例如日志类、配置信息类等。

2. 工厂模式：用于创建对象的模式，根据不同的条件返回不同

的实例。适用于需要创建多种不同对象的情况，例如创建不同的用户角色、订单状态等。

3. 建造者模式：用于创建对象的模式，提供一种方法来逐步构

建对象。适用于需要创建复杂的对象结构的情况，例如建筑工程、软件开发项目等。

4. 观察者模式：用于处理对象之间的观察者关系，当一个对象

发生变化时，所有依赖它的对象都会更新。适用于需要处理对象之间依赖关系的情况，例如客户关系管理系统、音乐播放器等。

5. 适配器模式：用于将一个类的接口转换成客户希望的另一个

接口。适用于需要将不同类型的数据转换为不同的格式的情况，例如将 JSON 数据转换为 XML 数据、将 CSV 数据转换为 Excel 数据等。

6. 装饰器模式：用于动态地给一个对象添加一些额外的职责。

适用于需要动态地增加对象的功能的情况，例如动态增加日志记录功

能、动态增加缓存功能等。

7. 策略模式：用于定义一系列算法，将它们一个个封装起来，并使它们可以互相替换。适用于需要定义多种算法的情况，例如用户认证策略、文件压缩策略等。

8. 模板方法模式：用于将一个复杂方法分解成的简单方法的封装。适用于需要将一个复杂方法分解成多个简单方法的情况，例如将一个复杂的 SQL 查询语句分解成多个简单的查询语句。

面向对象23种设计模式

在面向对象的编程中，设计模式是一种解决问题的通用方案。设

计模式可以帮助开发人员在开发过程中减少代码的冗余和复杂性，并

提高代码的可维护性和可重用性。本文将介绍23种面向对象的设计模式。

1. 工厂方法模式

工厂方法模式是一种创建型设计模式，它定义了一个用于创建对

象的接口，但是让子类决定实例化哪个类。在工厂方法模式中，客户

端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。

2. 抽象工厂模式

抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于

创建相关或依赖对象的家族，而不需要指定它们的具体类。在抽象工

厂模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中

定义的接口即可。

3. 单例模式

单例模式是一种创建型设计模式，它保证一个类只有一个实例，

并提供一个访问该实例的全局点。

4. 原型模式

原型模式是一种创建型设计模式，它允许复制或克隆一个现有的

对象，而不必知道其具体实现。

5. 建造者模式

建造者模式是一种创建型设计模式，它允许逐步创建复杂的对象，而不必知道其内部实现细节。

6. 适配器模式

适配器模式是一种结构型设计模式，它将一个或多个不兼容的类

或接口转换为客户端所需的接口。

7. 桥接模式

桥接模式是一种结构型设计模式，它将抽象部分与其实现部分分离开来，以便独立地进行修改。

8. 组合模式

组合模式是一种结构型设计模式，它将一组对象作为单个对象处理，以便客户端可以以相同的方式处理单个对象和组合对象。

9. 装饰器模式

装饰器模式是一种结构型设计模式，它允许向现有对象添加额外的功能，同时不改变其现有的结构。

23种设计模式记忆口诀

设计模式是软件开发中常见的解决方案模板，它们能够解决许多常见的设计问题。为了帮助记忆23种设计模式，可以使用下面这个口诀来记忆：

Creational Patterns（创建型模式）:

1. Singleton（单例模式）：

一个类能产生一个实例，全局访问。

2. Builder（建造者模式）：

分步骤创建复杂对象，易拓展。

3. Factory Method（工厂方法模式）：

子类决定实例化哪个对象。

4. Abstract Factory（抽象工厂模式）：

创建一组相关对象，不依赖具体类。

5. Prototype（原型模式）：

通过复制现有对象来创建新对象。

Structural Patterns（结构型模式）:

6. Adapter（适配器模式）：

将类的接口转换为客户端希望的接口。

7. Bridge（桥接模式）：

将抽象部分与实际部分分离。

将对象组合成树形结构来表示部分整体的层次结构。

9. Decorator（装饰器模式）：

动态地给对象添加功能。

10. Facade（外观模式）：

提供一个统一的接口，简化客户端使用。

11. Flyweight（享元模式）：

共享细粒度对象，减少内存使用。

12. Proxy（代理模式）：

控制对其他对象的访问。

Behavioral Patterns（行为型模式）:

13. Chain Of Responsibility（责任链模式）：

将请求的发送者和接收者解耦，多个对象都可能处理请求。将请求封装成对象，可以用参数化方式处理。

15. Iterator（迭代器模式）：

24种设计模式及原则简介

⼀、设计模式的分类

总体来说设计模式分为三⼤类：

创建型模式，共五种：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、多例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

⾏为型模式，共⼗⼀种：策略模式、模板⽅法模式、观察者模式、迭代⼦模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

创建型模式

抽象⼯⼚模式(Abstract factory pattern): 提供⼀个接⼝，⽤于创建相关或依赖对象的家族，⽽不需要指定具体类。

⽣成器模式(Builder pattern): 使⽤⽣成器模式封装⼀个产品的构造过程，并允许按步骤构造。将⼀个复杂对象的构建与它的表⽰分离，使得同样的构建过程可以创建不同的表⽰。

⼯⼚模式(factory method pattern): 定义了⼀个创建对象的接⼝，但由⼦类决定要实例化的类是哪⼀个，⼯⼚⽅法让类把实例化推迟到⼦类。

原型模式(prototype pattern): 当创建给定类的实例过程很昂贵或很复杂时，就使⽤原形模式。使⽤深拷贝或浅拷贝。

单例了模式(Singleton pattern): 确保⼀个类只有⼀个实例，并提供全局访问点。

多例模式(Multition pattern): 在⼀个解决⽅案中结合两个或多个模式，以解决⼀般或重复发⽣的问题。

结构型模式

适配器模式(Adapter pattern): 将⼀个类的接⼝，转换成客户期望的另⼀个接⼝。适配器让原本接⼝不兼容的类可以合作⽆间。对象适配器使⽤组合，类适配器使⽤多重继承。

23种设计模式及其应用场景

23种设计模式及其应⽤场景

设计模式主要分三个类型:创建型、结构型和⾏为型。

其中创建型有：

⼀、Singleton，单例模式：保证⼀个类只有⼀个实例，并提供⼀个访问它的全局访问点；应⽤场景：⼀个⽆状态的类使⽤单例模式节省内存资源。

⼆、Abstract Factory，抽象⼯⼚：提供⼀个创建⼀系列相关或相互依赖对象的接⼝，⽽⽆须指定它们的具体类。应⽤场景：⼀系列相互依赖的对象有不同的具体实现。提供⼀种“封装机制”来避免客户程序和这种“多系列具体对象创建⼯作”的紧耦合。

三、Factory Method，⼯⼚⽅法：定义⼀个⽤于创建对象的接⼝，让⼦类决定实例化哪⼀个类，Factory Method使⼀个类的实例化延迟到了⼦类。应⽤场景：由于需求的变化，⼀个类的⼦类经常⾯临着剧烈的变化，但他却拥有⽐较稳定的接⼝。使⽤⼀种封装机制来“隔离这种易变对象的变化”，⼯⼚⽅法定义⼀个⽤于创建对象的接⼝，让⼦类来确定创建哪⼀个具体类的对象，将对象的实例化延迟。

四、Builder，建造模式：将⼀个复杂对象的构建与他的表⽰相分离，使得同样的构建过程可以创建不同的表⽰。应⽤场景：⼀个类的各个组成部分的具体实现类或者算法经常⾯临着变化，但是将他们组合在⼀起的算法却相对稳定。提供⼀种封装机制将稳定的组合算法于易变的各个组成部分隔离开来。

五、Prototype，原型模式：⽤原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。应⽤场景：⽤new创建⼀个对象需要⾮常繁琐的数据准备或者权限

⾏为型有：

六、Iterator，迭代器模式：提供⼀个⽅法顺序访问⼀个聚合对象的各个元素，⽽⼜不需要暴露该对象的内部表⽰。应⽤场景：迭代。

24种设计模式的定义和使用场合

一.创建型模式(Creational):

简单工厂模式(simpleFactory)发音:['simpl] ['fækt(ə)rɪ]

定义:

提供一个创建对象实例的功能,而无须关心其具体实现.被创建实例的类型可以是接口,抽象类,也可以是具体的类.

1.抽象工厂(AbstractFactory)发音: ['æbstrækt]定义:

提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类.

使用场合:

1.如果希望一个系统独立于它的产品的创建,组合和表示的时候,换句话书,希望一个系统只是知道产品的接口,而不关心实现的时候.

3.如果强调一系列相关产品的接口,以便联合使用他们的时候

2.建造者模式(Builder)发音: ['bɪldə]

定义:

将复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.

使用场合:

1.如果创建对象的算法,应该独立于该对象的组成部分以及它们的装配方式时

2.如果同一个构建过程有着不同的表示时

3.工厂方法模式(Factory Method)

定义:

为创建对象定义一个接口,让子类决定实例化哪个类.工厂方法让一个类的实例化延迟到了子类.

使用场景:

1.客户类不关心使用哪个具体类,只关心该接口所提供的功能.

2.创建过程比较复杂,例如需要初始化其他关联的资源类,读取配置文件等.

3.接口有很多具体实现或者抽象类有很多具体子类时,

4.不希望给客户程序暴露过多的此类的内部结构,隐藏这些细节可以降低耦合度.

5.优化性能,比如缓存大对象或者初始化比较耗时的对象.

24种设计模式及案例

图标放到了最后⾯

思维导图

创建型模式

⼯⼚模式

⼯⼚模式（Factory Pattern）是 Java 中最常⽤的设计模式之⼀。这种类型的设计模式属于创建型模式，它提供了⼀种创建对象的最佳⽅式。

在⼯⼚模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使⽤⼀个共同的接⼝来指向新创建的对象。

介绍

意图：定义⼀个创建对象的接⼝，让其⼦类⾃⼰决定实例化哪⼀个⼯⼚类，⼯⼚模式使其创建过程延迟到⼦类进⾏。

主要解决：主要解决接⼝选择的问题。

何时使⽤：我们明确地计划不同条件下创建不同实例时。

如何解决：让其⼦类实现⼯⼚接⼝，返回的也是⼀个抽象的产品。

关键代码：创建过程在其⼦类执⾏。

应⽤实例： 1、您需要⼀辆汽车，可以直接从⼯⼚⾥⾯提货，⽽不⽤去管这辆汽车是怎么做出来的，以及这个汽车⾥⾯的具体实现。 2、Hibernate 换数据库只需换⽅⾔和驱动就可以。

优点： 1、⼀个调⽤者想创建⼀个对象，只要知道其名称就可以了。 2、扩展性⾼，如果想增加⼀个产品，只要扩展⼀个⼯⼚类就可以。3、屏蔽产品的具体实现，调⽤者只关⼼产品的接⼝。

缺点：每次增加⼀个产品时，都需要增加⼀个具体类和对象实现⼯⼚，使得系统中类的个数成倍增加，在⼀定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使⽤场景： 1、⽇志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，⽤户可以选择记录⽇志到什么地⽅。 2、数据库访问，当⽤户不知道最后系统采⽤哪⼀类数据库，以及数据库可能有变化时。 3、设计⼀个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现⼀个接⼝。

工作中常用的设计模式

在软件设计中，常用的设计模式包括以下几种：

1. 单例模式：确保一个类只有一个实例存在，提高资源利用率。

2. 工厂模式：定义一个用于创建对象的接口，由子类决定实例化哪一个类。

3. 观察者模式：定义对象间一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖的对象都会得到通知并自动更新。

4. 装饰器模式：动态地给一个对象添加一些额外的职责，而不需要修改这个对象的类。

5. 适配器模式：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。

6. 策略模式：定义一系列算法，将每个算法都封装起来并且使它们之间可以相互替换。

7. 迭代器模式：提供一种方式可以访问一个聚合对象中的各个元素，而又不必暴露该对象的内部表示。

8. 状态模式：允许对象在其内部状态改变时改变它的行为，封装了状态的变化。

以上是一些常用的设计模式，它们可以用于提高代码的可维护性，可扩展性以及代码组织的结构性。

24种设计模式

Factory Pattern(⼯⼚模式)：1. 创建对象的接⼝，封装对象的创建；2. 使具体化类的⼯作延迟到⼦类中。（维护⼀类对象）AbstractFactory Pattern(抽象⼯⼚模型)：该模式将⼀组对象的创建封装到⼀个⽤于创建对象的类中。（解决的问题：要创建⼀组或者相互依赖的对象）。

Singleton Pattern(单例模式)：该模式在⾯向纯粹的⾯向对象的范式中⽤于创建唯⼀的实例，值得注意的是Singleton不能被实例化，因此将其构造函数声明为protected或private类型。Singleton Pattern经常与Factory Pattern结合使⽤，因为Factory对象只能有⼀个。

Builder Pattern(创建者模式)：将⼀个复杂的对象的构建与它的表⽰分离，使得同样的构建构成可以创建不同的表⽰。如建筑师画图纸，⽽⼯⼈建造房屋。

Prototype Pattern(原型模式)：提供⼀个通过已存在对象进⾏新对象创建的接⼝（clone）。（浅拷贝和深拷贝）

Bridge Pattern(桥梁模式)：将抽象部分与实现部分分开实现，使他们都可以独⽴地变化，并使⽤组合的⽅式将多维度的抽象⽅法联系在⼀起。⽐如咖啡分⼩杯、中杯、⼤杯以及加奶和不加奶，则抽象部分为：⼩杯、中杯、⼤杯，⾏为为：加奶和不加奶。

Adapter Pattern(适配器模式)：适配就是由“源”到“⽬标”的适配，⽽当中链接两者的关系就是适配器。它负责把“源”过度到“⽬标”。将⼀个类的接⼝转换成客户希望的另外⼀个接⼝。Adapter模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的那些类可以⼀起⼯作。适配器模式分为两种：①⾯向类的设计模式；②⾯向对象的设计模式。

23种设计模式及案例整理分享

创建型模式

⼯⼚模式

⼯⼚模式（Factory Pattern）是 Java 中最常⽤的设计模式之⼀。这种类型的设计模式属于创建型模式，它提供了⼀种创建对象的最佳⽅式。

在⼯⼚模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使⽤⼀个共同的接⼝来指向新创建的对象。

介绍

意图：定义⼀个创建对象的接⼝，让其⼦类⾃⼰决定实例化哪⼀个⼯⼚类，⼯⼚模式使其创建过程延迟到⼦类进⾏。

主要解决：主要解决接⼝选择的问题。

何时使⽤：我们明确地计划不同条件下创建不同实例时。

如何解决：让其⼦类实现⼯⼚接⼝，返回的也是⼀个抽象的产品。

关键代码：创建过程在其⼦类执⾏。

优点： 1、⼀个调⽤者想创建⼀个对象，只要知道其名称就可以了。 2、扩展性⾼，如果想增加⼀个产品，只要扩展⼀个⼯⼚类就可以。 3、屏蔽产品的具体实现，调⽤者只关⼼产品的接⼝。

23种设计模式的经典运用

介绍

设计模式是解决软件设计中常见问题的可重复使用的解决方案。本文将介绍23种经典的设计模式，并给出它们在实际开发中的应用示例。通过学习这些设计模式，您将增加对软件设计的理解，并能够更好地解决问题。

创建型设计模式

1.工厂方法模式（F a c t o r y M e t h o d）

工厂方法模式通过定义一个创建对象的接口，但由子类决定实例化具体类。这种方法可以延迟实例化过程，具有更高的灵活性和可扩展性。

应用场景：

-在一个系统中，希望客户端与具体类的实例化解耦。

-希望通过增加具体类的扩展来增加系统的灵活性。

2.抽象工厂模式（A b s t r a c t F a c t o r y）

抽象工厂模式提供一个接口，用于创建相关或依赖对象组。这种模式将对象的实例化推迟到子类中，从而实现了解耦。

应用场景：

-当一个系统独立于其产品的创建、组合和表示时。

-当需要一个系列的相互依赖的对象而无需指定其具体类时。

3.单例模式（S i n gl e t o n）

单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式常用于控制对资源的访问，例如数据库连接或日志文件。

应用场景：

-当需要一个类的唯一实例，并且该实例需要被多个客户端共享时。

-当需要限制系统中特定类的实例数量时。

4.原型模式（P r o to t y p e）

原型模式通过复制现有对象来创建新对象。这种模式对于创建需要消

耗大量资源的对象非常有用，可以通过克隆现有对象来提高性能。

应用场景：

-当一个系统的某些对象的创建比较昂贵时。

常见的设计模式及应用场景

常见的设计模式及应⽤场景

⼀、单例模式

单例模式是⼀种常⽤的软件设计模式，在应⽤这个模式时，单例对象的类必须保证只有⼀个实例存在，整个系统只能使⽤⼀个对象实例。

优点：不会频繁地创建和销毁对象，浪费系统资源。

使⽤场景：IO 、数据库连接、Redis 连接等。

单例模式代码实现：

class Singleton {

private static Singleton instance = new Singleton();

public static Singleton getInstance() {

return instance;

}

单例模式调⽤代码：

public class Lesson{

public static void main(String[] args) {

Singleton singleton1 = Singleton.getInstance();

Singleton singleton2 = Singleton.getInstance();

System.out.println(singleton1 == singleton2);

}

程序的输出结果：true

可以看出以上单例模式是在类加载的时候就创建了，这样会影响程序的启动速度，那如何实现单例模式的延迟加载？在使⽤时再创建？

单例延迟加载代码：

// 单例模式-延迟加载版

class SingletonLazy {

private static SingletonLazy instance;

public static SingletonLazy getInstance() {

安卓中设计模式及应用场景

设计模式是指在软件开发中可复用的解决问题的经验总结和最佳实践。在安卓开发中，设计模式能帮助我们构建可维护、可扩展和可重用的应用程序。下面将介绍几种常见的设计模式及其在安卓开发中的应用场景。

1. 单例模式（Singleton Pattern）:

单例模式用于确保一个类只有一个实例，并提供一个全局访问点。在安卓开发中，有些情况下我们只需要一个全局对象，例如数据库管理器、网络请求管理器等。通过单例模式可以确保只有一个实例存在，方便在各处进行访问。

2. 观察者模式（Observer Pattern）:

观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，其依赖的对象们会收到通知并作出相应的更新。在安卓中，我们可以利用观察者模式实现事件总线来进行组件之间的通信，例如使用EventBus库。当某一组件的状态变化时，可以通过事件总线通知其他组件进行相应的操作。

3. 工厂模式（Factory Pattern）:

工厂模式定义了一个创建对象的接口，由子类决定实例化哪个类。在安卓开发中，工厂模式经常用于创建各种不同类型的对象，能很好地实现解耦和复用。例如在RecyclerView 的Adapter 中，在不同的情况下需要创建不同的ViewHolder，可以使用工厂模式根据需求创建不同的ViewHolder。

4. 适配器模式（Adapter Pattern）:

适配器模式将一个类的接口转换成客户端所期望的另一个接口，从而使得原本不兼容的类能够一起工作。在安卓中，ListView 和RecyclerView 常常需要使用适配器来将数据源与界面进行绑定，使得数据能够正确地显示在界面上。