Introducción a esta sección
Esta sección comienza a hablar sobre los layouts en Android. Hay seis layouts principales en Android, que son: LinearLayout (Linear Layout), RelativeLayout (Relative Layout), TableLayout (Table Layout), FrameLayout (Frame Layout), AbsoluteLayout (Absolute Layout), GridLayout (Grid Layout). Y hoy vamos a explicar el primer layout, LinearLayout (Linear Layout). En la adaptación de pantalla, el más utilizado es el atributo weight (peso) de LinearLayout. En esta sección, analizaremos en detalle LinearLayout, incluyendo algunos atributos básicos, el uso del atributo weight y cómo calcular las proporciones. Además, mencionaremos un atributo menos utilizado: android:divider para dibujar una línea subrayada.
1. Diagrama de estudio de esta sección

2. Explicación detallada del atributo weight (peso):
① El uso más simple:
Como se muestra en la figura:


Código de implementación:
<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>
Para lograr el efecto 1:1 del primero, solo necesitas cambiar el weight de los dos LinearLayout a 1 y 1 respectivamente. Resumen de uso: Para dividir proporcionalmente en dirección horizontal: establece el atributo android:width de las Views involucradas en 0dp, y luego usa el atributo android:weight para establecer la proporción. De manera similar, en dirección vertical, solo necesitas establecer android:height en 0dp y luego definir el atributo weight. ¡Puedes escribir un ejemplo de división equitativa en dirección vertical para experimentar el uso simple!
② Explicación detallada del atributo weight:
Por supuesto, si no usamos el método mencionado de establecer 0dp, sino que usamos directamente wrap_content y match_parent, entonces debemos analizar el atributo weight. Hay dos casos: wrap_content y match_parent. Además, hay que tener en cuenta si la orientación de LinearLayout es horizontal o vertical, ya que esto determina en qué dirección se dividirá proporcionalmente.
1) wrap_content es más simple, directamente se divide en proporción.

Código de implementación:
<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): este caso requiere cálculo.
Escribimos este código simple:
<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>
Imagen del resultado de ejecución:

En este momento surgirá la duda: ¿cómo puede ser esto? La proporción es 2:1, ¿dónde está three? En el código claramente está three, e incluso se estableció en 3. Además, la proporción de 1 y 2 tampoco es correcta; 1:2:3 se convierte en 2:1:0. ¿Cómo puede ser? Respuesta: En realidad, no es tan simple; necesitamos calcular. Hay varios algoritmos en Internet. Aquí presentaré uno que el autor considera más fácil de entender:step 1:Cada uno es fill_parent, pero solo hay una pantalla, entonces 1 - 3 = -2 fill_parentstep 2:Las proporciones en orden son 1/6, 2/6, 3/6step 3:Por orden de llegada, primero se asigna a one, cálculo: 1 - 2 * (1/6) = 2/3 fill_parent Luego a two, cálculo: 1 - 2 * (2/6) = 1/3 fill_parent Finalmente a three, cálculo: 1 - 2 * (3/6) = 0 fill_parentstep 4:Entonces el resultado final es: one ocupa dos partes, two ocupa una parte, three no ocupa nada. Lo anterior es la razón por la cual three no aparece. Quizás después de leerlo sigáis un poco confundidos, no pasa nada, ¡veamos algunos ejemplos más para entenderlo!
Proporción: 1:1:1

Siguiendo el método de cálculo anterior una vez, el resultado es: 1/3 1/3 1/3, correcto.
A continuación, probemos con: 2:3:4

Resultado del cálculo: 5/9 3/9 1/9. Comparando con la imagen del efecto, 5:3:1, también es correcto. ¡Así que debes marcar este método de cálculo!
③ Configurar el atributo weight en código Java:
setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT,
LayoutParams.WRAP_CONTENT, 1));
3. Establecer una línea divisoria para LinearLayout
En el desarrollo de muchas interfaces se suelen usar subrayados o líneas divisorias para que la interfaz sea más ordenada y bonita, por ejemplo, la página de registro de Kugou Music a continuación:

Para este tipo de líneas, normalmente tenemos dos métodos:① Agregar directamente una vista (view) en el layout, la función de esta view es solo mostrar una línea, y el código también es muy simple:
<View
android:layout_width="match_parent"
android:layout_height="1px"
android:background="#000000" />
Esta es una línea negra en dirección horizontal. Por supuesto, también puedes cambiar a otros colores o usar una imagen.

② El segundo método es usar el atributo divider de LinearLayout, estableciendo directamente la línea divisoria para LinearLayout. Aquí necesitas preparar una imagen de línea tú mismo. 1) android:divider establece la imagen como línea divisoria. 2) android:showDividers establece la posición de la línea divisoria: none (ninguna), beginning (principio), end (final), middle (entre cada dos componentes). 3) dividerPadding establece el padding de la línea divisoria.
Ejemplo de uso:

Código de implementación:
<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. Ejemplo simple de LinearLayout:

El código de implementación es el siguiente:
<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. Notas:
¡¡¡Un problema muy importante con el uso de Layout_gravity!!! Contenido del problema: En un LinearLayout con orientación horizontal, coloca dos TextView. Quieres que uno esté a la izquierda y el otro a la derecha. ¿Cómo se hace? Quizás dirás sin pensar: "¡Configura gravity uno a la izquierda (left) y el otro a la derecha (right)!" ¿Es realmente tan simple? ¿Lo has probado? Si escribes un Layout simple, descubrirás que no sale como esperabas: El código es el siguiente:
<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>
Imagen del resultado de ejecución:

Al ver esto dirás: "Vaya, realmente no funciona. ¿Qué tal si añadimos el atributo gravity=left al LinearLayout externo y luego establecemos el layout_gravity del segundo TextView en right? Bien, probemos:"
<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>
El resultado sigue siendo el mismo:

Bien, no hay manera, ¿qué hacemos?
Cuando android:orientation="vertical", solo tienen efecto las configuraciones en dirección horizontal; las configuraciones en dirección vertical no tienen efecto. Es decir: left, right, center_horizontal son efectivos. Cuando android:orientation="horizontal", solo tienen efecto las configuraciones en dirección vertical; las configuraciones en dirección horizontal no tienen efecto. Es decir: top, bottom, center_vertical son efectivos.
Sin embargo, este método parece no servir de mucho. Por ejemplo: Si solo se puede establecer la alineación izquierda/derecha en la dirección vertical, aparecerá el siguiente efecto:

¡Evidentemente esto no es el resultado que queremos! En resumen, o bien se sigue las reglas dadas anteriormente para el layout, pero para este caso es mejor usar el RelativeLayout (Relative Layout). En Internet no se da una razón concreta; todos dicen que se cambia así, y algunos dicen que esto está relacionado con la prioridad de orientation. Por ahora, marquémoslo (mark) y si más adelante sabemos el motivo, lo explicaremos. Antes, en la adaptación de pantalla, también se mencionó:Para el layout, se recomienda usar RelativeLayout!