Tutorial de introducción a Android | Conceptos básicos de Fragment

¿Qué son los fragmentos?

Fragmento, traducido literalmente como "fragmento", "fragmento". Fragment representa el comportamiento o parte de la interfaz en FragmentActivity. Puede combinar varios fragmentos en una actividad para crear una interfaz de paneles múltiples y reutilizar un fragmento en varias actividades. Los fragmentos se pueden considerar como componentes modulares de una Actividad que tienen su propio ciclo de vida, reciben sus propios eventos de entrada y se pueden agregar o eliminar mientras la Actividad se está ejecutando (es un poco como una "Actividad secundaria").

Los fragmentos siempre deben alojarse en una Actividad y su ciclo de vida se ve directamente afectado por el ciclo de vida de la Actividad del host. Por ejemplo, cuando se pausa la Actividad, todos los fragmentos de la Actividad también se pausan; cuando se destruye la Actividad, también se destruyen todos los fragmentos.

Sin embargo, mientras la actividad se está ejecutando (en el estado del ciclo de vida reanudado), cada fragmento se puede manipular de forma independiente, como agregar o eliminar fragmentos. Cuando se ejecuta una transacción de fragmento de este tipo, también se agrega a la pila de actividades administrada por la Actividad; cada entrada de la pila de actividades en la Actividad es un registro de que se ha producido una transacción de fragmentos. Con la pila de actividades, el usuario puede deshacer la transacción del fragmento (atrás) presionando el botón Atrás.

Ventajas de los fragmentos

• La carga de fragmentos es flexible y fácil de reemplazar. Personalice su interfaz de usuario, cree una interfaz de usuario adecuada en pantallas de diferentes tamaños y mejore la experiencia del usuario.
• Reutilizable, el diseño de la página puede utilizar varios Fragmentos y se pueden distribuir diferentes controles y contenidos en diferentes Fragmentos.
• Usando Fragment, puedes usar menos Actividad. Una Actividad puede gobernar múltiples Fragmentos.

Ciclo de vida del fragmento

El código de la clase Fragmento es muy similar al de Actividad. Contiene métodos de devolución de llamada similares a Activity, como onCreate(), onStart(), onPause() y onStop(). De hecho, si estás convirtiendo una aplicación de Android existente para usar fragmentos, es posible que solo necesites mover el código del método de devolución de llamada de la actividad al método de devolución de llamada correspondiente al fragmento.

Normalmente, se deben implementar al menos los siguientes métodos de ciclo de vida :

• onCreate() El sistema llama a este método cuando se crea el fragmento. Si desea conservar los componentes básicos de un fragmento después de haberlo pausado o detenido y luego reanudado, debe inicializarlo en su implementación.
• onCreateView() El sistema llama a este método cuando el fragmento dibuja su interfaz por primera vez. Para dibujar la interfaz de un fragmento, la Vista devuelta por este método debe ser la vista raíz del diseño del fragmento. Puede devolver nulo si el fragmento no proporciona una interfaz.
• onPause() El sistema llama a este método como la primera señal de que el usuario abandona el fragmento (pero no siempre significa que el fragmento será destruido). En general, cualquier cambio que persista después de que finalice la sesión del usuario actual (ya que es posible que el usuario no regrese) debe reconocerse dentro de este método.

Es posible que también desees ampliar varias subclases además de la clase base Fragment :

• DialogFragment muestra un cuadro de diálogo flotante. Usar esta clase para crear un diálogo es una alternativa efectiva al uso de los métodos auxiliares de diálogo en la clase Actividad, porque puede colocar el diálogo del fragmento en la pila de fragmentos administrada por la Actividad, lo que permite al usuario regresar a un fragmento borrado.
• ListFragment muestra una colección de elementos administrados por un adaptador como SimpleCursorAdapter, similar a ListActivity. Esta clase proporciona varios métodos para administrar la vista de lista, como la devolución de llamada onListItemClick() para manejar eventos de clic. (Tenga en cuenta que la forma preferida de mostrar una lista es usar RecyclerView, no ListView. En este caso, cree un fragmento que contenga RecyclerView en el diseño de la lista. Consulte Creación de una lista con RecyclerView para aprender cómo hacerlo).
• PreferenceFragmentCompat muestra una jerarquía de objetos de preferencia en forma de lista. Esta clase se utiliza para crear pantallas de configuración para la aplicación.

Crear fragmento, usar interfaz personalizada

Los fragmentos se utilizan normalmente como parte de la interfaz de una Actividad e incorporarán su propio diseño a la Actividad.

Para proporcionar un diseño para un fragmento, debe implementar onCreateView()el método de devolución de llamada que llama el sistema Android cuando el fragmento necesita dibujar su diseño. La Vista devuelta por una implementación de este método debe ser la vista raíz del diseño del fragmento.

Para devolver un diseño desde onCreateView(), el diseño se puede ampliar mediante un recurso de diseño definido en XML. Para ayudarle a hacer esto, onCreateView() proporciona un objeto LayoutInflater.

Por ejemplo, la siguiente subclase Fragmento example_fragment.xmlcarga el diseño desde un archivo:

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);
    }
}

El parámetro contenedor al que se pasa onCreateView()es el ViewGroup principal (del diseño de la actividad) en el que se insertará el diseño del fragmento. El parámetro saveInstanceState es el paquete que proporciona datos relacionados con la instancia del fragmento anterior cuando se restaura el fragmento (la sección que trata sobre el ciclo de vida del fragmento explica en detalle el estado de restauración).

El método inflate() toma tres parámetros :

• El ID de recurso del diseño que desea ampliar.
• El ViewGroup que será el padre del diseño extendido. Pasar un contenedor tiene importancia para que el sistema aplique parámetros de diseño a la vista raíz (especificada por la vista principal a la que pertenece) del diseño extendido.
• Un booleano que indica si se debe adjuntar un diseño expandido al ViewGroup (segundo parámetro) durante la expansión. (En este caso, el valor es falso porque el sistema ya insertó el diseño expandido en el contenedor y pasar un valor verdadero habría creado un grupo de vista redundante en el diseño final).

A continuación, debes agregar este fragmento a tu Actividad.

Agregar fragmento a la actividad

Normalmente, los fragmentos aportan una parte de la interfaz a la Actividad del host, incrustados en la Actividad como parte de la jerarquía de vistas general de la Actividad. Hay dos formas de agregar fragmentos al diseño de Actividad (los fragmentos de código a continuación no están completos).

manera estática

Declare fragmentos dentro del archivo de diseño de la actividad. En este caso, puede especificar propiedades de diseño para un fragmento como si fuera una vista. Por ejemplo, aquí está el archivo de diseño para una Actividad con dos 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>El atributo en android:nameespecifica la clase Fragmento para crear una instancia en el diseño.

Cuando se crea este diseño de actividad, el sistema crea una instancia de cada fragmento especificado en el diseño y llama onCreateView()al método de cada fragmento para recuperar el diseño de cada fragmento. La Vista devuelta por el fragmento se inserta directamente en lugar del <fragment>elemento.

Nota: Cada fragmento requiere un identificador único que el sistema puede usar para restaurar el fragmento cuando se reinicia la actividad (o para capturar el fragmento para realizar ciertas transacciones, como eliminarlo). Hay dos formas de proporcionar una ID para un fragmento: Proporcionar una ID única para el atributo android:id. Proporcione una cadena única para el atributo android:tag.

El código Java carga Fragmento

Alternativamente, agregue mediante programación el fragmento a un ViewGroup existente. Puede agregar fragmentos al diseño de la actividad en cualquier momento mientras se ejecuta la actividad. Simplemente especifica en qué grupo de vistas desea colocar el fragmento.

Para realizar transacciones de fragmentos (como agregar, eliminar o reemplazar fragmentos) en una Actividad, debe usar las API en FragmentTransaction. Se puede obtener una instancia de FragmentTransaction de FragmentActivity de la siguiente manera:

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

Luego puede add()agregar un fragmento usando el método, especificando qué fragmento agregar y en qué vista insertarlo. Por ejemplo:

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

El primer parámetro al que se pasa add()es el ViewGroup donde se debe colocar el fragmento, especificado por el ID del recurso, y el segundo parámetro es el fragmento a agregar. Una vez que se hayan realizado los cambios a través de FragmentTransaction, se debe llamar commit()para que los cambios surtan efecto.

Administrar fragmentos

Para administrar los fragmentos en la Actividad, debe usar FragmentManager. Para obtenerlo, llámalo desde Activity getSupportFragmentManager().

Las operaciones que se pueden realizar con FragmentManager incluyen :

• findFragmentById()Obtenga los fragmentos presentes en la Actividad mediante (para fragmentos que proporcionan una interfaz en el diseño de la Actividad) o findFragmentByTag() (para fragmentos que proporcionan o no una interfaz).
• popBackStack()Extraiga el fragmento de la pila posterior ( simulando un comando de retorno emitido por el usuario).
• addOnBackStackChangedListener()Registre un oyente para cambios en la pila de retorno a través de .

FragmentManager también se puede utilizar para abrir un FragmentTransaction, a través del cual realizar ciertas transacciones, como agregar y eliminar fragmentos.

Ejecutar transacción de fragmento

Una de las mejores cosas de usar fragmentos en una Actividad es que puedes agregar, eliminar, reemplazar y hacer otras cosas con el fragmento en respuesta a la interacción del usuario. Cada conjunto de cambios confirmados en una Actividad se denomina transacción y las API de FragmentTransaction se pueden utilizar para realizar una transacción. Cada transacción también se puede guardar en una pila de actividades administrada por la Actividad, lo que permite al usuario revertir los cambios de fragmentos (similar a revertir la Actividad).

Se puede obtener una instancia de FragmentTransaction desde FragmentManager de la siguiente manera:

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

Cada transacción es un conjunto de cambios que desea realizar al mismo tiempo. Puede utilizar métodos como agregar(), eliminar() y reemplazar() para configurar todos los cambios que desea realizar para una transacción determinada. Luego, para aplicar la transacción a la Actividad, debes llamar a commit().

Sin embargo, antes de llamar a commit(), es posible que desees llamar a addToBackStack() para agregar la transacción a la pila posterior de transacciones de fragmentos. Esta pila de actividades es administrada por la Actividad y permite al usuario regresar al estado del fragmento anterior presionando el botón Atrás.

Por ejemplo, el siguiente ejemplo muestra cómo reemplazar un fragmento por otro y preservar el estado anterior en la pila posterior:

// 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();

En este caso, newFragment reemplaza cualquier fragmento (si lo hay) actualmente en el contenedor de diseño identificado por el ID de R.id.fragment_container. Al llamar a addToBackStack(), se puede guardar una transacción de reemplazo en la pila de actividades para que el usuario pueda deshacer la transacción y retroceder al fragmento anterior presionando el botón Atrás.

FragmentActivity luego recupera automáticamente el fragmento de la pila posterior a través de onBackPressed().

Si agrega varios cambios a una transacción (como otro add() o remove()) y llama a addToBackStack(), todos los cambios aplicados antes de llamar a commit() se agregarán a la pila de actividades como una sola transacción, y el El botón Atrás los deshará todos.

Sin embargo, el orden en el que agregas cambios a FragmentTransaction no importa:

commit() debe llamarse en último lugar. Si agrega varios fragmentos al mismo contenedor, el orden en que los agregue determinará el orden en que aparecerán en la jerarquía de vistas. Si no se llama a addToBackStack() durante la transacción que elimina el fragmento, el fragmento se destruirá cuando se confirme la transacción y el usuario no podrá volver al fragmento. Sin embargo, si se llama a addToBackStack() mientras se elimina el fragmento, el sistema detiene el fragmento y luego lo reanuda cuando el usuario regresa.

Llamar a commit() no ejecuta la transacción inmediatamente, sino que programa la transacción para que se ejecute en el subproceso cuando el subproceso de la interfaz de usuario de la actividad (el subproceso "principal") esté disponible para hacerlo. Sin embargo, si es necesario, también se puede llamar a ejecutarPendingTransactions() desde el subproceso de la interfaz de usuario para ejecutar las transacciones confirmadas de commit() inmediatamente. Normalmente no es necesario hacer esto a menos que los trabajos en otros subprocesos dependan de la transacción.

Nota: Solo puede usar commit() para confirmar una transacción antes de que la Actividad guarde su estado (cuando el usuario abandona la Actividad). Se lanzará una excepción si se intenta confirmar después de ese punto. Esto se debe a que el estado enviado puede perderse si es necesario reanudar la Actividad. Para los casos en los que las confirmaciones faltantes no importan, utilice commitAllowingStateLoss().

cambios en el ciclo de vida

Cuando se crea el fragmento

Pasa por los siguientes estados.

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

Cuando el Fragmento es visible para el usuario

Pasa por los siguientes estados.

onStart()
onResume()

Cuando Fragment entra en "modo de fondo"

Pasa por los siguientes estados.

onPause()
onStop()

Se destruye el fragmento (o se destruye la actividad que lo contiene)

Pasa por los siguientes estados.

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

Diferentes ciclos de vida entre Fragmento y Actividad.

La mayor parte del estado de Fragment es similar a Activity, pero Fragment tiene algunos estados nuevos.

El fragmento es diferente del ciclo de vida de la actividad.

• onAttached()—— Llamado cuando se agrega el fragmento a la actividad (en este método se puede obtener la actividad donde se encuentra).
• onCreateView()—— Cuando la actividad quiere obtener el diseño del fragmento, se llama a este método y el fragmento crea su propio diseño (interfaz) en él.
• onActivityCreated()—— Este método se llama después de que regresa el método onCreated() de la actividad
• onDestroyView()- Este método se llama cuando se elimina la vista en el fragmento.
• onDetach()—— Este método se llama cuando el fragmento y la actividad están separados.

Una vez que la actividad ingresa al estado reanudado (es decir, al estado de ejecución), puede agregar y eliminar fragmentos libremente. Por lo tanto, solo cuando la actividad está en el estado reanudado, el ciclo de vida del fragmento puede ejecutarse de forma independiente, y otras veces depende del cambio del ciclo de vida de la actividad.

Manejar el ciclo de vida del fragmento

Administrar el ciclo de vida del fragmento es muy similar a administrar el ciclo de vida de la actividad. Al igual que las actividades, los fragmentos existen en tres estados:

• Restaurado: el fragmento es visible en la actividad en ejecución.
• En pausa: otra actividad está en primer plano y tiene el foco, pero la actividad en la que reside este fragmento aún está visible (la actividad en primer plano es parcialmente transparente o no cubre toda la pantalla).
• Detenido: el fragmento no es visible. La actividad del host se detuvo o el fragmento se eliminó de la actividad pero se agregó a la pila de actividades. Un fragmento detenido todavía está activo (se conserva toda la información de estado y membresía). Sin embargo, ya no es visible para el usuario y finaliza con la finalización de la Actividad. Al igual que con las actividades, también puede usar una combinación de onSaveInstanceState(Bundle), ViewModel y almacenamiento local persistente para preservar el estado de la interfaz de usuario de un fragmento durante los cambios de configuración y la terminación del proceso. Para obtener más información sobre cómo conservar el estado de la IU, consulte Guardar el estado de la IU.

Para el ciclo de vida de la actividad y el ciclo de vida del fragmento, la diferencia más significativa entre los dos es el método de almacenamiento en sus respectivas pilas de retorno. De forma predeterminada, cuando una actividad se detiene, se coloca en la pila de actividades administrada por el sistema. Sin embargo, el sistema coloca el fragmento en la pila de actividades administrada por la Actividad del host solo cuando se solicita explícitamente que se guarde una instancia llamando a addToBackStack() durante la transacción que eliminó el fragmento.

En otros aspectos, gestionar el ciclo de vida del fragmento es muy similar a gestionar el ciclo de vida de la actividad; aquí se puede adoptar el mismo enfoque.

Nota: Si necesita un objeto Context en el Fragmento, puede llamar a getContext(). Sin embargo, tenga en cuenta que solo es necesario llamar a getContext() cuando el fragmento está adjunto a una actividad. Si el fragmento no se adjuntó o se separó durante el final de su vida útil, getContext() devuelve nulo.

Preguntas de entrevista relacionadas con fragmentos:

1. Cómo cambiar de fragmento (sin volver a crear instancias)

Al revisar el documento oficial de Android y el código fuente de algunos componentes, descubrí que el método replace() es solo un método conveniente cuando el Fragmento anterior ya no es necesario.

El método de cambio correcto es agregar(), ocultar() al cambiar y agregar() otro Fragmento; al cambiar nuevamente, simplemente ocultar() el actual y mostrar() el otro. De esta manera, se pueden lograr múltiples cambios de Fragmento sin necesidad de volver a crear instancias:

2. Ventajas del fragmento

• Los fragmentos le permiten separar una actividad en múltiples componentes reutilizables, cada uno con su propio ciclo de vida e interfaz de usuario.
• Los fragmentos pueden crear fácilmente diseños de interfaz de usuario dinámicos y flexibles que pueden adaptarse a diferentes tamaños de pantalla. Del teléfono a la tableta.
• Fragmento es un módulo independiente, estrechamente vinculado con la actividad. Se puede eliminar, agregar, intercambiar, etc. dinámicamente durante la operación.
• Los fragmentos le brindan una nueva forma de unificar su interfaz de usuario en diferentes dispositivos Android.
• Fragment resuelve el problema del cambio irregular entre actividades y el cambio ligero.
• Fragment reemplaza a TabActivity para la navegación y tiene un mejor rendimiento.
• Fragment agrega un método de uso de fragmentos anidados en la versión 4.2, que puede generar mejores efectos de interfaz.

3. ¿Cómo logra Fragment efectos push y pop similares a la pila de actividades?

El administrador de cosas de Fragment mantiene una estructura de lista doblemente vinculada en su interior, que puede registrar el Fragmento que agregamos y reemplazamos cada vez, y luego, cuando hacemos clic en el botón Atrás, automáticamente nos ayudará a realizar la operación de desapilado.

4. La diferencia entre los métodos reemplazar y agregar de Fragment

El fragmento en sí no tiene métodos de reemplazo y adición. La comprensión aquí debería ser la diferencia entre usar los métodos de reemplazo y adición de FragmentManager para cambiar fragmentos.

Una de las arquitecturas que utilizamos a menudo es cambiar Fragmentos a través de RadioGroup, y cada Fragmento es un módulo funcional.

El contenedor del Fragmento es un FrameLayout. Al agregar, todos los Fragmentos se superponen en el FrameLayout capa por capa. Al reemplazar, primero elimine los otros Fragmentos en el contenedor y luego agregue el Fragmento actual al contenedor.

Solo se puede agregar un tipo de Fragmento a un contenedor de Fragmentos. Si se agrega varias veces, se informará una excepción y el programa finalizará. Sin embargo, no importa el reemplazo, simplemente cambie a voluntad.

Debido a que cada Fragmento agregado por el método agregar solo se puede agregar una vez, si desea lograr el efecto de cambio, debe usar la combinación de los métodos ocultar y mostrar del Fragmento. Muestra los que se mostrarán y oculta otros. El ciclo de vida del Fragmento no ha cambiado en este proceso. Cambiar Fragmentos mediante reemplazo ejecutará el onDestroyView del Fragmento anterior y los métodos onCreateView, onStart y onResume del nuevo Fragmento cada vez.

Según las diferentes características anteriores, el uso que estamos utilizando debe combinarse con el ciclo de vida para operar nuestras vistas y datos.

5. Cómo pasar valor entre Fragmento y Actividad

• La actividad pasa valor a Fragmento:

Coloque el valor que se pasará al objeto del paquete; cree el fragmento del objeto del Fragmento en la Actividad y páselo al fragmento llamando a fragment.setArguments(); Obtenga el objeto del paquete llamando a getArguments() en el Fragmento, y puedes obtener el valor interno.

• Fragmento pasa valor a Actividad:

Llame a getFragmentManager() en Actividad para obtener fragmentManager, llame a findFragmentByTag(tag) o pase findFragmentById(id) FragmentManager fragmentManager = getFragmentManager();Fragment fragment = fragmentManager.findFragmentByTag(tag);

A través de la devolución de llamada, defina una interfaz (se puede definir en la clase Fragmento), hay un método vacío en la interfaz, el método de la interfaz se llama cuando es necesario en el fragmento, el valor se puede colocar en este método como parámetro, y luego dejar que la Actividad se implemente. Esta interfaz inevitablemente reescribirá este método, de modo que el valor se pase a la Actividad.

6. Ciclo de vida del fragmento

• onAttach(Contextcontext): Se llama cuando el Fragmento y la Actividad están asociados, y solo se llama una vez. En esta devolución de llamada, podemos convertir el contexto en una Actividad y guardarlo, evitando así la situación de llamar frecuentemente a getAtivity() para obtener la Actividad más tarde, y evitando la excepción de que getAtivity() esté vacío en algunos casos (cuando la Actividad y Los fragmentos están separados). Al mismo tiempo, los argumentos entrantes también se pueden extraer y analizar en la devolución de llamada. Aquí, se recomienda encarecidamente pasar parámetros a Fragment a través de setArguments, porque Fragment no guardará las propiedades relacionadas cuando el sistema recicle la aplicación.
• onCreate: Se llamará cuando se cree inicialmente el Fragmento, similar a onCreate de la Actividad.
• View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState): Se llama cuando la interfaz Fragment está lista para ser dibujada. El valor de retorno es la vista raíz de Fragment para dibujar el diseño. Por supuesto, también puede devolver nulo. Tenga en cuenta que adjuntarToRoot debe especificarse como falso cuando se usa el inflador para crear una Vista, porque Fragment agregará automáticamente la vista al contenedor y adjuntarToRoot agregará repetidamente un error si es verdadero. onCreateView no se llama necesariamente, no se llamará al agregar un Fragmento sin una interfaz, como llamar al método add (fragmento de fragmento, etiqueta de cadena) de FragmentTransaction.
• onActivityCreated: Se llamará cuando se ejecute onCreated de la actividad.
• onStart(): Se llama cuando el Fragmento es visible para el usuario, siempre que se haya iniciado la Actividad.
• onResume(): Se llamará cuando el Fragmento y el usuario puedan interactuar antes, siempre que la Actividad se haya reanudado.
• onPause(): Se llamará cuando el Fragmento y el usuario no puedan interactuar entre sí antes.
• onStop(): Se llama cuando el Fragmento no es visible.
• onDestroyView(): Se llama cuando se elimina la jerarquía de vistas relacionadas con Fragmentos.
• onDestroy(): Se llamará cuando finalmente se borre el estado del Fragmento.
• onDetach(): Se llama cuando el Fragmento y la Actividad están desasociados.

7. El impacto de ViewPager en el ciclo de vida de los fragmentos

ViewPager+Fragment es una combinación relativamente común, generalmente utilizada con FragmentPagerAdapter o FragmentStatePagerAdapter de ViewPager. Sin embargo, ViewPager tiene un mecanismo de almacenamiento en caché para evitar que el deslizamiento se congele. De forma predeterminada, ViewPager creará y almacenará en caché páginas (como fragmentos) en los lados izquierdo y derecho de la página actual. En este momento, los Fragmentos izquierdo y derecho ejecutarán el ciclo de vida desde onAttach->….->onResume. Obviamente el Fragmento no se ha mostrado pero ha llegado a onResume. En algunos casos, ocurrirán problemas. Por ejemplo, el momento de cargar datos, juzgar si el Fragmento es visible, etc.

última parte

[Equipo técnico de Tencent producido] Entrada a la competencia de base cero de Android, tutorial de instalación de Android Studio + un conjunto completo de tutoriales básicos de Android

Tutorial de programación de Android

Conceptos básicos del lenguaje Java desde la entrada hasta la familiaridad

Conceptos básicos del lenguaje Kotlin desde la entrada hasta la familiaridad

Pila de tecnología Android desde la entrada hasta la familiaridad

Aprendizaje integral del depósito familiar Android Jetpack

Para los principiantes, puede resultar difícil instalar Android Studio. Puede ver el siguiente video y aprender a instalarlo y ejecutarlo paso a paso.

Tutorial de instalación de Android Studio

Con el aprendizaje de la etapa de Java, se recomienda centrarse en el aprendizaje en video en esta etapa y complementarlo con libros para verificar si hay omisiones. Si se centra en los libros, puede escribir códigos basados ​​en explicaciones de libros, complementados con vídeos didácticos para comprobar si hay omisiones. Si tiene problemas, puede ir a Baidu. Generalmente, muchas personas encontrarán problemas al comenzar y darán mejores respuestas.

Es necesario dominar puntos de conocimiento básicos, como cómo utilizar los cuatro componentes principales, cómo crear un Servicio, cómo diseñar, una Vista personalizada simple, animación, comunicación de red y otras tecnologías comunes.

Se ha preparado un conjunto completo de tutoriales de base cero para usted; si lo necesita, puede agregar el código QR a continuación para obtenerlo gratis

Un conjunto completo de tutoriales básicos de Android.