Android Academy · Lekcja

Fragmenty

Lekcja 6 z 713 kroki

Fragmenty to bezpłatna lekcja Android Academy na CoddyKit. To lekcja 6 z 7. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Android Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Android Academy zawiera 7 lekcji w sumie.

Czym są fragmenty?

Fragment to wielokrotnie używany moduł interfejsu użytkownika działający wewnątrz aktywności. Można go traktować jak podaktywność z własnym układem, cyklem życia i logiką.

Dlaczego warto używać fragmentów?

Ponowne używanie interfejsu w wielu aktywnościach
Obsługa różnych układów dla telefonu i tabletu
Tworzenie wieloekranowych przepływów bez wielu aktywności
Naturalna współpraca z Navigation Component

Cykl życia fragmentu

Fragmenty mają własny cykl życia, który przebiega równolegle do cyklu życia aktywności. Najważniejsze metody zwrotne:

onAttach — fragment dołączony do aktywności
onCreate — fragment utworzony (widok jeszcze nie istnieje)
onCreateView — rozwinięcie układu
onViewCreated — widok jest gotowy, tutaj skonfiguruj interfejs
onDestroyView — widok zniszczony (wyczyść odwołania do widoku)
onDetach — fragment odłączony

Tworzenie fragmentu

Utwórz klasę rozszerzającą Fragment i przesłoń metodę onCreateView, aby rozwinąć układ:

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 we fragmentach

Używaj ViewBinding we fragmentach, ale zwalniaj powiązanie w onDestroyView, aby uniknąć wycieków pamięci:

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 układu fragmentu

Utwórz plik res/layout/fragment_home.xml tak samo jak układ aktywności. Widok główny stanie się widokiem fragmentu:

<!-- 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>

Dodawanie fragmentu do aktywności

Fragment można dodać do aktywności na dwa sposoby:

Statycznie (XML) — zadeklaruj go w układzie za pomocą znacznika <fragment>. Jest ustalony podczas działania aplikacji.
Dynamicznie (kod) — użyj FragmentManager i transakcji. Można go zamieniać podczas działania aplikacji.

<!-- 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" />

Dynamiczne transakcje fragmentów

Użyj supportFragmentManager, aby podczas działania aplikacji dodawać, zastępować lub usuwać fragmenty:

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

Przekazywanie argumentów do fragmentów

Przekazuj dane za pomocą Bundle i wzorca fabryki z obiektem companion. Nigdy nie używaj konstruktora fragmentu z parametrami — po zmianie konfiguracji system Android odtwarza fragmenty za pomocą konstruktora bez argumentów:

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

Komunikacja Fragment → Activity

Użyj interfejsu zdefiniowanego we fragmencie i zaimplementowanego przez aktywność. Fragment uzyskuje do niego odwołanie za pomocą 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
    }
}

Stos powrotu

Gdy w transakcji wywołasz addToBackStack(null), naciśnięcie przycisku Wstecz usunie fragment ze stosu:

Bez addToBackStack — przycisk Wstecz zamyka aktywność
Z addToBackStack — przycisk Wstecz powraca do poprzedniego fragmentu
Użyj programowo popBackStack(), aby przejść wstecz

Fragment w kontenerze

Układ aktywności potrzebuje tylko widoku kontenera — zwykle FrameLayout z identyfikatorem. Fragment wypełni ten kontener:

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

Szybkie sprawdzenie

Dlaczego nie należy przekazywać argumentów do konstruktora fragmentu, lecz używać Bundle za pośrednictwem fabryki w obiekcie companion?

Odpowiedz w interaktywnej lekcji

Podsumowanie: fragmenty

Fragmenty są podstawowymi elementami nowoczesnych interfejsów użytkownika systemu Android:

Rozszerzaj Fragment i rozwijaj układ w onCreateView
Konfiguruj interfejs w onViewCreated
Zwalniaj ViewBinding w onDestroyView
Przekazuj dane za pomocą Bundle i fabryki w obiekcie companion (newInstance)
Używaj addToBackStack do nawigacji wstecz
Komunikuj się z aktywnością za pomocą interfejsu

W następnej części poprosisz o niebezpieczne uprawnienia w czasie działania aplikacji.

Bezpłatny start

Ucz się Kotlin dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 36
Lekcje: 152

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Fragmenty” jest bezpłatna?

Tak — pełny tekst „Fragmenty” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Android Academy, przejdź na CoddyKit PRO. Kurs Android Academy zawiera 7 lekcji w sumie.

Co nauczysz się w „Fragmenty”?

Proszę budować modułowe interfejsy za pomocą Fragmentów. Proszę poznać cykl życia fragmentu, ViewBinding we fragmentach, przekazywanie argumentów, zarządzanie stosem powrotu oraz komunikację fragment… Ćwiczysz Android Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Android Academy?

Nie wymagamy żadnego doświadczenia. Android Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 6 z 7.

Ile czasu zajmuje lekcja „Fragmenty”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Android Academy?

Tak. Każda lekcja Android Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Android Academy