Tutorial de primeiros passos do Android | Conceitos básicos do fragmento

O que são fragmentos?

Fragmento, traduzido literalmente como "fragmento", "fragmento". Fragment representa o comportamento ou parte da interface em FragmentActivity. Você pode combinar vários fragmentos em uma atividade para criar uma interface com vários painéis e reutilizar um fragmento em várias atividades. Os fragmentos podem ser considerados componentes modulares de uma atividade que possuem seu próprio ciclo de vida, recebem seus próprios eventos de entrada e podem ser adicionados ou removidos enquanto a atividade está em execução (é um pouco como uma "atividade infantil").

Os fragmentos devem sempre ser hospedados em uma atividade e seu ciclo de vida é diretamente afetado pelo ciclo de vida da atividade hospedeira. Por exemplo, quando a Atividade é pausada, todos os fragmentos da Atividade também são pausados; quando a Atividade é destruída, todos os fragmentos também são destruídos.

No entanto, enquanto a Atividade está em execução (no estado de ciclo de vida retomado), cada fragmento pode ser manipulado de forma independente, como adicionar ou remover fragmentos. Quando tal transação de fragmento é executada, ela também é adicionada à backstack gerenciada pela Activity – cada entrada de backstack na Activity é um registro de que ocorreu uma transação de fragmento. Com a backstack, o usuário pode desfazer a transação do fragmento (voltar) pressionando o botão Voltar.

Vantagens dos fragmentos

• O carregamento de fragmentos é flexível e fácil de substituir. Personalize sua UI, crie uma UI adequada em telas de tamanhos diferentes e melhore a experiência do usuário.
• Reutilizável, o layout da página pode usar vários fragmentos, e diferentes controles e conteúdos podem ser distribuídos em diferentes fragmentos.
• Usando Fragment, você pode usar menos Activity. Uma atividade pode governar vários fragmentos.

Ciclo de vida do fragmento

O código da classe Fragment é muito semelhante ao da Activity. Ele contém métodos de retorno de chamada semelhantes a Activity, como onCreate(), onStart(), onPause() e onStop(). Na verdade, se você estiver convertendo um aplicativo Android existente para usar fragmentos, talvez seja necessário apenas mover o código do método de retorno de chamada da Activity para o método de retorno de chamada correspondente do fragmento.

Normalmente, pelo menos os seguintes métodos de ciclo de vida devem ser implementados :

• onCreate() O sistema chama esse método quando o fragmento é criado. Se quiser preservar os componentes básicos de um fragmento depois que o fragmento tiver sido pausado ou interrompido e depois retomado, você deverá inicializá-lo em sua implementação.
• onCreateView() O sistema chama esse método quando o fragmento desenha sua interface pela primeira vez. Para desenhar a interface de um fragmento, a View retornada desse método deve ser a visualização raiz do layout do fragmento. Pode retornar nulo se o fragmento não fornecer uma interface.
• onPause() O sistema chama esse método como o primeiro sinal de que o usuário sai do fragmento (mas nem sempre significa que o fragmento será destruído). Em geral, quaisquer alterações que persistam após o término da sessão do usuário atual (já que o usuário não pode retornar) devem ser reconhecidas neste método.

Você também pode estender várias subclasses além da classe base Fragment :

• DialogFragment exibe uma caixa de diálogo flutuante. Usar esta classe para criar um diálogo é uma alternativa eficaz ao uso dos métodos auxiliares de diálogo na classe Activity, porque você pode colocar o diálogo do fragmento na pilha de fragmentos gerenciada pela Activity, permitindo que o usuário retorne a um fragmento limpo.
• ListFragment exibe uma coleção de itens gerenciados por um adaptador como SimpleCursorAdapter, semelhante a ListActivity. Esta classe fornece vários métodos para gerenciar a exibição de lista, como o retorno de chamada onListItemClick() para lidar com eventos de clique. (Observe que a maneira preferida de exibir uma lista é usar um RecyclerView, não um ListView. Nesse caso, crie um fragmento que contenha o RecyclerView no layout da lista. Consulte Criando uma lista com um RecyclerView para saber como)
• PreferenceFragmentCompat exibe uma hierarquia de objetos Preference em formato de lista. Esta classe é utilizada para criar telas de configurações da aplicação.

Crie um fragmento, use uma interface personalizada

Os fragmentos são normalmente usados ​​como parte da interface de uma atividade e incorporarão seu próprio layout na atividade.

Para fornecer layout para um fragmento, você deve implementar onCreateView()o método de retorno de chamada que o sistema Android chama quando o fragmento precisa desenhar seu layout. A View retornada por uma implementação deste método deve ser a visão raiz do layout do fragmento.

Para retornar um layout de onCreateView(), o layout pode ser estendido por um recurso de layout definido em XML. Para ajudá-lo a fazer isso, onCreateView() fornece um objeto LayoutInflater.

Por exemplo, a seguinte subclasse Fragment example_fragment.xmlcarrega o layout de um arquivo:

public static class ExampleFragment extends Fragment {
    
    
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
    
    
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.example_fragment, container, false);
    }
}

O parâmetro container passado onCreateView()é o ViewGroup pai (do layout da Activity) no qual o layout do fragmento será inserido. O parâmetro saveInstanceState é o Bundle que fornece dados relacionados à instância anterior do fragmento quando o fragmento é restaurado (a seção que trata do ciclo de vida do fragmento explica detalhadamente o estado da restauração).

O método inflate() leva três parâmetros :

• O ID do recurso do layout que você deseja estender.
• O ViewGroup que será o pai do layout estendido. A passagem de um contêiner é importante para o sistema aplicar parâmetros de layout à visualização raiz (especificada pela visualização pai à qual pertence) do layout estendido.
• Um booleano que indica se um layout expandido deve ser anexado ao ViewGroup (segundo parâmetro) durante a expansão. (Nesse caso, o valor é falso porque o sistema já inseriu o layout expandido no contêiner e passar um valor verdadeiro teria criado um grupo de visualização redundante no layout final.)

Em seguida, você precisa adicionar este fragmento à sua atividade.

Adicionar fragmento à atividade

Normalmente, os fragmentos contribuem com uma parte da interface para a atividade hospedeira, incorporada na atividade como parte da hierarquia de visualização geral da atividade. Existem duas maneiras de adicionar fragmentos ao layout da atividade (os trechos de código abaixo não estão completos).

maneira estática

Declare fragmentos no arquivo de layout da atividade. Nesse caso, você pode especificar propriedades de layout para um fragmento como se fosse uma visualização. Por exemplo, aqui está o arquivo de layout de uma Activity com dois fragmentos:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <fragment android:name="com.example.news.ArticleListFragment"
            android:id="@+id/list"
            android:layout_weight="1"
            android:layout_width="0dp"
            android:layout_height="match_parent" />
    <fragment android:name="com.example.news.ArticleReaderFragment"
            android:id="@+id/viewer"
            android:layout_weight="2"
            android:layout_width="0dp"
            android:layout_height="match_parent" />
</LinearLayout>

<fragment>O atributo in android:nameespecifica a classe Fragment a ser instanciada no layout.

Quando esse layout de atividade é criado, o sistema instancia cada fragmento especificado no layout e chama onCreateView()o método de cada fragmento para recuperar o layout de cada fragmento. A View retornada pelo fragmento é inserida diretamente no lugar do <fragment>elemento.

Nota: Cada fragmento requer um identificador exclusivo que o sistema pode usar para restaurar o fragmento quando a atividade for reiniciada (ou para capturar o fragmento para executar determinadas transações, como removê-lo). Há duas maneiras de fornecer um ID para um fragmento: Forneça um ID exclusivo para o atributo android:id. Forneça uma string exclusiva para o atributo android:tag.

Código Java carrega fragmento

Como alternativa, adicione programaticamente o fragmento a um ViewGroup existente. Você pode adicionar fragmentos ao layout da atividade a qualquer momento enquanto a atividade estiver em execução. Você apenas especifica em qual ViewGroup deseja colocar o fragmento.

Para realizar transações de fragmentos (como adicionar, remover ou substituir fragmentos) em uma Activity, você deve usar as APIs em FragmentTransaction. Uma instância FragmentTransaction pode ser obtida de FragmentActivity da seguinte maneira:

FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

Você pode então add()adicionar um fragmento usando o método, especificando qual fragmento adicionar e em qual visualização inseri-lo. Por exemplo:

ExampleFragment fragment = new ExampleFragment();
fragmentTransaction.add(R.id.fragment_container, fragment);
fragmentTransaction.commit();

O primeiro parâmetro passado add()é o ViewGroup onde o fragmento deve ser colocado, especificado pelo ID do recurso, e o segundo parâmetro é o fragmento a ser adicionado. Depois que as alterações forem feitas por meio de FragmentTransaction, deverá ser chamado commit()para que as alterações tenham efeito.

Gerenciar fragmentos

Para gerenciar os fragmentos na Activity, você precisa usar FragmentManager. Para obtê-lo, chame-o na Activity getSupportFragmentManager().

As operações que podem ser executadas usando FragmentManager incluem :

• findFragmentById()Obtenha os fragmentos presentes na Activity via (para fragmentos que fornecem uma interface no layout da Activity) ou findFragmentByTag() (para fragmentos que fornecem ou não uma interface).
• popBackStack()Retire o fragmento da pilha traseira ( simulando um comando de retorno emitido pelo usuário).
• addOnBackStackChangedListener()Registre um ouvinte para alterações na pilha de retorno via .

FragmentManager também pode ser usado para abrir um FragmentTransaction, por meio do qual realizar determinadas transações, como adicionar e remover fragmentos.

Executar transação de fragmento

Uma das melhores vantagens do uso de fragmentos em uma atividade é que você pode adicionar, remover, substituir e fazer outras coisas com o fragmento em resposta à interação do usuário. Cada conjunto de alterações confirmadas em uma atividade é chamado de transação, e APIs em FragmentTransaction podem ser usadas para realizar uma transação. Cada transação também pode ser salva em uma backstack gerenciada pela Activity, permitindo ao usuário reverter alterações de fragmentos (semelhante à reversão da Activity).

Uma instância FragmentTransaction pode ser obtida do FragmentManager da seguinte forma:

FragmentManager fragmentManager = getSupportFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

Cada transação é um conjunto de alterações que você deseja realizar simultaneamente. Você pode usar métodos como add(), remove() e replace() para definir todas as alterações que deseja realizar em uma determinada transação. Então, para aplicar a transação à Activity, você deve chamar commit().

No entanto, antes de chamar commit(), você pode chamar addToBackStack() para adicionar a transação à backstack da transação do fragmento. Essa backstack é gerenciada pela Activity e permite que o usuário retorne ao estado anterior do fragmento pressionando o botão Voltar.

Por exemplo, o exemplo a seguir mostra como substituir um fragmento por outro e preservar o estado anterior na backstack:

// Create new fragment and transaction
Fragment newFragment = new ExampleFragment();
FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();

// Replace whatever is in the fragment_container view with this fragment,
// and add the transaction to the back stack
transaction.replace(R.id.fragment_container, newFragment);
transaction.addToBackStack(null);

// Commit the transaction
transaction.commit();

Nesse caso, newFragment substitui qualquer fragmento (se houver) atualmente no contêiner de layout identificado pelo ID R.id.fragment_container. Ao chamar addToBackStack(), uma transação de substituição pode ser salva na pilha de retorno para que o usuário possa desfazer a transação e reverter para o fragmento anterior pressionando o botão Voltar.

FragmentActivity então recupera automaticamente o fragmento da backstack via onBackPressed().

Se você adicionar várias alterações a uma transação (como outro add() ou remove()) e chamar addToBackStack(), todas as alterações aplicadas antes de chamar commit() serão adicionadas à backstack como uma única transação, e o o botão Voltar irá desfazer todos eles.

A ordem em que você adiciona alterações a FragmentTransaction não importa:

commit() deve ser chamado por último. Se você estiver adicionando vários fragmentos ao mesmo contêiner, a ordem em que você adiciona os fragmentos determinará a ordem em que eles aparecem na hierarquia de visualização. Se addToBackStack() não for chamado durante a transação que exclui o fragmento, o fragmento será destruído quando a transação for confirmada e o usuário não poderá reverter para o fragmento. No entanto, se addToBackStack() for chamado enquanto o fragmento estiver sendo excluído, o sistema interromperá o fragmento e o retomará quando o usuário voltar.

Chamar commit() não executa a transação imediatamente, mas em vez disso agenda a transação para ser executada no thread quando o thread de UI da Activity (o thread "principal") estiver disponível para fazer isso. No entanto, se necessário, executePendingTransactions() também pode ser chamado a partir do thread de UI para executar transações confirmadas commit() imediatamente. Normalmente você não precisa fazer isso, a menos que trabalhos em outros threads dependam da transação.

Nota: Você só pode usar commit() para confirmar uma transação antes que a Activity salve seu estado (quando o usuário sai da Activity). Uma exceção será lançada se for feita uma tentativa de commit após esse ponto. Isso ocorre porque o estado enviado pode ser perdido se a Atividade precisar ser retomada. Para casos em que a falta de commits não importa, use commitAllowingStateLoss().

mudanças no ciclo de vida

Quando o fragmento é criado

Ele passa pelos seguintes estados

onAttach()
onCreate()
onCreateView()
onActivityCreated()

Quando o Fragmento está visível para o usuário

Ele passa pelos seguintes estados

onStart()
onResume()

Quando o Fragment entra no "modo de fundo"

Ele passa pelos seguintes estados

onPause()
onStop()

O fragmento é destruído (ou a atividade que o contém é destruída)

Ele passa pelos seguintes estados

onPause()
onStop()
onDestroyView()
onDestroy()
onDetach()

Diferentes ciclos de vida entre Fragmento e Atividade

A maior parte do estado do Fragment é semelhante ao Activity, mas o Fragment tem alguns novos estados.

O fragmento é diferente do ciclo de vida da atividade

• onAttached()—— Chamado quando o fragmento é adicionado à atividade (neste método pode-se obter a atividade onde ele está localizado).
• onCreateView()—— Quando a atividade deseja obter o layout do fragmento, este método é chamado, e o fragmento cria seu próprio layout (interface) nele.
• onActivityCreated()—— Este método é chamado após o retorno do método onCreated() da atividade
• onDestroyView()- Este método é chamado quando a visualização do fragmento é removida.
• onDetach()—— Este método é chamado quando o fragmento e a atividade são separados.

Depois que a atividade entra no estado retomado (ou seja, no estado de execução), você pode adicionar e remover fragmentos livremente. Portanto, somente quando a atividade está no estado retomado, o ciclo de vida do fragmento pode ser executado de forma independente, e outras vezes depende da mudança do ciclo de vida da atividade.

Lidar com o ciclo de vida do fragmento

Gerenciar o ciclo de vida do fragmento é muito semelhante ao gerenciar o ciclo de vida da atividade. Assim como as Atividades, os Fragmentos existem em três estados:

• Restaurado: o fragmento fica visível na atividade em execução.
• Pausada: outra atividade está em primeiro plano e em foco, mas a atividade na qual esse fragmento reside ainda está visível (a atividade em primeiro plano é parcialmente transparente ou não cobre a tela inteira).
• Parado: o fragmento não está visível. A atividade do host foi interrompida ou o fragmento foi removido da atividade, mas adicionado à backstack. Um fragmento interrompido ainda está ativo (todas as informações de estado e associação são preservadas). Porém, ela não fica mais visível para o usuário e termina com o encerramento da Atividade. Assim como acontece com as atividades, você também pode usar uma combinação de onSaveInstanceState(Bundle), ViewModel e armazenamento local persistente para preservar o estado da interface do usuário de um fragmento durante alterações de configuração e encerramento de processos. Para saber mais sobre como preservar o estado da UI, consulte Salvando o estado da UI.

Para o ciclo de vida da atividade e o ciclo de vida do fragmento, a diferença mais significativa entre os dois é o método de armazenamento em suas respectivas pilhas de retorno. Por padrão, quando uma atividade é interrompida, ela é colocada na pilha de retorno de atividades gerenciada pelo sistema. No entanto, o sistema coloca o fragmento na backstack gerenciada pela Activity host somente quando uma instância é explicitamente solicitada para ser salva chamando addToBackStack() durante a transação que removeu o fragmento.

Em outros aspectos, o gerenciamento do ciclo de vida do fragmento é muito semelhante ao gerenciamento do ciclo de vida da atividade; a mesma abordagem pode ser adotada aqui.

Nota: Se você precisar de um objeto Context no Fragment, poderá chamar getContext(). Observe, entretanto, que getContext() só precisa ser chamado quando o fragmento é anexado a uma Activity. Se o fragmento não foi anexado ou foi desanexado durante o fim da vida útil, getContext() retornará nulo.

Perguntas da entrevista relacionadas ao fragmento:

1. Como alternar o fragmento (sem reinstanciação)

Olhando o documento oficial do Android e o código-fonte de alguns componentes, descobri que o método replace() é apenas um método conveniente quando o Fragment anterior não é mais necessário.

O método de comutação correto é add(), hide() ao alternar e add() outro Fragment; ao alternar novamente, apenas hide() o atual e show() o outro. Desta forma, vários switches Fragment podem ser alcançados sem reinstanciação:

2. Vantagens do Fragmento

• Os fragmentos permitem separar uma atividade em vários componentes reutilizáveis, cada um com seu próprio ciclo de vida e interface de usuário.
• Os fragmentos podem criar facilmente designs de UI dinâmicos e flexíveis que podem se adaptar a diferentes tamanhos de tela. Do telefone ao tablet.
• Fragmento é um módulo independente, fortemente ligado à atividade. Ele pode ser removido, adicionado, trocado, etc. dinamicamente durante a operação.
• Os fragmentos fornecem uma nova maneira de unificar sua IU em diferentes dispositivos Android.
• O Fragment resolve o problema da alternância complicada entre atividades e da alternância leve.
• Fragment substitui TabActivity para navegação e tem melhor desempenho.
• Fragment adiciona um método de uso de fragmentos aninhados na versão 4.2., que pode gerar melhores efeitos de interface.

3. Como o Fragment consegue efeitos push e pop semelhantes à pilha de atividades

O gerenciador de coisas do Fragment mantém uma estrutura de lista duplamente vinculada internamente, que pode registrar o Fragmento que adicionamos e substituir o Fragmento a cada vez e, quando clicarmos no botão Voltar, ele nos ajudará automaticamente a realizar a operação de desempilhamento.

4. A diferença entre os métodos substituir e adicionar do Fragment

O fragmento em si não possui métodos de substituição e adição. O entendimento aqui deve ser a diferença entre usar os métodos de substituição e adição do FragmentManager para alternar fragmentos.

Uma das arquiteturas que usamos com frequência é alternar fragmentos por meio do RadioGroup, e cada fragmento é um módulo funcional.

O contêiner do Fragment é um FrameLayout. Ao adicionar, todos os Fragments são sobrepostos ao FrameLayout camada por camada. Ao substituir, primeiro remova os outros Fragments do contêiner e depois adicione o Fragment atual ao contêiner.

Apenas um tipo de Fragment pode ser adicionado a um contêiner Fragment. Se for adicionado várias vezes, uma exceção será relatada e o programa será encerrado. No entanto, não importa a substituição, apenas alterne à vontade.

Como cada Fragmento adicionado pelo método add só pode ser adicionado uma vez, se você deseja obter o efeito de alternância, você precisa usar a combinação dos métodos ocultar e mostrar do Fragmento. Mostre aqueles a serem exibidos e oculte outros. O ciclo de vida do Fragmento não mudou neste processo. Alternar Fragmentos por substituição executará o onDestroyView do Fragment anterior e os métodos onCreateView, onStart e onResume do novo Fragment todas as vezes.

Com base nas diferentes características acima, o uso que utilizamos deve ser combinado com o ciclo de vida para operar nossas visualizações e dados.

5. Como passar valor entre Fragmento e Atividade

• A atividade passa valor para o fragmento:

Coloque o valor a ser passado no objeto bundle; Crie o objeto fragmento fragmento do Fragment na Activity e passe-o para o fragmento chamando fragment.setArguments(); Obtenha o objeto bundle chamando getArguments() no Fragment, e você pode obter o valor interno.

• Fragmento passa valor para Activity:

Chame getFragmentManager() em Activity para obter fragmentManager, chame findFragmentByTag(tag) ou passe findFragmentById(id) FragmentManager fragmentManager = getFragmentManager(); Fragment fragment = fragmentManager.findFragmentByTag(tag);

Através do callback, defina uma interface (pode ser definida na classe Fragment), existe um método vazio na interface, o método da interface é chamado quando necessário no fragmento, o valor pode ser colocado neste método como parâmetro, e então deixe a atividade implementar. Essa interface inevitavelmente reescreverá esse método, para que o valor seja passado para a atividade.

6. Ciclo de vida do fragmento

• onAttach(Contextcontext): chamado quando Fragment e Activity estão associados e chamado apenas uma vez. Neste callback, podemos converter o contexto em uma Activity e salvá-lo, evitando assim a situação de chamar frequentemente getAtivity() para obter a Activity posteriormente, e evitando a exceção de que getAtivity() está vazio em alguns casos (quando a Activity e Fragmento são separados). Ao mesmo tempo, os argumentos recebidos também podem ser extraídos e analisados ​​​​no retorno de chamada.Aqui, é altamente recomendável passar parâmetros para o Fragment por meio de setArguments, porque o Fragment não salvará as propriedades relacionadas quando o aplicativo for reciclado pelo sistema.
• onCreate: será chamado quando o Fragment for criado inicialmente, semelhante ao onCreate da Activity.
• View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState): Chamado quando a interface Fragment está pronta para ser desenhada, o valor de retorno é a visualização raiz do Fragment para desenhar o layout, claro, também pode retornar nulo. Observe que attachmentToRoot deve ser especificado como falso ao usar o inflater para construir uma visualização, porque Fragment adicionará automaticamente a visualização ao contêiner e, se attachmentToRoot for verdadeiro, o erro será adicionado repetidamente. onCreateView não é necessariamente chamado, ele não será chamado ao adicionar um Fragment sem uma interface, como chamar o método add(Fragment fragment, String tag) de FragmentTransaction.
• onActivityCreated: Será chamado quando o onCreated da Activity for executado.
• onStart(): Chamado quando o Fragment está visível para o usuário, desde que a Activity tenha sido iniciada.
• onResume(): Será chamado quando o Fragment e o usuário puderem interagir antes, desde que a Activity tenha sido retomada.
• onPause(): Será chamado quando o Fragment e o usuário não puderem interagir entre si antes.
• onStop(): chamado quando o Fragment não está visível.
• onDestroyView(): chamado quando a hierarquia de visualização relacionada ao fragmento é removida.
• onDestroy(): Será chamado quando o estado Fragment for finalmente limpo.
• onDetach(): chamado quando Fragment e Activity são desassociados.

7. O impacto do ViewPager no ciclo de vida do fragmento

ViewPager+Fragment é uma combinação relativamente comum, geralmente usada com FragmentPagerAdapter ou FragmentStatePagerAdapter do ViewPager. No entanto, o ViewPager possui um mecanismo de cache para evitar o congelamento do deslizamento. Por padrão, o ViewPager criará e armazenará páginas em cache (como fragmentos) nos lados esquerdo e direito da página atual. Neste momento, os fragmentos esquerdo e direito executarão o ciclo de vida de onAttach->….->onResume. Obviamente, o fragmento não foi exibido, mas atingiu onResume. Em alguns casos, ocorrerão problemas. Por exemplo, o tempo de carregamento dos dados, julgar se o Fragmento está visível, etc.

último compartilhamento

[Equipe técnica da Tencent produzida] Entrada para proficiência baseada em Android, tutorial de instalação do Android Studio + um conjunto completo de tutoriais básicos do Android

Tutorial de programação Android

Noções básicas da linguagem Java, desde a entrada até a familiaridade

Noções básicas da linguagem Kotlin, desde a entrada até a familiaridade

Pilha de tecnologia Android desde a entrada até a familiaridade

Aprendizado abrangente da família Android Jetpack

Para iniciantes, pode ser difícil instalar o Android Studio. Você pode assistir ao vídeo a seguir e aprender a instalar e executar passo a passo.

Tutorial de instalação do Android Studio

Com o aprendizado da etapa Java, recomenda-se focar no aprendizado em vídeo nesta fase e complementá-lo com livros para verificar omissões. Se você se concentra em livros, pode digitar códigos com base nas explicações dos livros, complementados por vídeos didáticos para verificar omissões. Se você encontrar problemas, pode ir ao Baidu. Geralmente, muitas pessoas encontrarão problemas ao começar e darão respostas melhores.

É necessário dominar conhecimentos básicos, como usar os quatro componentes principais, como criar um Serviço, como fazer o layout, visualização personalizada simples, animação, comunicação em rede e outras tecnologias comuns.

Um conjunto completo de tutoriais baseados em zero foi preparado para você. Se precisar, você pode adicionar o código QR abaixo para obtê-lo gratuitamente

Um conjunto completo de tutoriais básicos do Android