Introduction à cette section

Cette section commence par aborder les mises en page dans Android. Il existe six mises en page principales dans Android : LinearLayout (mise en page linéaire), RelativeLayout (mise en page relative), TableLayout (mise en page de tableau), FrameLayout (mise en page par cadre), AbsoluteLayout (mise en page absolue) et GridLayout (mise en page en grille). Aujourd'hui, nous allons expliquer la première mise en page, LinearLayout. Dans l'adaptation d'écran, la fonctionnalité la plus couramment utilisée est la propriété weight de LinearLayout. Dans cette section, nous analyserons LinearLayout en détail, y compris certains attributs de base, l'utilisation de la propriété weight et la manière dont les proportions sont calculées. De plus, nous mentionnerons également un attribut moins fréquemment utilisé : android:divider pour tracer des lignes de séparation.


1. Schéma d'apprentissage de cette section


2. Explication détaillée de la propriété weight :

① Utilisation la plus simple :

Comme le montre la figure :

Code d'implémentation :

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

Pour obtenir le premier effet 1:1, il vous suffit de définir respectivement le weight des deux LinearLayouts sur 1 et 1. Résumé de l'utilisation : Pour diviser proportionnellement dans le sens horizontal : définissez l'attribut android:width des Views concernées sur 0dp, puis définissez l'attribut android:weight pour spécifier la proportion. De même, pour le sens vertical, définissez simplement android:height sur 0dp, puis définissez l'attribut weight. Vous pouvez écrire vous-même une division proportionnelle verticale pour découvrir cette utilisation simple !

② Explication détaillée de la propriété weight :

Bien sûr, si nous n'utilisons pas la méthode ci-dessus consistant à définir 0dp et utilisons directement wrap_content ou match_parent, alors nous devons analyser plus en détail la propriété weight. Il y a deux cas : wrap_content et match_parent ! De plus, nous devons aussi regarder si l'orientation du LinearLayout est horizontale ou verticale, car cela détermine dans quelle direction la division proportionnelle est appliquée.

1) wrap_content est plus simple ; il est directement divisé proportionnellement.

Code d'implémentation :

<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) : cela nécessite un calcul.

Écrivons ce simple bout de code :

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

Capture d'écran du résultat d'exécution :

À ce stade, vous vous posez peut-être des questions : pourquoi est-ce ainsi ? Le rapport semble être de 2:1, non ? Alors où est passé « three » ? Le code contient clairement « three », et il est défini à 3. De plus, le rapport entre 1 et 2 est faux : 1:2:3 est devenu 2:1:0. Comment cela s'est-il produit ? Réponse : ce n'est en fait pas si simple ici ; nous devons encore calculer. Il existe plusieurs algorithmes donnés en ligne. Je vais présenter ici celui que l'auteur trouve plus facile à comprendre :étape 1 :Chaque élément est fill_parent, mais il n'y a qu'un seul écran, donc 1 - 3 = -2 fill_parent.étape 2 :Les proportions sont respectivement 1/6, 2/6, 3/6.étape 3 :Premier arrivé, premier servi. Donnez d'abord à « one » : calculez 1 - 2 * (1/6) = 2/3 fill_parent. Ensuite à « two » : calculez 1 - 2 * (2/6) = 1/3 fill_parent. Enfin à « three » : calculez 1 - 2 * (3/6) = 0 fill_parent.étape 4 :Le résultat final est donc : « one » prend deux parts, « two » prend une part, et « three » ne reçoit rien du tout. C'est pourquoi « three » n'apparaît pas. Vous êtes peut-être encore un peu perplexe après avoir lu ceci. Ce n'est pas grave, essayons encore quelques exemples et vous comprendrez !

Le rapport est 1:1:1.

Calculez une fois selon la méthode ci-dessus ; le résultat est 1/3 1/3 1/3, c'est exact.

Ensuite, essayons 2:3:4.

Résultat du calcul : 5/9 3/9 1/9. En comparant avec la capture d'écran de l'effet, 5:3:1, c'est aussi correct. Vous devriez donc noter cette méthode de calcul !

③ Définition de la propriété weight dans le code Java :

setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT,     
        LayoutParams.WRAP_CONTENT, 1)); 

3. Définition d'un séparateur pour LinearLayout

Dans de nombreux projets de développement d'UI, on définit des soulignements ou des séparateurs pour rendre l'interface plus propre et plus belle, comme la page d'inscription de Kugou Music ci-dessous :

Pour ce genre de ligne, nous avons généralement deux approches :① Ajouter directement une View dans la mise en pageCette View sert uniquement à afficher une ligne, et le code est également très simple :

<View  
    android:layout_width="match_parent"  
    android:layout_height="1px"  
    android:background="#000000" />  

Il s'agit d'une ligne noire horizontale. Bien sûr, vous pouvez aussi la changer pour d'autres couleurs ou utiliser une image.

② La seconde approche consiste à utiliser la propriété divider de LinearLayout,qui définit directement un séparateur pour le LinearLayout. Ici, vous devez préparer vous-même une image de ligne. 1) android:divider : définir l'image utilisée comme séparateur. 2) android:showDividers : définir la position des séparateurs : none (aucun), beginning (début), end (fin), middle (entre chaque paire de composants). 3) dividerPadding : définir le padding du séparateur.

Exemple d'utilisation :

Code d'implémentation :

<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. Exemples simples de LinearLayout :

Le code d'implémentation est le suivant :

<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. Remarques :

Un problème très important avec l'utilisation de layout_gravity !!! Question : Dans un LinearLayout horizontal, il y a deux TextView. Vous en voulez un à gauche et un à droite. Comment faire ? Peut-être vous exclameriez-vous : « Réglez gravity à left pour l'un et à right pour l'autre, et c'est tout ! » Est-ce vraiment aussi simple ? L'avez-vous essayé ? Écrivez un layout simple et vous constaterez que les choses tournent contrairement à vos souhaits : Le code est le suivant :

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

Capture d'écran du résultat d'exécution :

En voyant cela, vous diriez : Oh, ça ne marche vraiment pas. Et si on ajoutait un attribut gravity="left" au LinearLayout externe, puis qu'on réglait le layout_gravity du second TextView sur right ? Bon, essayons :

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

Le résultat est toujours le même :

Eh bien, on ne peut pas y échapper. Que devrions-nous faire ?

Lorsque android:orientation="vertical", seuls les paramètres d'alignement horizontal prennent effet ; les paramètres d'alignement vertical ne prennent pas effet. C'est-à-dire : left, right, center_horizontal sont effectifs. Lorsque android:orientation="horizontal", seuls les paramètres d'alignement vertical prennent effet ; les paramètres d'alignement horizontal ne prennent pas effet. C'est-à-dire : top, bottom, center_vertical sont effectifs.

Cependant, cette méthode semble ne servir à rien. Par exemple : Si seule la direction verticale peut être utilisée pour définir l'alignement left/right, l'effet suivant apparaîtra :

Ce n'est manifestement pas le résultat que nous voulons ! En résumé, soit on met en page selon les règles données ci-dessus, mais dans ce cas il vaut mieux utiliser RelativeLayout ! Internet ne donne pas de raison précise ; les gens disent simplement de changer de cette façon, et certains disent que c'est lié à la priorité de l'orientation. Notons-le pour l'instant et expliquerons plus tard si nous en connaissons la raison ! Comme mentionné précédemment dans la section d'adaptation d'écran,il est toujours recommandé d'utiliser RelativeLayout pour la mise en page !