简单地说：

顾名思义，它是应用程序/对象当前状态的上下文。它让新创建的对象了解发生了什么。通常，您调用它来获取有关程序的另一部分（活动和包/应用程序）的信息。

您可以通过调用 、 或 （在扩展自 的类中，例如 Application、Activity、Service 和 IntentService 类）来获取上下文。getApplicationContext()getContext()getBaseContext()thisContext

上下文的典型用途：

• 创建新对象： 创建新视图、适配器、侦听器：

   TextView tv = new TextView(getContext());
   ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(), ...);
  

• 访问标准公共资源： LAYOUT_INFLATER_SERVICE、SharedPreferences 等服务：

   context.getSystemService(LAYOUT_INFLATER_SERVICE)
   getApplicationContext().getSharedPreferences(*name*, *mode*);
  

• 隐式访问组件： 关于内容提供商、广播、意图

   getApplicationContext().getContentResolver().query(uri, ...);
  

上下文是系统的句柄;它提供解析资源、获取对数据库和首选项的访问权限等服务。Android 应用具有活动。上下文类似于应用程序当前运行环境的句柄。活动对象继承 Context 对象。

如需了解详情，请参阅使用 Android Studio 进行 Android 开发简介 - 教程。

Android Context 是一个接口（在一般意义上，不是 Java 意义上的，在 Java 中，实际上是一个抽象类！），它允许访问特定于应用程序的资源和类以及有关应用程序环境的信息。Context

如果您的 Android 应用程序是一个 Web 应用程序，您的上下文将类似于（我在这里不做确切的比较）。ServletContext

您的 Activity 和服务也会扩展，因此它们会继承所有这些方法来访问运行应用程序的环境信息。Context

上下文是对当前对象的引用。此外，上下文允许访问有关应用程序环境的信息。

上下文基本上用于资源访问和获取应用程序（用于应用程序上下文）或活动（用于活动上下文）或任何其他...

为了避免内存泄漏，您应该对需要上下文对象的每个组件使用应用程序上下文。欲了解更多信息，请点击这里

上下文到底是什么？

根据 Android 参考文档，它是一个表示各种环境数据的实体。它提供对本地文件、数据库、与环境关联的类装入器、服务（包括系统级服务）等的访问。在本书中，以及在使用 Android 的日常编码中，你会看到 Context 经常被传递。

摘自《Android in Practice》一书，第 60 页。

多个 Android API 需要将 Context 作为参数

如果您浏览各种 Android API，您将 请注意，他们中的许多人将对象视为 参数。您还将看到 Activity 或 Service 通常用作 .这之所以有效，是因为这两个类都是从 扩展而来的。android.content.ContextContextContext

可以将其视为孤立运行应用或服务的进程的 VM。孤立的环境可以访问一堆底层系统信息和某些允许的资源。您需要该上下文才能获得这些服务。

该类提供与 Android 系统的连接和项目的资源。它是有关应用程序环境的全局信息的接口。android.content.Context

上下文还提供对 Android 服务（例如定位服务）的访问。

活动和服务扩展了课程。Context

Context是有关应用程序环境的全局信息的“接口”。在实践中，实际上是一个抽象类，其实现是由Android系统提供的。Context

它允许访问特定于应用程序的资源和类，以及应用程序级操作的上调，例如启动活动、广播和接收意图等。

在下图中，您可以看到类的层次结构，其中是此层次结构的根类。特别值得一提的是，它是 的后代。ContextActivityContext

只是把它放在新手那里;

所以首先要了解单词的上下文：

在 english-lib 中。这意味着：

“构成事件、声明或 想法，并据此可以充分理解和评估。

“书面或口头的事物中紧接在和 跟着一个词或一段话，澄清它的含义。

现在对编程世界有同样的理解：

应用程序/对象当前状态的上下文。它允许新创建的对象了解发生了什么。通常，您调用它来获取有关程序另一部分（活动、包/应用程序）的信息

您可以通过调用 或（在活动类中时）来获取上下文。getApplicationContext()getContext(), getBaseContext()this

若要在应用程序中获取 Context Anywhere，请使用以下代码：

在 android 应用程序中创建新类AppContext

public class AppContext extends Application {

    private static Context context;

    public void onCreate(){
        super.onCreate();
        AppContext.context = getApplicationContext();
    }

    public static Context getAppContext() {
        return AppContext.context;
    }
}

现在，每当您希望在非活动类中使用应用程序上下文时，调用此方法，您就拥有了应用程序上下文。

希望这对;)有所帮助

上下文的定义

• 上下文表示环境数据
• 它提供对数据库等内容的访问

更简单的术语（示例 1）

• 考虑一下 Person-X 是一家初创软件公司的 CEO。

• 公司里有一位首席架构师，这位首席架构师 完成公司中涉及此类数据库、UI 的所有工作 等。

• 现在，首席执行官聘请了一位新的开发人员。

• 建筑师告诉新雇用的人的责任 人，根据新人的技能以及他是否会 在数据库或UI等上工作。

更简单的术语（示例 2）

• 这就像访问 Android 活动对应用资源的访问一样。

• 这类似于你去酒店时，你想要早餐、午餐和 在合适的时间吃晚饭，对吧？

• 在住宿期间，还有很多其他你喜欢的东西。你如何得到这些东西？

• 您要求客房服务人员为您带来这些东西。

• 在这里，客房服务人员是上下文，考虑到你是 单一活动和酒店成为您的应用程序，最后是早餐、午餐和 晚餐必须是资源。

---

涉及上下文的内容包括：

1. 加载资源。
2. 启动新活动。
3. 创建视图。
4. 获取系统服务。

---

Context 是 Activity、Service、Application 等的基类

另一种描述方式是：将上下文视为电视的远程，电视中的频道是资源、服务、使用意图等 - - - 在这里，远程充当访问前台所有不同资源的访问。

• 因此，Remote 可以访问资源、服务、使用意图等渠道......

• 同样。。。谁可以访问远程，谁就可以访问所有的东西，例如资源、服务、使用意图等

---

获取上下文的不同方法

• getApplicationContext()
• getContext()
• getBaseContext()
• 或（在活动课上时）this

---

例：

TextView tv = new TextView(this);

关键字是指当前活动的上下文。this

A 就是我们大多数人所说的应用程序。它由 Android 系统制作，只能执行应用程序能够执行的操作。 在 Tomcat 中，上下文也是我所说的应用程序。Context

一个 Context 包含多个 Activity，每个 Activity 可能具有多个视图。

显然，有些人会说它不适合，因为这个或那个，他们可能是对的，但是说 Context 是你当前的应用程序将有助于你理解你在方法参数中放置的内容。

上下文是应用程序/对象当前状态的上下文。它是一个代表各种环境数据的实体。上下文可帮助当前 Activity 与外部 Android 环境进行交互，例如本地文件、数据库、与环境关联的类加载器、服务（包括系统级服务）等。

Context 是系统的句柄。它提供解析资源、获取对数据库和首选项的访问权限等服务。Android 应用程序具有活动。它就像应用程序当前运行环境的句柄。活动对象继承 Context 对象。

获取上下文的不同调用方法 1. getApplicationContext（）， 2. getContext（）， 3. 获取BaseContext（） 4.或这个（在活动课上时）。

android.content.Context 类的实例提供与执行应用的 Android 系统的连接。例如，您可以通过上下文检查当前设备显示的大小。

它还允许访问项目的资源。它是有关应用程序环境的全局信息的接口。

Context 类还提供对 Android 服务的访问，例如用于触发基于时间的事件的警报管理器。

活动和服务扩展了 Context 类。因此，它们可以直接用于访问上下文。

Context 是 android.content.Context 类的实例提供与执行应用程序的 Android 系统的连接。例如，您可以通过上下文检查当前设备显示的大小。

它还允许访问项目的资源。它是有关应用程序环境的全局信息的接口。

Context 类还提供对 Android 服务的访问，例如用于触发基于时间的事件的警报管理器。

活动和服务扩展了 Context 类。因此，它们可以直接用于访问上下文。

上下文是有关应用程序环境的全局信息的接口。它是一个抽象类，其实现由系统提供。Android

Context允许访问特定于应用程序的资源和类，以及对应用程序级操作的调用，例如启动活动、广播和接收意图等。

这是示例

 public class MyActivity extends Activity {

      public void Testing() {

      Context actContext = this; /*returns the Activity Context since   Activity extends Context.*/

      Context appContext = getApplicationContext();    /*returns the context of the single, global Application object of the current process. */

      Button BtnShowAct1 = (Button) findViewById(R.id.btnGoToAct1);
      Context BtnContext = BtnShowAct1.getContext();   /*returns the context of the View. */

欲了解更多详情，您可以访问 http://developer.android.com/reference/android/content/Context.html

在android中理解的简单示例：context

每个老板都有一个助手来照顾，去做所有不太重要和耗时的任务。如果需要一份文件或一杯咖啡，助手就会在奔跑。有些老板几乎不知道办公室里发生了什么，所以他们也会问他们的助手。他们自己做一些工作，但对于大多数其他事情，他们需要助手的帮助。

在此方案中，

老板 – 是 Android 应用程序

助手 – 是一个上下文

文件/一杯咖啡 - 是资源

当我们需要获取有关应用程序不同部分（如活动、应用程序等）的信息时，我们通常会调用上下文。

涉及上下文的一些操作（需要助手的事情）：

• 加载公共资源
• 创建动态视图
• 显示 Toast 消息
• 启动活动等

获取上下文的不同方式：

getContext()

getBaseContext()

getApplicationContext()

this

如果您想将 Context 与 Android 中其他熟悉的类连接起来，请记住以下结构：

ContextWrapper < 应用程序<上下文

Context < ContextWrapper < ContextThemeWrapper < 活动

Context < ContextWrapper < ContextThemeWrapper < Activity < 列表活动

ContextWrapper < Service <上下文

ContextWrapper < < Service < IntentService 的上下文

因此，所有这些类都以自己的方式成为上下文。如果需要，可以将 Service 和 ListActivity 强制转换为 Context。但如果你仔细观察，一些类也继承了主题。在 Activity 或 Fragment 中，您希望将主题应用于您的视图，但并不关心它 例如，Service 类。

我在这里解释上下文的差异。

Context 是每个 app-s Sandbox 的 android 特定 API，它提供访问应用程序私有数据，例如资源、数据库、私有文件目录、首选项、设置......

对于一个应用程序的所有活动/服务/广播侦听器，大多数私有数据都是相同的。

由于 Application、Activity、Service 实现了 Context 接口，因此可以在 API 调用需要 Context 参数的地方使用它们

简单来说，机器人是一团糟，除非你不再担心，否则你不会喜欢。Context

Android 是：Context

• 神客体。

• 当你开始为 Android 开发时，你想传递你的所有应用程序，但当你更接近编程、测试和 Android 本身时，就会避免这样做。

  • 依赖关系不明确。

  • 内存泄漏的常见来源。

  • PITA 用于测试。

• Android 系统用于调度权限、资源、首选项、服务、广播、样式、显示对话框和膨胀布局的实际上下文。对于一些单独的事物，您需要不同的实例（显然，您不能显示来自应用程序或服务上下文的对话框;从应用程序和活动上下文中膨胀的布局可能会有所不同）。Context

 Context表示电流。 用于对当前屏幕执行操作。 例如：
1. getApplicationContext（） 2. getContext（）
Context

Toast.makeText(getApplicationContext(), "hello", Toast.LENGTH_SHORT).show();

• Context表示用于获取环境数据的句柄。
• Context类本身被声明为抽象，其实现由 android 操作系统提供。
• Context就像电视遥控器和电视频道的遥控器一样，电视中的资源、服务等。

你能用它做什么？

• 加载资源。
• 启动新活动。
• 创建视图。
• 获取系统服务。

获取上下文的方法：

• getApplicationContext()
• getContext()
• getBaseContext()

默认情况下，此属性声明与此布局关联的活动。

老板助理类比

在深入研究 Context 的技术性之前，让我们先做一个小类比

每个老板都有一个助理或某人（跑腿男孩），他做得更少 对他来说，重要且更耗时的事情。例如，如果他们 需要文件或咖啡，然后助手将运行。老板不会 知道后台发生了什么，但文件或任务会 交付

So Here
Boss - Android 应用
助手 - 上下文
文件或一杯咖啡 - 资源

Android 开发者官方网站对 Context 的评价

上下文是应用程序相关资源的访问点

让我们看看其中的一些资源或任务

• 启动活动。

• 获取文件系统上特定于应用程序的缓存目录的绝对路径。

• 确定是否允许对系统中运行的特定进程和用户 ID 使用给定的权限。

• 检查您是否被授予了特定权限。

等等。
因此，如果一个 Android 应用程序想要启动一个 Activity，它会直接进入 （Access Point），然后类会把资源还给他（在本例中为 Intent）。ContextContext

像任何其他类一样，类具有字段和方法。
您可以在官方文档中探索更多信息，它几乎涵盖了所有内容、可用方法、字段，甚至如何将字段与方法一起使用。ContextContext

Context指不同时间段内的组件（或应用程序）。如果我在下午 1 点到 2 点之间吃了这么多食物，那么我那段时间的上下文将用于访问我在那段时间使用的所有方法（或资源）。内容是特定时间的组件（应用程序）。应用程序的组件会根据组件或应用程序的基础生命周期不断变化。 例如，在 onCreate（） 中 ，ContextActivity

getBaseContext()-- 给出由 Activity 的构造函数设置（创建）的。 -- 在创建应用程序期间提供设置（创建）。contextActivitygetApplicationContext()Context

注意：包含所有 Android 组件。<application>

<application>
    <activity> .. </activity> 

    <service>  .. </service>

    <receiver> .. </receiver>

    <provider> .. </provider>
</application> 

这意味着，当您从任何组件内部调用时，您正在调用整个应用程序的公共上下文。getApplicationContext()

Context系统会根据组件的生命周期不断进行修改。

上下文意味着 Android 知道我应该参加或参与哪些活动。

1 - 它用于此。Toast.makeText(context, "Enter All Details", Toast.LENGTH_SHORT).show();Context context = ActivityName.this;

2 -startActivity(new Intent(context,LoginActivity.class));

在此上下文中，意味着您要从哪个活动转到其他活动。 context 或 ActivityName.this 比 getContext 和 getApplicatinContext 更快。

将 Context 视为具有不同资源的框：字符串、颜色和字体。如果你需要资源，你可以转向这个框。旋转屏幕时，此框会更改，因为方向更改为横向。

有关上下文的更多详细信息，请阅读此文章。我将简要解释一下。

如果你想知道什么是上下文，你必须知道它的作用......
例如，getContext（） 是检索上下文的方法之一。在 getContext（） 中，Context 与 Activity 及其生命周期相关联。我们可以将上下文想象成站在 Activity 后面的层，只要 Activity 存在，它就会存在。Activity 消亡的那一刻，Context 也会消亡。此方法为活动提供功能列表，例如：

Load Resource Values,
Layout Inflation,
Start an Activity,
Show a Dialog,
Start a Service,
Bind to a Service,
Send a Broadcast,
Register BroadcastReceiver.

现在想象一下：

上下文是位于其组件后面的层（接口） （活动、应用......和组件的生命周期，它提供 访问应用程序支持的各种功能 环境和 Android 框架。

Context 是 Android 提供的抽象类，因此，它的工作是将应用程序代码与 Android 系统桥接起来。通过继承自 Context 的类（活动、服务和应用程序），您的应用能够访问只有操作系统才能访问的资源和功能。

当上下文后代对象作系统实例化时（通过操作系统控制的实例化机制，如“意图”），它们将由操作系统管理，因此，它们将获得生命周期。

对于其他任何内容，在方法调用中将上下文作为参数传递，允许此方法使用上下文作为与操作系统的通信通道，以便到达操作系统并要求它执行某些操作或返回某些资源。

将上下文与清单一起可视化

为了直观地显示 Android 上下文和清单的运行情况，旧的呼叫中心总机是一个很好的类比。

基础是 Android 系统，其中出现了连接每个正在运行的应用程序的所有应用程序组件的所有电线。

1. 每个“交换机应用程序”都包含一些插件，这些插件表示应用程序的清单组件声明。因此，通过清单声明，Android 系统可以了解这些插件的存在，因此它可以通过 intent 创建对象来插入新的上下文线。

2. 每条线代表一个 Android Context，连接到应用的某个可启动组件或应用本身。您可以使用现有的电线，因为它与Android系统连接，以便请求完成需要通过操作系统的各种事情。

3. 您可以假设，当一个活动被破坏时，它的电线会被拔掉。而当构造另一个活动（或另一个组件）时，会出现一条新电线并连接到正确的清单声明的插件。

我写了一整篇文章，解释了 Context 如何将您的应用程序与 android 系统耦合：

上下文到底是什么？

根据 Android 参考文档，它是一个表示各种环境数据的实体。它提供对本地文件、数据库、与环境关联的类装入器、服务（包括系统级服务）等的访问。在本书中，以及在使用 Android 的日常编码中，你会看到 Context 经常被传递。

摘自《Android in Practice》一书，第 60 页。

多个 Android API 需要将 Context 作为参数

如果您浏览各种 Android API，您将 请注意，他们中的许多人将对象视为 参数。您还将看到 Activity 或 Service 通常用作 .这之所以有效，是因为这两个类都是从 扩展而来的。android.content.ContextContextContext

如果你看一下 https://stackoverflow.com/a/16301475/1772898 的评论，你会发现 ulf-edholm 的评论

嗯，对我来说，这听起来像是我们老前辈过去所说的全局变量，当面向对象进入场景时，这非常不受欢迎

他是对的。上下文是全局变量的替代方法。

为简单起见，我们可以这样说：global variable ≈ context

上下文相对于全局变量的好处是，全局变量使得不可能在同一进程中创建同一系统的两个独立实例，而上下文允许系统的多个实例在单个进程中共存，每个实例都有自己的上下文。

请查看 John Ousterhout 的 A Philosophy of Software Design， 7.5 Pass-through variables。

全局变量使得无法创建两个独立的变量 同一进程中同一系统的实例，因为访问 全局变量将发生冲突。

...

我最常使用的解决方案是引入一个上下文对象，如 图 7.2（d）.上下文存储应用程序的所有全局状态 （否则将是传递变量或全局变量的任何内容 变量）。大多数应用程序在其全局变量中都有多个变量 状态，表示诸如配置选项之类的内容，共享 子系统和性能计数器。每个 Context 对象有一个 系统实例。上下文允许 系统在单个进程中共存，每个进程都有自己的上下文。

稍后在评论部分，您会发现 Bjornw 的另一条评论

如果你只是 grep 一个代码库，你会看到数百个不同的 getContext、getBaseContext 和 getBlaBlaContext。

他也是对的。

为了减少必须了解上下文的方法数，在许多主要对象中都引用了对上下文的引用。这就是为什么你会看到 getContext、getBaseContext、getBlaBlaContext 的原因。在很多地方。

参考资料：John Ousterhout 的《软件设计哲学》，7.5 传递变量。

不幸的是，许多地方可能需要上下文，因此 它可能成为传递变量。要减少 必须意识到它的方法数，对上下文的引用 可以保存在系统的大多数主要对象中。在示例中 图 7.2（d），包含 m3 的类存储了对 context 作为其对象中的实例变量。当一个新对象 created，则 creating 方法从其 对象并将其传递给新对象的构造函数。有了这个 方法，上下文随处可用，但仅显示为 构造函数中的显式参数。

另一个类比：

Context可以看作是办公室钥匙卡。 您必须随身携带它才能进入某些限制区域。 在 Android 中，这包括：系统服务、应用程序文件、资产、主题、权限等。

在实践中，a 由应用程序组件表示（例如，）。就像不同的钥匙卡可以解锁某些门而不能解锁其他门一样，某些应用程序组件的用途有限（例如，您不能使用它来启动对话框或膨胀布局）。ContextActivityServiceContext