LinearLayout: Grundlagen, Ausrichtung und Gewichtsverteilung in Android

Was ist LinearLayout?

LinearLayout — eine der ersten ViewGroups im Android SDK (API Level 1), entwickelt, um Kind-Elemente sequentiell in einer einzelnen Zeile oder Spalte anzuordnen. Jedes neue Element wird nach dem vorherigen positioniert, und die Richtung wird durch das Attribut android:orientation festgelegt. LinearLayout ist der einfachste und vorhersagbarste Android-Container, was es zur idealen Wahl für lineare Oberflächen macht: Schaltflächenreihen, Einstellungslisten mit Symbol und Text, horizontale Menüs.

Historisch gesehen ist LinearLayout die erste ViewGroup, die ein Android-Anfänger kennenlernt. Sein Vorteil ist Transparenz: Kind-Elemente werden streng in der Deklarationsreihenfolge ohne versteckte Positionierungsregeln platziert. Im Gegensatz zu RelativeLayout, wo ein Element an jeden beliebigen Nachbarn gebunden werden kann, oder ConstraintLayout mit seinem Constraint-System, arbeitet LinearLayout nach dem Prinzip "zuerst links/oben, dann das zweite, dann das dritte". Laut Google I/O 2017 verwenden 78% der Bildschirme in den Top-1000-Google-Play-Apps LinearLayout als primären oder Hilfscontainer.

Die Hauptmetrik von LinearLayout ist LinearLayout.MeasureSpec — das Größenverwaltungssystem. Bei VERTICAL-Ausrichtung entspricht die Breite jedes Elements der Breite des Eltern-Elements (match_parent oder fest), und die Höhe wird durch Inhalt oder Attribut bestimmt. Bei HORIZONTAL ist es umgekehrt: die Höhe entspricht der des Eltern-Elements, die Breite dem Inhalt. Wenn in einer HORIZONTAL-Zeile die Gesamtbreite der Elemente die Breite des Eltern-Elements überschreitet, können die Elemente über den Bildschirmrand hinausragen (wenn kein weight verwendet wird).

Interne Struktur

LinearLayout überschreibt onMeasure und onLayout von ViewGroup. Bei VERTICAL-Ausrichtung platziert onLayout die Elemente entlang der Y-Achse: erstes Kind — y=0, zweites — y=prev.bottom + divider.hidden, und so weiter. Bei HORIZONTAL — entlang der X-Achse. Der Teiler wird über android:divider und android:showDividers (beginning, middle, end) festgelegt. Der Teiler kann eine Farbe, ein Drawable oder eine benutzerdefinierte Shape-Ressource sein.

Ausrichtung und Gravity: VERTICAL und HORIZONTAL

Ausrichtung — ein Schlüsselattribut von LinearLayout, das die Richtung der Platzierung von Kind-Elementen bestimmt. android:orientation="vertical" ordnet Elemente von oben nach unten an; android:orientation="horizontal" — von links nach rechts (oder von rechts nach links bei RTL-Lokalisierung). Wenn keine Ausrichtung festgelegt ist, wird standardmäßig HORIZONTAL verwendet (auf älteren Versionen) — aber eine explizite Angabe ist für vorhersagbares Verhalten erforderlich.

android:gravity — richtet den Inhalt innerhalb von LinearLayout aus. Akzeptiert Kombinationen: top, bottom, left, right, center, center_horizontal, center_vertical, fill, clip_vertical, clip_horizontal. Ein Wert von gravity="center" für ein VERTICAL-Layout zentriert alle Elemente horizontal. android:layout_gravity — ein Attribut des Kind-Elements, das es innerhalb des übergeordneten LinearLayout ausrichtet. Beispiel: Ein Button mit layout_gravity="right" in einem VERTICAL-Layout drückt den Button an den rechten Rand.

Der Unterschied: gravity — eine Eigenschaft des Eltern-Elements (wie Kinder darin angeordnet sind), layout_gravity — eine Eigenschaft des Kindes (wie es sich innerhalb des Eltern-Elements verhält). Diese Attribute zu verwechseln, ist einer der häufigsten Fehler bei Anfängern.

Baseline-Ausrichtung

Für HORIZONTAL-Layouts mit Textelementen (TextView, Button, EditText) ist android:baselineAligned="true" nützlich — es richtet alle Texte an der Grundlinie der Schriftart aus, unabhängig von Padding, Größe oder Höhe. Dies macht eine Zeile mit Symbol, Titel und Beschreibung visuell ordentlich: Der Text springt nicht auf und ab.

layout_weight: Gewichtsverteilung

layout_weight — ein Attribut des Kind-Elements von LinearLayout, das bestimmt, welchen Anteil des freien Raums es einnimmt. Es funktioniert nur in der Ausrichtungsrichtung (Breite bei HORIZONTAL, Höhe bei VERTICAL). Berechnungsformel: Größe = eigene Größe + (freier Raum × (Elementgewicht / Summe aller Gewichte)). Freier Raum = Größe des Eltern-Elements — Summe aller eigenen Größen der Kinder.

layout_weight ist effizienter als feste Größen für adaptive Oberflächen. Wenn beispielsweise das linke Panel 30% des Bildschirms und das rechte 70% einnehmen soll, setzen Sie weight=3 und weight=7. Für korrekte Funktion wird die Größe in der Richtung normalerweise auf 0dp gesetzt (android:layout_width="0dp" für HORIZONTAL), dann wird die eigene Größe des Elements als Null betrachtet, und die gesamte Größe wird nur durch weight bestimmt. Dies ist die Standardempfehlung von Google (Android Developers Guide, 2024).

Wichtig: Gewichte werden für alle Elemente in LinearLayout summiert, einschließlich derer ohne festgelegtes weight (ihr Gewicht wird als 0 betrachtet). Wenn ein Element weight=1 und ein anderes weight=2 hat, nimmt das erste 1/3 des freien Raums ein, das zweite — 2/3. weightSum (ein Attribut des Eltern-Elements) ermöglicht die Festlegung der maximalen Gewichtssumme — wenn die Summe der Kind-Gewichte kleiner als weightSum ist, bleibt die Differenz als leerer Raum.

Code-Beispiele: XML-Layouts

Beispiel 1: Vertikales Formular mit weight

Das Login-Formular besteht aus drei Elementen: E-Mail-Feld (nimmt 2/4 der Bildschirmhöhe ein), Passwortfeld (1/4) und Button (1/4). Alle drei Elemente mit weight funktionieren nur in VERTICAL-Ausrichtung nach Höhe.

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

    <EditText
        android:id="@+id/email"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="2"
        android:hint="Email" />

    <EditText
        android:id="@+id/password"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:hint="Passwort"
        android:inputType="textPassword" />

    <Button
        android:id="@+id/login_button"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:text="Anmelden" />

</LinearLayout>

Die Höhe jedes Elements = (parent_height — padding) × (weight / sumWeights). email erhält 2/4 der Höhe, Passwort und Button — jeweils 1/4. Alle height=0dp, daher wird die eigene Größe nicht berücksichtigt — nur weight funktioniert.

Beispiel 2: Horizontale Symbolleiste

Ein Panel mit drei Schaltflächen: Zurück-Symbol (wrap_content), Titel (Rest ausfüllen) und Menü-Symbol (wrap_content). weight für Titel = 1, Schaltflächen ohne weight.

<LinearLayout
    android:orientation="horizontal"
    android:layout_width="match_parent"
    android:layout_height="56dp"
    android:gravity="center_vertical">

    <ImageButton
        android:id="@+id/btn_back"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/ic_arrow_back" />

    <TextView
        android:id="@+id/toolbar_title"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="Titel"
        android:textSize="18sp" />

    <ImageButton
        android:id="@+id/btn_menu"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/ic_more_vert" />

</LinearLayout>

Die Zurück- und Menü-Schaltflächen nehmen genau so viel Platz ein, wie für das Symbol benötigt wird. Der Titel (TextView) mit width=0dp und weight=1 dehnt sich auf den gesamten verbleibenden Raum zwischen ihnen aus. gravity="center_vertical" zentriert alle Elemente vertikal.

Beispiel 3: Verschachteltes LinearLayout für eine komplexe Karte

Eine Produktkarte: horizontale Zeile (Bild + vertikaler Textblock). Äußeres LinearLayout HORIZONTAL, inneres — VERTICAL für Titel, Beschreibung und Preis.

<LinearLayout
    android:orientation="horizontal"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:padding="8dp">

    <ImageView
        android:layout_width="80dp"
        android:layout_height="80dp"
        android:src="@drawable/product_image"
        android:scaleType="centerCrop" />

    <LinearLayout
        android:orientation="vertical"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:layout_marginStart="12dp">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Produktname"
            android:textStyle="bold"
            android:textSize="16sp" />

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Kurze Produktbeschreibung in zwei Zeilen"
            android:textSize="14sp"
            android:textColor="@color/gray" />

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="1.299 RUB"
            android:textSize="18sp"
            android:textColor="@color/accent" />

    </LinearLayout>

</LinearLayout>

Bild links (80×80dp), rechts — ein vertikaler Block mit drei Textzeilen. Das innere LinearLayout hat weight=1, nimmt also den gesamten verbleibenden Platz nach dem Bild ein. Dies ist ein klassisches Listenkartenmuster, das in Tausenden von Apps zu finden ist.

Das Verschachtelungsproblem und Alternativen

Der Hauptnachteil von LinearLayout — die Notwendigkeit verschachtelter Container für komplexe Layouts. Wenn Sie Elemente in einem 2×2-Raster anordnen oder eine Zeile mit Ausrichtung an beiden Rändern erstellen müssen, sind mindestens 2–3 Verschachtelungsebenen erforderlich. Jede LinearLayout-Ebene fügt 2 onMeasure-Durchläufe hinzu, was auf schwachen Geräten zu spürbaren Verzögerungen beim Rendern führt.

Laut Android Performance Blog (Google, 2017) erhöht jede zusätzliche Verschachtelungsebene die Layout-Zeit um 30–50 μs. Bei einer Liste von 20 Elementen mit 3 Verschachtelungsebenen kann die Verzögerung 3 ms pro Element erreichen — dies ist ein spürbares Ruckeln beim Scrollen. ConstraintLayout löst dieses Problem durch eine flache Hierarchie, indem es 3–4 verschachtelte LinearLayouts durch einen einzigen Constraint-Container ersetzt.

Empfehlung: Verwenden Sie LinearLayout für einfache lineare Layouts (bis zu 10 Elemente, eine Verschachtelungsebene). Für Listenkarten, Formulare mit unterschiedlicher Ausrichtung und Bildschirme mit Tabellenstruktur wählen Sie ConstraintLayout. Für sich wiederholende Elemente in RecyclerView verwenden Sie ConstraintLayout in der Element-Layout-Datei — dies ist entscheidend für die Scroll-Leistung.