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

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

Упрощенные условия ::

• Рассмотрим, что Person-X является генеральным директором компании-разработчика программного обеспечения.

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

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

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

Упрощенные условия ::

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

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

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

• Вы попросите человека, обслуживающего номера, принести вам эти вещи.

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

Вещи, которые связаны с контекстом:

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

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

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

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

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

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

Пример:

TextView TV=new TextView(this);

this → относится к контексту текущей активности.

Источник

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

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

Что такое контекст?

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

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

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

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

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

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

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

Результатом является то, что Context - это то, что позволяет получить доступ к системным ресурсам и тем, какие компоненты перехватывают в "большее приложение". Давайте рассмотрим подклассы Context, классы, которые обеспечивают реализацию абстрактного класса Context. Наиболее очевидным классом является класс Activity. Activity наследует от 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).

На этом этапе мы начинаем заглядывать в внутреннюю систему.

Здесь ОС фактически обрабатывает все. Итак, как Instrumentation начинает работу точно? Ну, параметр this в методе execStartActivity выше - ваша Activity, то есть Context, и execStartActivity использует этот контекст.

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

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

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

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

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

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

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

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

Пока вы все равно будете думать, подумайте, большой.

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

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

АНДРОИД И КОНТЕКСТ

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

Что такое контекст?

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

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

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

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

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

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

В этом случае

Boss - приложение для Android

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

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

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

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

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

getContext()

getBaseContext()

getApplicationContext()

this

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

Что вы можете с ним сделать?

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

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

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

Просто поместите его там для новичков;

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

В англо-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 в Android. http://www.doubleencore.com/2013/06/context/

одна из хороших ссылок о Context

http://possiblemobile.com/2013/06/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.content.Context обеспечивает подключение к системе Android, которая выполняет приложение. Например, вы можете проверить размер текущего дисплея устройства через контекст.

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

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

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

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

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

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

Контекст - это в основном доступ к ресурсам и получение информации о среде для приложения (для контекста приложения) или активности (для контекста активности) или любого другого...

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

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

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

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

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

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

A Context - это то, что большинство из нас назвало бы Application. Он создан системой Android и способен делать только то, что может сделать приложение. В Tomcat контекст также является тем, что я бы назвал приложением.

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

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

Контекст означает, что Android узнает, в какую деятельность я должен пойти или действовать.

1 - Toast.makeText (контекст, "Ввести все детали", Toast.LENGTH_SHORT).show(); он использовал в этом. Контекстный контекст = ActivityName.this;

2 -startActivity (новый Intent (контекст, LoginActivity.class));

в этом контексте означает, из какой деятельности вы хотите перейти на другую деятельность. контекст или ActivityName.this быстрее, getContext и getApplicatinContext.

Помощник помощника босса

Позволяет иметь небольшую аналогию, прежде чем погрузиться глубоко в технику Контекста

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

Так вот
Босс - приложение для Android
Помощник - Контекст
Файл или чашка кофе - Ресурс

Какой официальный сайт Android Developer говорит о Context

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

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

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

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

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

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

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

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

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

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

Простое, андроиды Context - это беспорядок, который вам не понравится, пока вы не перестанете беспокоиться.

Android Context:

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

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

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

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

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

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

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

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

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

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

Контекст < ContextWrapper < Применение

Контекст < ContextWrapper < ContextThemeWrapper < Активность

Контекст < ContextWrapper < ContextThemeWrapper < Активность < ListActivity

Контекст < ContextWrapper < Сервис

Контекст < ContextWrapper < Обслуживание < IntentService

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

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

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

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

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

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

    <service>  .. </service>

    <receiver> .. </receiver>

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

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

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

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

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

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

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

Разница между контекстом работы и контекстом приложения:

Они оба являются экземплярами Context, но экземпляр приложения привязан к жизненному циклу приложения, а экземпляр Activity привязан к жизненному циклу Activity. Таким образом, они имеют доступ к различной информации о среде приложения.

Если вы читаете документы в getApplicationContext, он отмечает, что вы должны использовать это, только если вам нужен контекст, жизненный цикл которого отделен от текущего контекста.

Но, в общем, используйте контекст активности, если у вас нет веских оснований.

Необходимость контекста:

В документации говорится, что для каждого представления нужен контекст для доступа к нужным ресурсам (например, тема, строки и т.д.).

Но почему в конструкторе, а не через setContentView (View)?

1.Потому что ресурсы должны быть доступны во время создания представления (для полного инициализации представления конструктору потребуются некоторые ресурсы).

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

3. Дизайнеры Android SDK, похоже, выбрали, что контекст должен быть установлен только один раз, а затем оставаться неизменным на протяжении всего жизненного цикла представления. Почему контекст не определяется автоматически в точке строительства?

1. Если нет статической переменной, которая сообщит вам текущий глобальный контекст вашего приложения. Метод getApplicationContext() является самым близким к нему, но не является статичным, поэтому вам нужен экземпляр объекта Activity для его вызова.

2. Язык Java предоставляет возможность просматривать стек вызовов и определять, был ли View создан в классе Context. Но что, если их много? Или что, если их нет? Этот метод очень дорог и подвержен ошибкам. Поэтому разработчики API решили, что контекст должен быть предоставлен вручную.

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

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

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

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

Context con = this;

getApplicationContext();

getBaseContext();

getContext();