Einführung in diesen Abschnitt
Dieser Abschnitt beginnt mit der Diskussion von Layouts in Android. Es gibt sechs wichtige Layouts in Android: LinearLayout (lineares Layout), RelativeLayout (relatives Layout), TableLayout (Tabellen-Layout), FrameLayout (Frame-Layout), AbsoluteLayout (absolutes Layout) und GridLayout (Grid-Layout). Heute werden wir das erste Layout erklären, LinearLayout. Bei der Bildschirmanpassung ist die am häufigsten verwendete Funktion die weight-Eigenschaft von LinearLayout. In diesem Abschnitt werden wir LinearLayout im Detail analysieren, einschließlich einiger grundlegender Attribute, der Verwendung der weight-Eigenschaft und der Berechnung von Proportionen. Darüber hinaus erwähnen wir auch ein seltener verwendetes Attribut: android:divider zum Zeichnen von Trennlinien.
1. Lerndiagramm für diesen Abschnitt

2. Detaillierte Erklärung der weight-Eigenschaft:
① Einfachste Verwendung:
Wie in der Abbildung gezeigt:


Implementierungscode:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/LinearLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="horizontal">
<LinearLayout
android:layout_width="0dp"
android:layout_height="fill_parent"
android:background="#2F97FF"
android:layout_weight="1"/>
<LinearLayout
android:layout_width="0dp"
android:layout_height="fill_parent"
android:background="#DA70D6"
android:layout_weight="2"/>
</LinearLayout>
Um den ersten 1:1-Effekt zu erzielen, musst du nur die weight-Eigenschaft der beiden LinearLayouts jeweils auf 1 und 1 setzen. Zusammenfassung der Verwendung: Um in horizontaler Richtung proportional zu unterteilen: Setze das android:width-Attribut der beteiligten Views auf 0dp, dann setze das android:weight-Attribut, um das Verhältnis anzugeben. Ähnlich für die vertikale Richtung: Setze einfach android:height auf 0dp, dann setze das weight-Attribut. Du kannst selbst eine vertikale proportionale Unterteilung schreiben, um diese einfache Verwendung auszuprobieren!
② Ausführliche Erklärung der weight-Eigenschaft:
Wenn wir natürlich nicht die oben beschriebene Methode verwenden, 0dp festzulegen, und direkt wrap_content oder match_parent benutzen, müssen wir die weight-Eigenschaft genauer analysieren. Es gibt zwei Fälle: wrap_content und match_parent! Außerdem müssen wir auch betrachten, ob die orientation des LinearLayout horizontal oder vertikal ist, denn das bestimmt, in welche Richtung die proportionale Aufteilung angewendet wird.
1) wrap_content ist einfacher; es wird direkt proportional aufgeteilt.

Implementierungscode:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/LinearLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="horizontal" >
<TextView
android:layout_weight="1"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:text="one"
android:background="#8AC3FB"
/>
<TextView
android:layout_weight="2"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:text="two"
android:background="#FFFF00"
/>
<TextView
android:layout_weight="3"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:text="three"
android:background="#FF00FF"
/>
</LinearLayout>
2) match_parent (fill_parent): Hier ist eine Berechnung erforderlich.
Schreiben wir dieses einfache Codestück:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/LinearLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent" >
<TextView
android:layout_weight="1"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:text="one"
android:background="#8AC3FB"
/>
<TextView
android:layout_weight="2"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:text="two"
android:background="#FFFF00"
/>
<TextView
android:layout_weight="3"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:text="three"
android:background="#FF00FF"
/>
</LinearLayout>
Screenshot des Ausführungsergebnisses:

An dieser Stelle hast du vielleicht Fragen: Warum ist das so? Das Verhältnis scheint doch 2:1 zu sein, oder? Wo ist also die "three" geblieben? Der Code enthält eindeutig "three", und es ist auf 3 gesetzt. Außerdem stimmt das Verhältnis zwischen 1 und 2 nicht: 1:2:3 ist zu 2:1:0 geworden. Wie konnte das passieren? Antwort: Hier ist es tatsächlich nicht so einfach; wir müssen noch rechnen. Es gibt mehrere online angegebene Algorithmen. Hier stelle ich den vor, den der Autor leichter zu verstehen findet:Schritt 1:Jedes einzelne ist fill_parent, aber es gibt nur einen Bildschirm, also 1 - 3 = -2 fill_parent.Schritt 2:Die Anteile sind jeweils 1/6, 2/6, 3/6.Schritt 3:Wer zuerst kommt, mahlt zuerst. Zuerst an "one": berechne 1 - 2 * (1/6) = 2/3 fill_parent. Dann an "two": berechne 1 - 2 * (2/6) = 1/3 fill_parent. Schließlich an "three": berechne 1 - 2 * (3/6) = 0 fill_parent.Schritt 4:Das Endergebnis ist also: "one" bekommt zwei Anteile, "two" bekommt einen Anteil und "three" bekommt überhaupt nichts. Deshalb erscheint "three" nicht. Vielleicht bist du nach dem Lesen noch etwas verwirrt. Kein Problem, probieren wir noch ein paar Beispiele aus, dann wirst du es verstehen!
Das Verhältnis ist 1:1:1.

Rechne einmal nach der obigen Methode; das Ergebnis ist 1/3 1/3 1/3, das stimmt.
Als Nächstes probieren wir 2:3:4.

Berechnungsergebnis: 5/9 3/9 1/9. Vergleicht man es mit dem Effekt-Screenshot, 5:3:1, ist es ebenfalls korrekt. Also solltest du diese Berechnungsmethode notieren!
③ Die weight-Eigenschaft im Java-Code festlegen:
setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT,
LayoutParams.WRAP_CONTENT, 1));
3. Einen Divider für LinearLayout festlegen
In vielen UI-Entwicklungsprojekten werden einige Unterstreichungen oder Trennlinien gesetzt, um die Oberfläche sauberer und schöner zu machen, wie zum Beispiel die untenstehende Registrierungsseite von Kugou Music:

Für diese Art von Linie haben wir normalerweise zwei Ansätze:① Füge direkt eine View im Layout hinzuDiese View dient nur dazu, eine Linie anzuzeigen, und der Code ist auch sehr einfach:
<View
android:layout_width="match_parent"
android:layout_height="1px"
android:background="#000000" />
Dies ist eine horizontale schwarze Linie. Natürlich kannst du sie auch in andere Farben ändern oder ein Bild verwenden.

② Der zweite Ansatz ist, die divider-Eigenschaft von LinearLayout zu verwenden,womit direkt ein Divider für das LinearLayout festgelegt wird. Hier musst du selbst ein Bild einer Linie vorbereiten. 1) android:divider: Legt das als Divider verwendete Bild fest. 2) android:showDividers: Legt die Position der Divider fest: none (keine), beginning (Anfang), end (Ende), middle (zwischen jeweils zwei Komponenten). 3) dividerPadding: Legt den Padding des Dividers fest.
Anwendungsbeispiel:

Implementierungscode:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/LinearLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:divider="@drawable/ktv_line_div"
android:orientation="vertical"
android:showDividers="middle"
android:dividerPadding="10dp"
tools:context="com.jay.example.linearlayoutdemo.MainActivity" >
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="按钮1" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="按钮2" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="按钮3" />
</LinearLayout>
4. Einfache Beispiele für LinearLayout:

Der Implementierungscode lautet wie folgt:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/LinearLayout1"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical"
tools:context=".MainActivity" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="请输入要保存的电话号码"/>
<EditText
android:layout_width="fill_parent"
android:layout_height="wrap_content"/>
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:gravity="right">
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="保存"/>
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="清空"/>
</LinearLayout>
</LinearLayout>
5. Hinweise:
Ein sehr wichtiges Problem bei der Verwendung von layout_gravity!!! Frage: In einem horizontalen LinearLayout gibt es zwei TextViews. Du möchtest eines links und eines rechts. Wie machst du das? Vielleicht würdest du herausplatzen: "Setze gravity für das eine auf left und für das andere auf right, und das war's!" Ist es wirklich so einfach? Hast du es ausprobiert? Schreibe ein einfaches Layout und du wirst feststellen, dass es anders kommt als gewünscht: Der Code lautet wie folgt:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="horizontal"
tools:context="com.jay.example.getscreendemo.MainActivity" >
<TextView
android:layout_width="wrap_content"
android:layout_height="200dp"
android:layout_gravity="left"
android:background="#FF7878"
android:gravity="center"
android:text="O(∩_∩)O哈哈~" />
<TextView
android:layout_width="wrap_content"
android:layout_height="200dp"
android:layout_gravity="right"
android:background="#FF7428"
android:gravity="center"
android:text="(*^__^*) 嘻嘻……" />
</LinearLayout>
Screenshot des Ausführungsergebnisses:

Wenn du das siehst, würdest du sagen: Oh, es funktioniert wirklich nicht. Wie wäre es, dem äußeren LinearLayout ein gravity="left"-Attribut hinzuzufügen und dann layout_gravity des zweiten TextView auf right zu setzen? Okay, versuchen wir es:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="horizontal"
android:gravity="left"
tools:context="com.jay.example.getscreendemo.MainActivity" >
<TextView
android:layout_width="wrap_content"
android:layout_height="200dp"
android:background="#FF7878"
android:gravity="center"
android:text="O(∩_∩)O哈哈~" />
<TextView
android:layout_width="wrap_content"
android:layout_height="200dp"
android:layout_gravity="right"
android:background="#FF7428"
android:gravity="center"
android:text="(*^__^*) 嘻嘻……" />
</LinearLayout>
Das Ergebnis ist immer noch dasselbe:

Nun, daran führt kein Weg vorbei. Was sollen wir tun?
Wenn android:orientation="vertical", wirken nur horizontale Ausrichtungseinstellungen; vertikale Ausrichtungseinstellungen wirken nicht. Das heißt: left, right, center_horizontal sind wirksam. Wenn android:orientation="horizontal", wirken nur vertikale Ausrichtungseinstellungen; horizontale Ausrichtungseinstellungen wirken nicht. Das heißt: top, bottom, center_vertical sind wirksam.
Diese Methode scheint jedoch nutzlos zu sein. Zum Beispiel: Wenn nur die vertikale Richtung verwendet werden kann, um die linke/rechte Ausrichtung festzulegen, tritt der folgende Effekt auf:

Das ist offensichtlich nicht das Ergebnis, das wir wollen! Zusammenfassend: Entweder gestaltet man das Layout nach den oben genannten Regeln, aber für diesen Fall ist es besser, RelativeLayout zu verwenden! Das Internet gibt keinen konkreten Grund an; die Leute sagen einfach, man solle es so ändern, und einige sagen, es hänge mit der Priorität der Ausrichtung zusammen. Merken wir es uns vorerst und erklären es später, wenn wir den Grund kennen! Wie bereits im Abschnitt zur Bildschirmanpassung erwähnt,Es wird weiterhin empfohlen, RelativeLayout für das Layout zu verwenden!