Android Academy · Lección

Fragments

Fragments es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 6 de 7. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 7 lecciones en total.

¿Qué son los Fragments?

Un Fragment es un módulo de interfaz de usuario reutilizable que vive dentro de una Activity. Considérelo como una sub-Activity con su propio diseño, ciclo de vida y lógica.

¿Por qué usar Fragments?

Reutilizar la interfaz en varias Activities
Gestionar distintos diseños para teléfonos y tablets
Crear flujos de varias pantallas sin varias Activities
Trabajar de forma natural con Navigation Component

Ciclo de vida de un Fragment

Los Fragments tienen su propio ciclo de vida, que se ejecuta junto al ciclo de vida de la Activity. Callbacks principales:

onAttach — el fragment se adjunta a la Activity
onCreate — se crea el fragment (todavía sin vista)
onCreateView — infla el diseño
onViewCreated — la vista está lista; configure aquí la interfaz
onDestroyView — se destruye la vista (elimine las referencias a ella)
onDetach — el fragment se separa

Crear un Fragment

Cree una clase que extienda Fragment y sobrescriba onCreateView para inflar el diseño:

import androidx.fragment.app.Fragment
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup

class HomeFragment : Fragment() {

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.fragment_home, container, false)
    }
}

ViewBinding en Fragments

Use ViewBinding en los fragments, pero libere el binding en onDestroyView para evitar fugas de memoria:

class HomeFragment : Fragment() {

    private var _binding: FragmentHomeBinding? = null
    private val binding get() = _binding!!

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
        _binding = FragmentHomeBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.tvTitle.text = "Welcome!"
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null   // prevent memory leak
    }
}

XML del diseño de un Fragment

Cree res/layout/fragment_home.xml igual que un diseño de Activity. La vista raíz se convierte en la vista del Fragment:

<!-- res/layout/fragment_home.xml -->
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/tvTitle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="24sp"
        android:text="Home" />

</LinearLayout>

Añadir un Fragment a una Activity

Hay dos formas de añadir un Fragment a una Activity:

Estática (XML) — declárelo en el diseño con la etiqueta <fragment>. Es fija en tiempo de ejecución.
Dinámica (código) — use FragmentManager y transacciones. Puede cambiarse en tiempo de ejecución.

<!-- Static: in activity_main.xml -->
<fragment
    android:id="@+id/homeFragment"
    android:name="com.example.HomeFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Transacciones dinámicas de Fragments

Use supportFragmentManager para añadir, reemplazar o eliminar fragments en tiempo de ejecución:

// In Activity:
class MainActivity : AppCompatActivity(R.layout.activity_main) {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        if (savedInstanceState == null) {
            supportFragmentManager.beginTransaction()
                .add(R.id.fragmentContainer, HomeFragment())
                .commit()
        }
    }

    fun showDetail(id: Int) {
        supportFragmentManager.beginTransaction()
            .replace(R.id.fragmentContainer, DetailFragment.newInstance(id))
            .addToBackStack(null)  // allow back navigation
            .commit()
    }
}

Pasar argumentos a Fragments

Pase datos mediante un Bundle usando el patrón de fábrica del companion object. No use nunca un constructor de Fragment con parámetros: Android recrea los fragments con un constructor sin argumentos después de cambios de configuración:

class DetailFragment : Fragment() {

    companion object {
        private const val ARG_ID = "item_id"

        fun newInstance(itemId: Int): DetailFragment {
            return DetailFragment().apply {
                arguments = Bundle().apply {
                    putInt(ARG_ID, itemId)
                }
            }
        }
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val itemId = requireArguments().getInt(ARG_ID)
        // use itemId to load data
    }
}

Comunicación entre Fragment y Activity

Use una interface definida en el Fragment e implementada por la Activity. El Fragment obtiene una referencia mediante onAttach:

class ListFragment : Fragment() {

    interface OnItemSelected {
        fun onItemSelected(id: Int)
    }

    private var listener: OnItemSelected? = null

    override fun onAttach(context: Context) {
        super.onAttach(context)
        listener = context as? OnItemSelected
    }

    private fun handleClick(id: Int) {
        listener?.onItemSelected(id)
    }

    override fun onDetach() {
        super.onDetach()
        listener = null
    }
}

Pila de retroceso

Cuando llama a addToBackStack(null) en una transacción, al pulsar Atrás se extrae el fragment de la pila:

Sin addToBackStack: Atrás cierra la Activity
Con addToBackStack: Atrás vuelve al fragment anterior
Use popBackStack() mediante programación para volver atrás

Fragment en un contenedor

El diseño de la Activity solo necesita una vista contenedora, normalmente un FrameLayout con un ID. El Fragment ocupa ese contenedor:

<!-- activity_main.xml -->
<FrameLayout
    android:id="@+id/fragmentContainer"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

Comprobación rápida

¿Por qué nunca debe pasar argumentos al constructor de un Fragment y debe usar en su lugar un Bundle mediante una fábrica companion?

Repaso: Fragments

Los Fragments son los componentes básicos de las interfaces de usuario modernas de Android:

Extienda Fragment e infle el diseño en onCreateView
Configure la interfaz en onViewCreated
Libere ViewBinding en onDestroyView
Pase datos mediante Bundle + una fábrica companion (newInstance)
Use addToBackStack para la navegación hacia atrás
Comuníquese con la Activity mediante una interface

A continuación: solicite permisos peligrosos en tiempo de ejecución.

Preguntas frecuentes

¿La lección «Fragments» es gratis?

Sí — el texto completo de «Fragments» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 7 lecciones en total.

¿Qué aprenderé en «Fragments»?

Construya interfaces de usuario modulares con Fragments. Aprenda el ciclo de vida de los fragments, ViewBinding en fragments, el paso de argumentos, la gestión de la pila de retroceso y la comunicaci… Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 6 de 7.

¿Cuánto tiempo toma la lección «Fragments»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Android Academy