Na programação do Android, o que exatamente é uma Contextclasse e para que é usada?

Eu li sobre isso no site do desenvolvedor , mas não consigo entendê-lo claramente.

Simplificando:

Como o nome sugere, é o contexto do estado atual do aplicativo / objeto. Ele permite que objetos recém-criados entendam o que está acontecendo. Normalmente, você o chama para obter informações sobre outra parte do seu programa (atividade e pacote / aplicativo).

Você pode obter o contexto invocando getApplicationContext(), getContext(), getBaseContext()ou this(quando em uma classe que se estende desde Context, tais como a aplicação, Actividade, classes de serviço e IntentService).

Usos típicos do contexto:

• Criando novos objetos : Criando novas visualizações, adaptadores, ouvintes:

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

• Acessando recursos comuns padrão : Serviços como LAYOUT_INFLATER_SERVICE, SharedPreferences:

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

• Acessando componentes implicitamente : em relação aos provedores de conteúdo, transmissões, intenção

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

Definição de Contexto

• O contexto representa dados do ambiente
• Fornece acesso a coisas como bancos de dados

Termos mais simples (exemplo 1)

• Considere Person-X é o CEO de uma empresa de software iniciante.

• Há um arquiteto principal presente na empresa, esse arquiteto principal faz todo o trabalho na empresa, que envolve, como banco de dados, interface do usuário etc.

• Agora, o CEO contrata um novo desenvolvedor.

• É o arquiteto que diz à responsabilidade do recém-contratado, com base nas habilidades do novo funcionário, que ele trabalhará no banco de dados ou na interface do usuário, etc.

Termos mais simples (exemplo 2)

• É como o acesso da atividade do Android ao recurso do aplicativo.

• É semelhante a quando você visita um hotel, quer café da manhã, almoço e jantar nos horários adequados, certo?

• Há muitas outras coisas que você gosta durante a estadia. Como você consegue essas coisas?

• Você pede à pessoa do serviço de quarto que traga essas coisas para você.

• Aqui a pessoa do serviço de quarto é o contexto, considerando que você é a única atividade e o hotel como seu aplicativo; finalmente, o café da manhã, o almoço e o jantar devem ser os recursos.

Coisas que envolvem contexto são:

1. Carregando um recurso.
2. Iniciando uma nova atividade.
3. Criando vistas.
4. obtendo serviço do sistema.

Contexto é a classe base para Atividade , Serviço , Aplicativo , etc.

Outra maneira de descrever isso: considere o contexto como remoto de uma TV e canal na televisão são recursos, serviços, usando intenções etc. - - - Aqui, o controle remoto atua como um acesso para obter acesso a todos os diferentes recursos em primeiro plano.

• Portanto, o Remote tem acesso a canais como recursos, serviços, uso de intenções etc.

• Da mesma forma ... Quem tem acesso remoto, naturalmente, tem acesso a tudo, como recursos, serviços, uso de intenções etc.

Diferentes métodos pelos quais você pode obter contexto

• getApplicationContext()
• getContext()
• getBaseContext()
• ou this(quando na classe de atividade)

Exemplo:

TextView tv = new TextView(this);

A palavra-chave thisrefere-se ao contexto da atividade atual.

Fonte

O tópico do Contexto no Android parece confuso para muitos. As pessoas sabem que o Contexto é necessário com frequência para fazer coisas básicas no Android. Às vezes, as pessoas entram em pânico porque tentam executar alguma operação que requer o contexto e não sabem como obter o contexto certo. Vou tentar desmistificar a ideia de contexto no Android. Um tratamento completo do problema está além do escopo deste post, mas tentarei fornecer uma visão geral para que você tenha uma noção do que é o contexto e como usá-lo. Para entender o que é contexto, vamos dar uma olhada no código fonte:

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

O que exatamente é o contexto?

Bem, a própria documentação fornece uma explicação bastante direta: A classe Context é uma "Interface para informações globais sobre um ambiente de aplicativos".

A própria classe Context é declarada como classe abstrata, cuja implementação é fornecida pelo sistema operacional Android. A documentação fornece ainda que o Contexto “… permite acesso a recursos e classes específicos de aplicativos, bem como chamadas para operações no nível de aplicativos, como atividades de lançamento, transmissão e recebimento de intenções, etc.".

Você pode entender muito bem agora, por que o nome é Contexto. É porque é só isso. O Contexto fornece o link ou gancho, se você desejar, para uma Atividade, Serviço ou qualquer outro componente, vinculando-o ao sistema, permitindo acesso ao ambiente global de aplicativos. Em outras palavras: o contexto fornece a resposta para a pergunta dos componentes: "onde diabos estou em relação ao aplicativo em geral e como faço para acessar / me comunicar com o restante do aplicativo?" Se tudo isso parecer um pouco confuso, uma rápida olhada nos métodos expostos pela classe Context fornece algumas pistas adicionais sobre sua verdadeira natureza.

Aqui está uma amostra aleatória desses métodos:

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

O que todos esses métodos têm em comum? Todos permitem que quem tem acesso ao Contexto possa acessar recursos de todo o aplicativo.

O contexto, em outras palavras, conecta o componente que tem uma referência ao restante do ambiente do aplicativo. Os ativos (pasta 'pensar / ativos' no seu projeto), por exemplo, estão disponíveis no aplicativo, desde que uma Atividade, Serviço ou qualquer outra coisa que saiba acessar esses recursos. O mesmo vale paragetResources() que permite fazer coisas como o getResources().getColor()que o conectará ao colors.xmlrecurso (esqueça que o aapt permite o acesso a recursos via código java, isso é uma questão separada).

O resultado é que Contexté o que permite o acesso aos recursos do sistema e é o que prende os componentes ao "aplicativo maior". Vejamos as subclasses das Contextclasses que fornecem a implementação da Contextclasse abstrata . A classe mais óbvia é a Activityclasse. ActivityHerda from ContextThemeWrapper, o que herda de ContextWrapper, o que herda de Contextsi. Essas classes são úteis para entender as coisas em um nível mais profundo, mas por enquanto é suficiente conhecer essaContextThemeWrapper e ContextWrappersão muito bonito o que soam como. eles implementar os elementos abstratos do Contextprópria classe "agrupando" um contexto (o contexto real) e delegando essas funções a esse contexto.Um exemplo é útil - noContextWrapperclasse, o método abstrato getAssetsda Contextclasse é implementado da seguinte maneira:

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

mBaseé simplesmente um campo definido pelo construtor para um contexto específico. Portanto, um contexto é ContextWrapperagrupado e delega sua implementação do método getAssets para esse contexto. Vamos voltar a examinar a Activityclasse que finalmente herda Contextpara ver como tudo isso funciona.

Você provavelmente sabe o que é uma Atividade, mas, para revisar, é basicamente 'uma única coisa que o usuário pode fazer. Ele cuida de fornecer uma janela na qual colocar a interface do usuário com a qual o usuário interage '. Desenvolvedores familiarizados com outras APIs e até mesmo não desenvolvedores podem pensar nisso de maneira vernacular como uma "tela". Isso é tecnicamente impreciso, mas não importa para nossos propósitos. Então, como ActivityeContext interagem eo que exatamente está acontecendo em seu relacionamento herança?

Novamente, é útil olhar para exemplos específicos. Todos nós sabemos como iniciar atividades. Desde que você tenha "o contexto" a partir do qual você está iniciando a Atividade, basta ligar startActivity(intent), onde o Intent descreve o contexto no qual você está iniciando uma Atividade e a Atividade que você deseja iniciar. Este é o familiar startActivity(this, SomeOtherActivity.class).

E o que é this? thisé sua atividade porque a Activityclasse herda Context. A informação completa é a seguinte: quando você liga startActivity, a Activityclasse executa algo como isto:

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

Portanto, utiliza o execStartActivityda Instrumentationclasse (na verdade, de uma classe interna Instrumentationchamada ActivityResult).

Neste ponto, estamos começando a dar uma olhada nos internos do sistema.

É aqui que o sistema operacional lida com tudo. Então, como a Instrumentação inicia a Atividade exatamente? Bem, o parâmetro thisno execStartActivitymétodo acima é sua Atividade, ou seja, o Contexto, e execStartActivityfaz uso desse contexto.

Uma visão geral de 30.000 é a seguinte: a classe Instrumentação mantém o controle de uma lista de atividades que está monitorando para fazer seu trabalho. Essa lista é usada para coordenar todas as atividades e garantir que tudo corra bem no gerenciamento do fluxo de atividades.

Existem algumas operações nas quais ainda não examinei completamente quais problemas de encadeamento e processo de coordenadas. Por fim, o ActivityResultusa uma operação nativa - ActivityManagerNative.getDefault().startActivity()que usa o Contextque você passou quando ligou startActivity. O contexto que você passou é usado para ajudar na "resolução de intenção", se necessário. Resolução de intenção é o processo pelo qual o sistema pode determinar o destino da intenção, se não for fornecido. (Confira o guia aqui para mais detalhes).

E para que o Android faça isso, ele precisa acessar as informações fornecidas por Context. Especificamente, o sistema precisa acessar um ContentResolverpara que ele possa "determinar o tipo MIME dos dados da intenção". Todo esse processo sobre como startActivityfazer uso do contexto foi um pouco complicado e eu não entendo completamente os elementos internos. Meu ponto principal foi apenas para ilustrar como os recursos de todo o aplicativo precisam ser acessados ​​para executar muitas das operações essenciais a um aplicativo. ContextÉ o que fornece acesso a esses recursos. Um exemplo mais simples pode ser o Views. Todos sabemos o que você cria. Visualização personalizada estendendo RelativeLayout ou alguma outra Viewclasse, você deve fornecer um construtor que faça umaContextcomo argumento. Quando você instancia sua Visualização personalizada, passa no contexto. Por quê? Porque o View precisa ter acesso a temas, recursos e outros detalhes de configuração do View. A configuração de visualização é realmente um ótimo exemplo. Cada contexto tem vários parâmetros (campos nas Contextimplementações) que são definidos pelo próprio sistema operacional para itens como a dimensão ou densidade da exibição. É fácil ver por que essas informações são importantes para a configuração de Views etc.

Uma palavra final: por algum motivo, pessoas novas no Android (e até pessoas não tão novas) parecem esquecer completamente a programação orientada a objetos quando se trata do Android. Por alguma razão, as pessoas tentam alterar seu desenvolvimento Android para paradigmas pré-concebidos ou comportamentos aprendidos.

O Android tem seu próprio paradigma e um certo padrão que é realmente bastante consistente se deixar de lado suas noções pré-concebidas e simplesmente ler a documentação e o guia do desenvolvedor. Meu argumento real, no entanto, enquanto “obter o contexto certo” pode às vezes ser complicado, as pessoas entram em pânico injustificadamente porque se deparam com uma situação em que precisam do contexto e pensam que não o têm. Mais uma vez, Java é uma linguagem orientada a objetos com um design de herança.

Você apenas "possui" o contexto dentro de sua Atividade porque sua própria atividade herda de Contexto. Não há mágica nisso (exceto todas as coisas que o sistema operacional faz por si só para definir vários parâmetros e "configurar" corretamente seu contexto). Portanto, deixando de lado os problemas de memória / desempenho (por exemplo, mantendo referências ao contexto quando você não precisa ou fazendo isso de uma maneira que tenha consequências negativas na memória, etc.), o contexto é um objeto como qualquer outro e pode ser contornado assim como qualquer POJO (Plain Old Java Object). Às vezes, você pode precisar fazer coisas inteligentes para recuperar esse contexto, mas qualquer classe Java comum que se estenda de nada além do próprio Objeto pode ser escrita de uma maneira que tenha acesso ao contexto; simplesmente exponha um método público que utiliza um contexto e, em seguida, use-o nessa classe, conforme necessário.

Um contexto é um identificador para o sistema; fornece serviços como resolver recursos, obter acesso a bancos de dados e preferências e assim por diante. Um aplicativo Android tem atividades. O contexto é como um identificador para o ambiente em que seu aplicativo está sendo executado. O objeto de atividade herda o objeto de Contexto.

Para obter mais informações, consulte Introdução ao desenvolvimento do Android com o Android Studio - Tutorial .

Contexté uma "interface" para as informações globais sobre um ambiente de aplicativo. Na prática, Contexté na verdade uma classe abstrata , cuja implementação é fornecida pelo sistema Android.

Permite o acesso a recursos e classes específicos do aplicativo, bem como chamadas para operações no nível do aplicativo, como atividades de lançamento, transmissão e recebimento de intenções, etc.

Na figura a seguir, você pode ver uma hierarquia de classes, onde Contextestá a classe raiz dessa hierarquia. Em particular, vale ressaltar que Activityé um descendente de Context.

O que Contextexatamente?

De acordo com a documentação de referência do Android, é uma entidade que representa vários dados do ambiente. Ele fornece acesso a arquivos locais, bancos de dados, carregadores de classes associados ao ambiente, serviços (incluindo serviços em nível de sistema) e muito mais. Ao longo deste livro, e na sua codificação diária com o Android, você verá o Contexto sendo transmitido com frequência.

No livro " Android na Prática ", p. 60

Várias APIs do Android exigem um Contextparâmetro as

Se você examinar as várias APIs do Android, perceberá que muitas delas usam um android.content.Contextobjeto como parâmetro. Você também verá que uma Atividade ou um Serviço é geralmente usado como um Context. Isso funciona porque essas duas classes se estendem de Context.

Exemplo simples de entender contextno android:

Todo chefe tem um assistente para cuidar, para executar todas as tarefas menos importantes e demoradas. Se for necessário um arquivo ou uma xícara de café, um assistente está fugindo. Alguns chefes mal sabem o que está acontecendo no escritório, então perguntam aos assistentes sobre isso também. Eles mesmos fazem algum trabalho, mas para a maioria das outras coisas precisam da ajuda de seus assistentes.

Neste cenário,

Chefe - é a aplicação Android

Assistente - é contexto

Arquivos / xícara de café - são recursos

Geralmente chamamos de contexto quando precisamos obter informações sobre diferentes partes de nosso aplicativo, como Atividades, Aplicativos etc.

Algumas operações (coisas em que o assistente é necessário) em que o contexto está envolvido:

• Carregando recursos comuns
• Criando visualizações dinâmicas
• Exibindo mensagens do Toast
• Iniciando atividades etc.

Diferentes maneiras de obter contexto:

getContext()

getBaseContext()

getApplicationContext()

this

Um contexto Android é uma interface (no sentido geral, não no sentido Java; em Java, Contexté na verdade uma classe abstrata!) Que permite o acesso a recursos específicos de aplicativos e classe e informações sobre o ambiente de aplicativos.

Se o seu aplicativo para Android fosse um aplicativo da Web, seu contexto seria algo semelhante a ServletContext(não estou fazendo uma comparação exata aqui).

Suas atividades e serviços também se estendem Context; portanto, eles herdam todos esses métodos para acessar as informações do ambiente em que o aplicativo está sendo executado.

• Context representa um identificador para obter dados do ambiente.
• Context A própria classe é declarada como abstrata, cuja implementação é fornecida pelo sistema operacional Android.
• Context é como o controle remoto de uma TV e os canais da televisão são recursos, serviços etc.

O que você pode fazer com isso?

• Carregando recurso.
• Iniciando uma nova atividade.
• Criando vistas.
• Obtendo serviço do sistema.

Maneiras de obter contexto:

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

Apenas publicando para iniciantes;

Então, primeiro entenda o contexto da palavra:

Em inglês-lib. Isso significa:

"As circunstâncias que formam o cenário para um evento, declaração ou idéia e em termos dos quais ele pode ser totalmente compreendido e avaliado".

"As partes de algo escrito ou falado que imediatamente precedem e seguem uma palavra ou passagem e esclarecem seu significado."

Agora adote o mesmo entendimento para o mundo da programação:

contexto do estado atual do aplicativo / objeto. Ele permite que objetos recém-criados entendam o que está acontecendo. Normalmente, você o chama para obter informações sobre outra parte do seu programa (atividade, pacote / aplicativo)

Você pode obter o contexto chamando getApplicationContext(), getContext(), getBaseContext()ou this(quando na classe de atividade).

Para obter o contexto em qualquer lugar no aplicativo, use o seguinte código:

Crie uma nova classe AppContextdentro do seu aplicativo 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;
    }
}

Agora, sempre que desejar o contexto do aplicativo na classe sem atividade, chame esse método e você terá o contexto do aplicativo.

Espero que esta ajuda;)

Pense nisso como a VM que isolou o processo em que o aplicativo ou serviço está sendo executado. O ambiente isolado acessa várias informações subjacentes do sistema e alguns recursos permitidos. Você precisa desse contexto para acessar esses serviços.

Contexto é uma referência ao objeto atual como este. O contexto também permite acesso a informações sobre o ambiente do aplicativo.

A classe android.content.Contextfornece a conexão com o sistema Android e os recursos do projeto. É a interface para informações globais sobre o ambiente do aplicativo.

O contexto também fornece acesso aos Serviços Android, por exemplo, o Serviço de Localização.

Atividades e serviços estendem a Contextaula.

O contexto é Instâncias da classe android.content.Context fornece a conexão com o sistema Android que executa o aplicativo. Por exemplo, você pode verificar o tamanho da tela do dispositivo atual via Contexto.

Também fornece acesso aos recursos do projeto. É a interface para informações globais sobre o ambiente do aplicativo.

A classe Context também fornece acesso aos serviços Android, por exemplo, o gerenciador de alarmes para acionar eventos com base no tempo.

Atividades e serviços estendem a classe Context. Portanto, eles podem ser usados ​​diretamente para acessar o contexto.

O contexto é uma interface para informações globais sobre um ambiente de aplicativo. É uma classe abstrata cuja implementação é fornecida pelo Androidsistema.

Context permite acesso a recursos e classes específicos de aplicativos, bem como solicita operações no nível de aplicativos, como launching activities, broadcasting and receiving intents, etc.

Aqui está o exemplo

 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. */

Para mais detalhes, visite http://developer.android.com/reference/android/content/Context.html

O contexto é basicamente para acessar recursos e obter os detalhes do ambiente do aplicativo (para o contexto do aplicativo) ou atividade (para o contexto da atividade) ou qualquer outro ...

Para evitar vazamento de memória, você deve usar o contexto do aplicativo para todos os componentes que precisam de um objeto de contexto ... para mais, clique aqui

O contexto é o contexto do estado atual do aplicativo / objeto. É uma entidade que representa vários dados do ambiente. O contexto ajuda a atividade atual a interagir com o ambiente Android externo, como arquivos locais, bancos de dados, carregadores de classes associados ao ambiente, serviços que incluem serviços no nível do sistema e muito mais.

Um contexto é um identificador para o sistema. Ele fornece serviços como resolução de recursos, obtenção de acesso a bancos de dados e preferências e assim por diante. Um aplicativo Android tem atividades. É como um identificador para o ambiente em que seu aplicativo está sendo executado. O objeto de atividade herda o objeto de Contexto.

Diferentes métodos de chamada pelos quais você pode obter o contexto 1. getApplicationContext (), 2. getContext (), 3. getBaseContext () 4. ou este (quando na classe de atividade).

Contexto significa que o Android sabe em qual atividade devo participar ou participar.

1 - Toast.makeText(context, "Enter All Details", Toast.LENGTH_SHORT).show(); é usado nisso. Context context = ActivityName.this;

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

nesse contexto, significa de qual atividade você deseja ir para outra atividade. context ou ActivityName.this é mais rápido, getContext e getApplicatinContext.

A Contexté o que muitos de nós chamaríamos de Aplicativo . É fabricado pelo sistema Android e pode fazer apenas o que um aplicativo é capaz. No Tomcat, um contexto também é o que eu chamaria de aplicativo.

Há um contexto que contém muitas atividades, cada atividade pode ter muitas visualizações.

Obviamente, alguns dirão que não se encaixa por causa disso ou daquilo e provavelmente estão certos, mas dizer que um Contexto é seu aplicativo atual ajudará você a entender o que está colocando nos parâmetros do método.

Chefe Assistente Analogia

Vamos ter uma pequena analogia antes de mergulhar profundamente no tecnicismo do contexto

Todo chefe tem um assistente ou alguém (garoto de recados) que faz coisas menos importantes e consome mais tempo para ele. Por exemplo, se eles precisam de um arquivo ou café, um assistente estará em execução. O chefe não saberá o que está acontecendo em segundo plano, mas o arquivo ou a tarefa será entregue

So Here
Boss -
Assistente de aplicativo para Android -
Arquivo de contexto ou xícara de café - Recurso

O que o site oficial do desenvolvedor Android diz sobre o Contexto

O contexto é seu ponto de acesso para recursos relacionados ao aplicativo

Vamos ver alguns desses recursos ou tarefas

• Iniciando uma atividade.

• Obtendo o caminho absoluto para o diretório de cache específico do aplicativo no sistema de arquivos.

• Determinando se a permissão fornecida é permitida para um determinado processo e ID do usuário em execução no sistema.

• Verificando se você recebeu uma permissão específica.

E assim por diante.
Portanto, se um aplicativo Android deseja iniciar uma atividade, ele vai direto para Context(Ponto de Acesso), e a Contextclasse devolve os recursos (intenção neste caso).

Como qualquer outra classe, Contexttambém possui campos e métodos.
Você pode explorar mais sobre a Contextdocumentação oficial, que abrange praticamente tudo, métodos disponíveis, campos e até mesmo como usar campos com métodos.

Instâncias da classe android.content.Context fornecem a conexão com o sistema Android que executa o aplicativo. Por exemplo, você pode verificar o tamanho da tela do dispositivo atual via Contexto.

Também fornece acesso aos recursos do projeto. É a interface para informações globais sobre o ambiente do aplicativo.

A classe Context também fornece acesso aos serviços Android, por exemplo, o gerenciador de alarmes para acionar eventos com base no tempo.

Atividades e serviços estendem a classe Context. Portanto, eles podem ser usados ​​diretamente para acessar o contexto.

Se você deseja conectar o Context a outras classes familiares no Android, lembre-se desta estrutura:

Contexto <ContextWrapper <Aplicativo

Contexto <ContextWrapper <ContextThemeWrapper <Atividade

Contexto <ContextWrapper <ContextThemeWrapper <Atividade <ListActivity

Context <ContextWrapper <Serviço

Contexto <ContextWrapper <Serviço <IntentService

Portanto, todas essas classes são contextos à sua maneira. Você pode converter Service e ListActivity em Contexto, se desejar. Mas se você olhar de perto, algumas das classes também herdam o tema. Em atividade ou fragmento, você gostaria que o tema fosse aplicado às suas visualizações, mas não se importa com isso Classe de serviço , por exemplo.

Eu explico a diferença de contexto aqui .

Simplificando, os Androids Contextsão uma bagunça que você não vai adorar até parar de se preocupar.

Os Android Contextsão:

• Objetos de Deus.

• A coisa que você deseja distribuir por todo o seu aplicativo quando estiver desenvolvendo para Android, mas evitará fazê-lo quando você se aproximar um pouco mais da programação, teste e do próprio Android.

  • Dependência pouco clara.

  • Fonte comum de vazamentos de memória.

  • PITA para teste.

• Contexto real usado pelo sistema Android para enviar permissões, recursos, preferências, serviços, transmissões, estilos, mostrando diálogos e inflando o layout. E você precisa de Contextinstâncias diferentes para algumas coisas separadas (obviamente, não é possível mostrar uma caixa de diálogo a partir de um aplicativo ou contexto de serviço; layouts inflados a partir de contextos de aplicativo e atividade podem ser diferentes).

O Contexto é a API específica do Android para a Sandbox de cada aplicativo que fornece acesso a dados privados do aplicativo, como recursos, banco de dados, diretórios de arquivos privados, preferências, configurações ...

A maioria dos dados privados é a mesma para todas as atividades / serviços / ouvintes de transmissão de um aplicativo.

Como Aplicativo, Atividade, Serviço implementam a interface Context, eles podem ser usados ​​onde uma chamada da API precisa de um parâmetro Context

Contextsignifica componente (ou aplicativo) em vários períodos. Se eu comer tanta comida entre 13 e 14 horas, meu contexto será usado para acessar todos os métodos (ou recursos) que eu uso durante esse período. O conteúdo é um componente (aplicativo) para um horário específico. Contextdos componentes do aplicativo continua mudando com base no ciclo de vida subjacente dos componentes ou aplicativo. Por exemplo, dentro do onCreate () de um Activity,

getBaseContext()- dá ao contextdo Activityque está definido (criado) pelo construtor de atividade. getApplicationContext()- fornece a Contextconfiguração (criada) durante a criação do aplicativo.

Nota: <application>contém todos os componentes do Android.

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

    <service>  .. </service>

    <receiver> .. </receiver>

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

Isso significa que, quando você chama getApplicationContext()de dentro de qualquer componente, está chamando o contexto comum de todo o aplicativo.

Context continua sendo modificado pelo sistema com base no ciclo de vida dos componentes.

Pense no contexto como uma caixa com diferentes recursos: sequência, cores e fontes. Se você precisar de um recurso, vá para esta caixa. Quando você gira a tela, essa caixa muda porque a orientação muda para paisagem.

 Contextsignifica atual. Contextuse para fazer a operação na tela atual. ex.
  1. getApplicationContext ()
  2. getContext ()

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

Ótimas explicações! Para complementar tudo o que foi exposto, achei este um dos MindOrks muito útil e até mostra alguns casos de uso básicos para você pensar:

Entendendo o contexto no aplicativo Android

Em Java, dizemos que essa palavra - chave se refere ao estado do objeto atual do aplicativo.
Da mesma forma, em uma alternativa que temos Contextno Android Development.

Isso pode ser definido explícita ou implicitamente,

Context con = this;

getApplicationContext();

getBaseContext();

getContext();

Este atributo declara a qual atividade esse layout está associado por padrão .