Что такое Contextкласс в программировании Android и для чего он используется?

Я читал об этом на сайте разработчика , но не могу понять это ясно.

Проще говоря:

Как следует из названия, это контекст текущего состояния приложения / объекта. Это позволяет вновь созданным объектам понять, что происходит. Как правило, вы звоните, чтобы получить информацию о другой части вашей программы (деятельность и пакет / приложение).

Вы можете получить контекст вызова getApplicationContext(), getContext(), getBaseContext()или this(если в классе , который простирается от Context, например, приложения, активность, классы обслуживания и IntentService).

Типичное использование контекста:

• Создание новых объектов : создание новых представлений, адаптеров, слушателей:

  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, ...);

Определение контекста

• Контекст представляет данные среды
• Он обеспечивает доступ к таким вещам, как базы данных

Более простые термины (пример 1)

• Представьте себе, что Person-X является генеральным директором начинающей софтверной компании.

• В компании присутствует ведущий архитектор, этот ведущий архитектор выполняет всю работу в компании, такую ​​как базы данных, пользовательский интерфейс и т. Д.

• Теперь генеральный директор нанимает нового разработчика.

• Именно Архитектор сообщает об ответственности вновь нанятого человека, основываясь на навыках нового человека, независимо от того, будет ли он работать над базой данных, пользовательским интерфейсом и т. Д.

Более простые термины (пример 2)

• Это похоже на доступ активности Android к ресурсу приложения.

• Это похоже на то, когда вы посещаете отель, вы хотите завтракать, обедать и ужинать в подходящее время, верно?

• Есть много других вещей, которые вам нравятся во время пребывания. Как вы получаете эти вещи?

• Вы просите служащего обслуживания номеров принести эти вещи для вас.

• Здесь обслуживающий персонал - это контекст, считающий, что вы - единственное занятие, а отель - ваше приложение, и, наконец, завтрак, обед и ужин должны быть ресурсами.

Вещи, которые включают контекст:

1. Загрузка ресурса.
2. Запуск новой деятельности.
3. Создание просмотров.
4. получение системного сервиса.

Контекст - это базовый класс для Activity , Service , Application и т. Д.

Еще один способ описать это: Рассматривать контекст как удаленный от телевидения, а каналы в телевизоре - это ресурсы, услуги, использование намерений и т. Д. - - - Здесь удаленный доступ действует как доступ для получения доступа ко всем различным ресурсам на переднем плане.

• Таким образом, Remote имеет доступ к таким каналам, как ресурсы, услуги, использование намерений и т. Д.

• Аналогично ... Тот, кто имеет доступ к удаленному, естественно, имеет доступ ко всем вещам, таким как ресурсы, услуги, использование намерений и т. Д.

Различные методы, с помощью которых вы можете получить контекст

• getApplicationContext()
• getContext()
• getBaseContext()
• или this(когда в классе деятельности)

Пример:

TextView tv = new TextView(this);

Ключевое слово thisотносится к контексту текущей деятельности.

Источник

Тема контекста в Android, кажется, многих сбивает с толку. Люди просто знают, что контекст необходим довольно часто для выполнения основных задач в Android. Люди иногда впадают в панику, потому что они пытаются выполнить какую-то операцию, которая требует контекста, и они не знают, как «получить» правильный контекст. Я собираюсь попытаться демистифицировать идею контекста в Android. Полное рассмотрение проблемы выходит за рамки этого поста, но я постараюсь дать общий обзор, чтобы у вас было представление о том, что такое контекст и как его использовать. Чтобы понять, что такое контекст, давайте взглянем на исходный код:

https://github.com/android/platform_frameworks_base/blob/master/core/java/android/content/Context.java

Что именно является контекстом?

Ну, сама документация дает довольно простое объяснение: класс Context - это «Интерфейс для глобальной информации о среде приложения».

Сам класс Context объявлен как абстрактный класс, реализация которого обеспечивается ОС Android. В документации также указывается, что Контекст «… разрешает доступ к ресурсам и классам, относящимся к конкретному приложению, а также к дополнительным вызовам для операций на уровне приложения, таких как операции запуска, широковещательная рассылка и получение и т.д.».

Теперь вы можете очень хорошо понять, почему имя называется «Контекст». Это потому, что это просто так. Контекст предоставляет ссылку или ловушку, если хотите, для Действия, Сервиса или любого другого компонента, тем самым связывая его с системой, обеспечивая доступ к глобальной среде приложения. Другими словами: Контекст дает ответ на вопрос компонентов: «Где я, черт возьми, по отношению к приложению в целом и как я могу получить доступ к общему приложению / общаться с ним?» Если все это немного сбивает с толку, быстрый взгляд на методы, предоставляемые классом Context, дает некоторые дополнительные сведения о его истинной природе.

Вот случайная выборка этих методов:

1. getAssets()
2. getResources()
3. getPackageManager()
4. getString()
5. getSharedPrefsFile()

Что общего у всех этих методов? Все они позволяют любому, кто имеет доступ к контексту, иметь доступ к ресурсам всего приложения.

Другими словами, контекст подключает компонент, имеющий ссылку на него, к остальной части среды приложения. Например, ресурсы (например, папка «/ assets» в вашем проекте) доступны по всему приложению при условии, что Activity, Сервис или кто-либо еще знает, как получить доступ к этим ресурсам. То же самое касается того, getResources()что позволяет нам делать такие вещи, getResources().getColor()которые зацепят вас вcolors.xml привязывать ресурсу (не говоря уже о том, что aapt обеспечивает доступ к ресурсам через код Java, это отдельная проблема).

В результате, это то Context, что обеспечивает доступ к системным ресурсам и их компонентам, которые подключают к «большему приложению». Давайте посмотрим на подклассы Contextклассов, обеспечивающих реализацию абстрактного Contextкласса. Наиболее очевидный класс - это Activityкласс. ActivityНаследует from ContextThemeWrapper, который наследует от ContextWrapper, который наследует от Contextсамого себя. Эти классы полезны для понимания вещей на более глубоком уровне, но на данный момент достаточно знать это ContextThemeWrapperи ContextWrapperв значительной степени они звучат так. Они реализуют абстрактные элементы сам Contextкласс путем «обертывания» контекста (фактического контекста) и делегирования этих функций этому контексту.ContextWrapperкласс, абстрактный метод getAssetsиз Contextкласса реализован следующим образом:

@Override
    public AssetManager getAssets() {
        return mBase.getAssets();
    }

mBaseэто просто набор полей конструктором для определенного контекста. Таким образом, контекст ContextWrapperпереносится, и делегирует свою реализацию метода getAssets этому контексту. Давайте вернемся к рассмотрению Activityкласса, который в конечном итоге наследуется, Contextчтобы увидеть, как все это работает.

Вы, наверное, знаете, что такое «Активность», но пересмотреть - это «единственная вещь, которую может сделать пользователь. Он заботится о предоставлении окна для размещения пользовательского интерфейса, с которым взаимодействует пользователь ». Разработчики, знакомые с другими API-интерфейсами, и даже не разработчики могут воспринимать это как «экран». Это технически неточно, но это не имеет значения для наших целей. Итак , как Activityи Contextвзаимодействуют и что именно происходит в их отношениях наследования?

Опять же, полезно взглянуть на конкретные примеры. Мы все знаем, как начать деятельность. Если у вас есть «контекст», из которого вы запускаете действие, вы просто вызываете startActivity(intent), где Intent описывает контекст, из которого вы запускаете действие, и действие, которое вы хотели бы начать. Это знакомый startActivity(this, SomeOtherActivity.class).

А что есть this? thisваша активность, потому что Activityкласс наследует от Context. Полный цикл выглядит так: когда вы вызываете startActivity, в конечном итоге Activityкласс выполняет что-то вроде этого:

Instrumentation.ActivityResult ar =
                mInstrumentation.execStartActivity(
                    this, mMainThread.getApplicationThread(), mToken, this,
                    intent, requestCode);

Таким образом, он использует execStartActivityиз Instrumentationкласса (на самом деле из внутреннего класса в Instrumentationвызываемом ActivityResult).

На данный момент, мы начинаем смотреть на внутренние системы.

Это где ОС на самом деле обрабатывает все. Так как же Инструментарий запускает Активность точно? Ну, параметр thisв execStartActivityметоде выше - это ваша активность, то есть контекст, и execStartActivityиспользует этот контекст.

Обзор 30 000 заключается в следующем: класс Instrumentation отслеживает список операций, которые он отслеживает для выполнения своей работы. Этот список используется для координации всех действий и обеспечения бесперебойной работы потока операций.

Есть некоторые операции, которые я не полностью изучил, для решения каких проблем потока и процесса. В конечном счете, ActivityResultиспользуется нативная операция, ActivityManagerNative.getDefault().startActivity()которая использует то, Contextчто вы передали при вызове startActivity. Контекст, который вы передали, используется для «разрешения намерений», если это необходимо. Умышленное разрешение - это процесс, с помощью которого система может определить цель намерения, если оно не предоставлено. (Проверьте руководство здесь для более подробной информации).

И для того, чтобы Android мог это сделать, ему необходим доступ к информации, предоставленной Context. В частности, система должна иметь доступ к ней, ContentResolverчтобы она могла «определить MIME-тип данных намерения». Весь этот вопрос о том, как startActivityиспользование контекста было немного сложным, и я сам не до конца понимаю внутренние механизмы. Моя главная мысль Это было просто для иллюстрации того, как нужно обращаться к ресурсам всего приложения, чтобы выполнить многие из операций, которые важны для приложения Context. Вот что обеспечивает доступ к этим ресурсам. Более простым примером могут быть представления. Мы все знаем, что вы создаете. Пользовательский вид путем расширения RelativeLayoutили какого-либо другого Viewкласса, вы должны предоставить конструктор, который принимаетContextв качестве аргумента. Когда вы создаете экземпляр своего пользовательского представления, вы переходите в контекст. Почему? Поскольку представление должно иметь доступ к темам, ресурсам и другим деталям конфигурации представления. Просмотр конфигурации на самом деле отличный пример. Каждый контекст имеет различные параметры (поля в Contextроссийских реализациях), которые устанавливаются самой ОС для таких вещей, как размерность или плотность отображения. Легко понять, почему эта информация важна для настройки представлений и т. Д.

Последнее слово: по какой-то причине люди, плохо знакомые с Android (и даже не новички), похоже, полностью забывают об объектно-ориентированном программировании, когда речь заходит об Android. По какой-то причине люди пытаются склонить свои разработки под Android к заранее продуманным парадигмам или изученному поведению.

У Android есть своя собственная парадигма и определенная схема, которая на самом деле вполне последовательна, если отпустить ваши предвзятые представления и просто прочитать документацию и руководство для разработчиков. Моя реальная точка зрения, однако, хотя «получение правильного контекста» может иногда быть хитрым, люди неоправданно паникуют, потому что сталкиваются с ситуацией, когда им нужен контекст, и думают, что его нет. Еще раз, Java является объектно-ориентированным языком с дизайном наследования.

Вы только «имеете» контекст внутри своей Деятельности, потому что ваша деятельность сама наследуется от Контекста. В этом нет ничего волшебного (за исключением всего того, что сама ОС делает для установки различных параметров и для правильной «настройки» вашего контекста). Таким образом, оставляя в стороне проблемы с памятью / производительностью (например, удерживая ссылки на контекст, когда вам это не нужно, или делая это таким образом, что это имеет негативные последствия для памяти и т. Д.), Context - это объект, подобный любому другому, и его можно передавать как и любой POJO (обычный старый объект Java). Иногда вам может потребоваться сделать что-то умное для извлечения этого контекста, но любой обычный класс Java, который расширяется из ничего, кроме самого объекта, может быть написан так, чтобы иметь доступ к контексту; просто предоставьте открытый метод, который принимает контекст, а затем использует его в этом классе по мере необходимости.

Контекст - это дескриптор системы; он предоставляет такие услуги, как разрешение ресурсов, получение доступа к базам данных и настройкам и т. д. В приложении для Android есть действия. Контекст подобен дескриптору среды, в которой ваше приложение в данный момент выполняется. Объект действия наследует объект контекста.

Для получения дополнительной информации см. Введение в разработку Android с Android Studio - Учебное пособие .

Contextявляется «интерфейсом» к глобальной информации о среде приложения. На практике Contextэто на самом деле абстрактный класс , реализация которого обеспечивается системой Android.

Он позволяет получить доступ к ресурсам и классам, относящимся к конкретному приложению, а также к дополнительным вызовам для операций на уровне приложения, таких как запуск, широковещание и получение и т.д.

На следующем рисунке вы можете увидеть иерархию классов, где Contextнаходится корневой класс этой иерархии. В частности, стоит подчеркнуть, что Activityявляется потомком Context.

Что Contextименно?

Согласно справочной документации по Android, это объект, представляющий различные данные среды. Он обеспечивает доступ к локальным файлам, базам данных, загрузчикам классов, связанным со средой, службам (включая службы системного уровня) и многим другим. В этой книге и в повседневной работе с Android вы будете часто видеть контекст.

Из книги « Android на практике », стр. 60.

Некоторым API Android требуется Contextпараметр as

Если вы посмотрите на различные API Android, вы заметите, что многие из них принимают android.content.Contextобъект в качестве параметра. Вы также увидите, что Деятельность или Служба обычно используются как Context. Это работает, потому что оба эти класса расширяются от Context.

Простой пример для понимания contextв Android:

У каждого босса есть помощник, за которым нужно ухаживать, выполнять все менее важные и трудоемкие задачи. Если файл или чашка кофе необходимы, помощник в бегах. Некоторые начальники почти не знают, что происходит в офисе, поэтому они спрашивают своих помощников об этом тоже. Они выполняют некоторую работу сами, но в большинстве других случаев им нужна помощь их помощников.

В этом сценарии

Босс - это приложение для Android

Помощник - это контекст

Файлы / Чашка кофе - это ресурсы

Обычно мы называем контекст, когда нам нужно получить информацию о различных частях нашего приложения, таких как «Действия», «Приложения» и т. Д.

Некоторые операции (вещи, где нужен помощник), где задействован контекст:

• Загрузка общих ресурсов
• Создание динамических представлений
• Отображение тостовых сообщений
• Запуск деятельности и т. Д.

Различные способы получения контекста:

getContext()

getBaseContext()

getApplicationContext()

this

Контекст Android - это Интерфейс (в общем смысле, а не в смысле Java; в Java Contextэто на самом деле абстрактный класс!), Который обеспечивает доступ к конкретным ресурсам приложения, а также к классу и информации о среде приложения.

Если бы ваше приложение для Android было веб-приложением, ваш контекст был бы чем-то похожим ServletContext(я не буду здесь точно сравнивать).

Ваши действия и службы также расширяются Context, поэтому они наследуют все эти методы для доступа к информации о среде, в которой работает приложение.

• Context представляет дескриптор для получения данных среды.
• Context Сам класс объявляется как абстрактный, реализация которого обеспечивается ОС Android.
• Context это как удаленные от телевидения и каналы в телевизоре ресурсы, услуги и т. д.

Что ты можешь сделать с этим ?

• Загрузка ресурса.
• Запуск новой деятельности.
• Создание просмотров.
• Получение системного сервиса.

Способы получения контекста:

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

Просто выкладываю это для новичков;

Итак, сначала поймите Слово Контекст:

На английском языке-lib. это значит:

«Обстоятельства, которые формируют обстановку для события, утверждения или идеи, и с точки зрения которых они могут быть полностью поняты и оценены».

«Части чего-либо написанного или сказанного, которые предшествуют и следуют за словом или отрывком и разъясняют его значение».

Теперь отнеситесь к миру программирования с тем же пониманием:

контекст текущего состояния приложения / объекта. Это позволяет вновь созданным объектам понять, что происходит. Как правило, вы звоните, чтобы получить информацию о другой части вашей программы (деятельность, пакет / приложение)

Вы можете получить контекст, вызвав getApplicationContext(), getContext(), getBaseContext()или this(когда в классе деятельности).

Для получения контекста Anywhere в приложении используйте следующий код:

Создайте новый класс AppContextв вашем приложении для Android

public class AppContext extends Application {

    private static Context context;

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

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

Теперь, когда вам нужен контекст приложения в неактивном классе, вызовите этот метод, и вы получите контекст приложения.

Надеюсь это поможет;)

Думайте об этом как о виртуальной машине, которая изолировала процесс, в котором выполняется приложение или служба. Изолированная среда имеет доступ к куче базовой информации о системе и определенных разрешенных ресурсов. Вам нужен этот контекст, чтобы получить эти услуги.

Контекст является ссылкой на текущий объект, как это. Также контекст позволяет получить доступ к информации о среде приложения.

Класс android.content.Contextобеспечивает подключение к системе Android и ресурсам проекта. Это интерфейс к глобальной информации о среде приложения.

Контекст также обеспечивает доступ к Сервисам Android, например, к Службе определения местоположения.

Деятельность и услуги расширяют Contextкласс.

Context is Экземпляры класса android.content.Context обеспечивают соединение с системой Android, которая выполняет приложение. Например, вы можете проверить размер отображения текущего устройства через контекст.

Это также дает доступ к ресурсам проекта. Это интерфейс к глобальной информации о среде приложения.

Класс Context также обеспечивает доступ к службам Android, например, диспетчеру аварийных сигналов для запуска событий, основанных на времени.

Действия и сервисы расширяют класс Context. Поэтому они могут быть непосредственно использованы для доступа к контексту.

Контекст - это интерфейс к глобальной информации о среде приложения. Это абстрактный класс, реализация которого обеспечивается Androidсистемой.

Context обеспечивает доступ к ресурсам и классам приложений, а также к вызовам таких операций на уровне приложений, как launching activities, broadcasting and receiving intents, etc.

Вот пример

 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, такой как локальные файлы, базы данных, загрузчики классов, связанные с этой средой, сервисы, включая сервисы системного уровня, и многое другое.

Контекст - это дескриптор системы. Он предоставляет такие услуги, как разрешение ресурсов, получение доступа к базам данных и настройкам и т. Д. В приложении для Android есть действия. Это похоже на дескриптор среды, в которой ваше приложение в данный момент выполняется. Объект действия наследует объект Context.

Различные вызывающие методы, с помощью которых вы можете получить контекст 1. getApplicationContext (), 2. getContext (), 3. getBaseContext () 4. или this (в классе активности).

Контекст означает, что 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это то, что большинство из нас назвали бы Приложением . Он сделан системой Android и может делать только то, что умеет приложение. В Tomcat контекст также является тем, что я бы назвал приложением.

Существует один контекст, который содержит много действий, каждое действие может иметь много представлений.

Очевидно, что некоторые скажут, что это не подходит из-за того или иного, и, вероятно, они правы, но если вы скажете, что Context - это ваше текущее приложение, это поможет вам понять, что вы вводите в параметры метода.

Помощник босса Аналогия

Давайте проведем небольшую аналогию, прежде чем углубляться в технические аспекты контекста.

У каждого босса есть помощник или кто-то (мальчик на побегушках), который делает для него менее важные и более трудоемкие вещи. Например, если им нужен файл или кофе, помощник будет в бегах. Босс не будет знать, что происходит в фоновом режиме, но файл или задание будет доставлено

So Here
Boss - Android Application
Assistant -
Файл контекста или чашка кофе - Ресурс

Что официальный сайт разработчика Android говорит о контексте

Контекст - это ваша точка доступа к ресурсам, связанным с приложением

Давайте посмотрим на некоторые из таких ресурсов или задач

• Запуск деятельности.

• Получение абсолютного пути к каталогу кэша приложения в файловой системе.

• Определение того, разрешено ли данное разрешение для определенного процесса, и идентификатор пользователя, работающий в системе.

• Проверка, было ли вам предоставлено конкретное разрешение.

И так далее.
Так что, если приложение Android хочет начать действие, оно идет прямо к Context(Точка доступа), иContext класс возвращает ему ресурсы (в данном случае Intent).

Как и у любого другого класса, Contextкласс имеет поля и методы.
Вы можете узнать больше об Contextофициальной документации, она охватывает почти все, доступные методы, поля и даже как использовать поля с методами.

Экземпляры класса android.content.Context обеспечивают соединение с системой Android, которая выполняет приложение. Например, вы можете проверить размер отображения текущего устройства через контекст.

Это также дает доступ к ресурсам проекта. Это интерфейс к глобальной информации о среде приложения.

Класс Context также обеспечивает доступ к службам Android, например, диспетчеру аварийных сигналов для запуска событий, основанных на времени.

Действия и сервисы расширяют класс Context. Поэтому они могут быть непосредственно использованы для доступа к контексту.

Если вы хотите связать Context с другими знакомыми классами в Android, имейте в виду следующую структуру:

Context <ContextWrapper <Приложение

Context <ContextWrapper <ContextThemeWrapper <Деятельность

Context <ContextWrapper <ContextThemeWrapper <Activity <ListActivity

Context <ContextWrapper <Сервис

Context <ContextWrapper <Service <IntentService

Итак, все эти классы являются контекстами по-своему. Вы можете преобразовать Service и ListActivity в Context, если хотите. Но если присмотреться, некоторые классы также наследуют тему. В упражнении или фрагменте вы хотели бы, чтобы они применялись к вашим представлениям, но вам не важно , например, класс обслуживания .

Я объясняю разницу в контекстах здесь .

Проще говоря, Android Context- это беспорядок, который вы не полюбите, пока не перестанете беспокоиться.

Android Contextявляются:

• Бог-объекты.

• То, что вы хотите передать всем своим приложениям, когда начинаете разработку для Android, но избегаете этого, когда вы немного приблизитесь к программированию, тестированию и самому Android.

  • Непонятная зависимость.

  • Общий источник утечек памяти.

  • PITA для тестирования.

• Фактический контекст, используемый системой Android для отправки разрешений, ресурсов, предпочтений, сервисов, трансляций, стилей, отображения диалогов и раздувания макета. И вам нужны разные Contextэкземпляры для некоторых отдельных вещей (очевидно, вы не можете показать диалог из контекста приложения или службы; макеты, накачанные из контекста приложения и действия, могут отличаться).

Контекст андроида конкретных апи для каждого приложения-s песочницы , которая обеспечивает доступ приложения личные данные , такую как к ресурсам, базам данных, частным filedirectories, предпочтение, настройка ...

Большинство приватных данных одинаковы для всех видов деятельности / услуг / широковещательных списков одного приложения.

Поскольку Application, Activity, Service реализуют интерфейс Context, их можно использовать там, где для вызова API требуется параметр Context.

Contextозначает компонент (или приложение) в различный период времени. Если я ем очень много пищи между 13:00 и 14:00, тогда мой контекст того времени используется для доступа ко всем методам (или ресурсам), которые я использую в течение этого времени. Контент - это компонент (приложение) на определенное время. ContextКомпоненты приложения продолжает изменяться на основе базового жизненного цикла компонентов или приложения. Например, внутри onCreate () объекта Activity,

getBaseContext()- дает contextиз , Activityкоторый устанавливается (создается) конструктором деятельности. getApplicationContext()- дает Contextнастройки (созданные) при создании приложения.

Примечание: <application>содержит все компоненты Android.

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

    <service>  .. </service>

    <receiver> .. </receiver>

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

Это означает, что когда вы вызываете getApplicationContext()изнутри любой компонент, вы вызываете общий контекст всего приложения.

Context система постоянно изменяется в зависимости от жизненного цикла компонентов.

Думайте о контексте как о блоке с различными ресурсами: строкой, цветами и шрифтами. Если вам нужен ресурс, вы переходите к этому полю. При повороте экрана это поле изменяется, поскольку ориентация меняется на альбомную.

 Contextозначает текущий. Contextиспользуйте, чтобы сделать операцию для текущего экрана. ех.
  1. getApplicationContext ()
  2. getContext ()

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

Великолепные объяснения! В дополнение ко всему вышесказанному, я нашел этот пример из MindOrks очень полезным, даже показывает некоторые базовые сценарии использования, чтобы заставить ваш разум работать:

Понимание контекста в приложении Android

В Java мы говорим, что это ключевое слово относится к состоянию текущего объекта приложения.
Точно так же у нас есть альтернатива Contextв разработке Android.

Это можно определить явно или неявно,

Context con = this;

getApplicationContext();

getBaseContext();

getContext();

Этот атрибут объявляет, с каким действием этот макет связан по умолчанию .