Ich weiß, dass wir die folgenden Werte für die Eigenschaften android:gravityund festlegen können android:layout_gravity:

1. center
2. center_vertical
3. center_horizontal, usw.

Aber ich bin in Bezug auf beide verwirrt.

Was ist der Unterschied zwischen der Verwendung von android:gravityund android:layout_gravity?

Ihre Namen sollten Ihnen helfen:

• android:gravityLegt die Schwerkraft des Inhalts (dh seiner Unteransichten) des Inhalts fest, auf dem Viewer verwendet wird.
• android:layout_gravityLegt die Schwerkraft des Viewoder Layoutrelativ zu seinem Elternteil fest.

Und ein Beispiel ist hier .

Innen Außen

• gravityordnet den Inhalt in der Ansicht an.
• layout_gravityordnet die Position der Ansicht außerhalb von sich selbst an.

Manchmal hilft es auch, ein Bild zu sehen. Das Grün und Blau sind TextViewsund die anderen beiden Hintergrundfarben sind LinearLayouts.

Anmerkungen

• Das layout_gravityfunktioniert nicht für Ansichten in a RelativeLayout. Verwenden Sie es für Ansichten in einem LinearLayoutoder FrameLayout. Weitere Einzelheiten finden Sie in meiner ergänzenden Antwort .
• Die Breite (oder Höhe) der Ansicht muss größer sein als der Inhalt. Sonst gravityhat das keine Wirkung. Also wrap_contentund gravitysind zusammen bedeutungslos.
• Die Breite (oder Höhe) der Ansicht muss kleiner als die der übergeordneten Ansicht sein. Sonst layout_gravityhat das keine Wirkung. Also match_parentund layout_gravitysind zusammen bedeutungslos.
• Das layout_gravity=centersieht genauso aus wie layout_gravity=center_horizontalhier, da sie sich in einem vertikalen linearen Layout befinden. In diesem Fall können Sie nicht vertikal layout_gravity=centerzentrieren, sondern nur horizontal zentrieren.
• Diese Antwort befasste sich nur mit der Einstellung gravityund layout_gravityden Ansichten innerhalb eines Layouts. Um zu sehen, was passiert, wenn Sie gravitydas übergeordnete Layout selbst festlegen , lesen Sie die ergänzende Antwort , auf die ich oben Bezug genommen habe. (Zusammenfassung: gravityfunktioniert bei a nicht gut RelativeLayout, kann aber bei a nützlich seinLinearLayout .)

Denken Sie also daran, dass layout _gravity eine Ansicht in seinem Layout anordnet . Die Schwerkraft ordnet den Inhalt in der Ansicht an.

xml

Hier ist die XML für das obige Bild als Referenz:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="#e3e2ad"
        android:orientation="vertical" >

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:textSize="24sp"
            android:text="gravity=" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#bcf5b1"
            android:gravity="left"
            android:text="left" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#aacaff"
            android:gravity="center_horizontal"
            android:text="center_horizontal" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#bcf5b1"
            android:gravity="right"
            android:text="right" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:background="#aacaff"
            android:gravity="center"
            android:text="center" />

    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        android:background="#d6c6cd"
        android:orientation="vertical" >

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:textSize="24sp"
            android:text="layout_gravity=" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="left"
            android:background="#bcf5b1"
            android:text="left" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="center_horizontal"
            android:background="#aacaff"
            android:text="center_horizontal" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="right"
            android:background="#bcf5b1"
            android:text="right" />

        <TextView
            android:layout_width="200dp"
            android:layout_height="40dp"
            android:layout_gravity="center"
            android:background="#aacaff"
            android:text="center" />

    </LinearLayout>

</LinearLayout>

verbunden

• Unterschied zwischen Polsterung und Rand einer Ansicht
• Match_parent vs wrap_content
• So stellen Sie die Schwerkraft und die Layout-Schwerkraft eines LinearLayout programmgesteuert ein

Der Unterschied

android:layout_gravityist die äußere Schwerkraft der Ansicht. Gibt die Richtung an, in die die Ansicht den Rand des übergeordneten Elements berühren soll.

android:gravityist die innere Schwerkraft dieser Ansicht. Gibt an, in welche Richtung der Inhalt ausgerichtet werden soll.

HTML / CSS-Entsprechungen

Android                 | CSS
————————————————————————+————————————
android:layout_gravity  | float
android:gravity         | text-align

Einfacher Trick, der Ihnen hilft, sich zu erinnern

Nehmen Sie layout-gravityals "Lay-außerhalb-Schwerkraft".

Kurze Antwort: Verwenden android:gravityoder setGravity()steuern Sie die Schwerkraft aller untergeordneten Ansichten eines Containers. Verwenden android:layout_gravityoder setLayoutParams()steuern Sie die Schwerkraft einer einzelnen Ansicht in einem Container.

Lange Geschichte: Um die Schwerkraft in einem linearen Layout-Container wie LinearLayoutoder zu steuern RadioGroup, gibt es zwei Ansätze:

1) Um die Schwere ALLER untergeordneten Ansichten eines LinearLayoutContainers zu steuern (wie Sie es in Ihrem Buch getan haben), verwenden Sie android:gravity(nicht android:layout_gravity) die XML-Layoutdatei oder die setGravity()Methode im Code.

2) Verwenden Sie das android:layout_gravityXML-Attribut, um die Schwerkraft einer untergeordneten Ansicht in ihrem Container zu steuern . Im Code muss man LinearLayout.LayoutParamsdie Ansicht abrufen und ihre Schwerkraft einstellen. Hier ist ein Codebeispiel, mit dem eine Schaltfläche in einem horizontal ausgerichteten Container nach unten gesetzt wird:

import android.widget.LinearLayout.LayoutParams;
import android.view.Gravity;
...

Button button = (Button) findViewById(R.id.MyButtonId);
// need to cast to LinearLayout.LayoutParams to access the gravity field
LayoutParams params = (LayoutParams)button.getLayoutParams(); 
params.gravity = Gravity.BOTTOM;
button.setLayoutParams(params);

Bei horizontalen LinearLayoutContainern wird die horizontale Schwerkraft der untergeordneten Ansicht nacheinander linksbündig ausgerichtet und kann nicht geändert werden. Das Einstellen android:layout_gravityauf center_horizontalhat keine Auswirkung. Die standardmäßige vertikale Schwerkraft ist center (oder center_vertical) und kann nach oben oder unten geändert werden. Eigentlich ist der Standardwert layout_gravity, -1aber Android hat ihn vertikal zentriert.

Um die horizontalen Positionen von untergeordneten Ansichten in einem horizontalen linearen Container zu ändern, können Sie layout_weightdie untergeordnete Ansicht mit Rand und Abstand verwenden.

In ähnlicher Weise ist für den Container "Vertikale Ansichtsgruppe" die vertikale Schwerkraft der untergeordneten Ansicht oben untereinander ausgerichtet und kann nicht geändert werden. Die standardmäßige horizontale Schwerkraft ist der Mittelpunkt (odercenter_horizontal ) und kann nach links oder rechts geändert werden.

Tatsächlich verfügt eine untergeordnete Ansicht wie eine Schaltfläche auch über ein android:gravityXML-Attribut und die setGravity()Methode zur Steuerung ihrer untergeordneten Ansichten - den darin enthaltenen Text. Das Button.setGravity(int)ist mit diesem Eintrag von developer.android.com verknüpft .

Was ich aus layout_gravity entnehmen kann, ist die Schwerkraft dieser Ansicht in ihrem übergeordneten Element und die Schwerkraft ist die Schwerkraft der Kinder in dieser Ansicht.

Ich denke, das ist richtig, aber der beste Weg, dies herauszufinden, ist herumzuspielen.

Schauen Sie sich das Bild an, um die Schwerkraft zu erkennen

Wenn wir die Schwerkraft von Inhalten in einer Ansicht festlegen möchten, verwenden wir "android :vity", und wenn wir die Schwerkraft dieser Ansicht (als Ganzes) in ihrer übergeordneten Ansicht festlegen möchten, verwenden wir "android:": layout_gravity ".

Ich dachte nur, ich würde hier meine eigene Erklärung hinzufügen - vor dem Hintergrund von iOS habe ich die beiden in iOS-Begriffen verinnerlicht: "Layout Gravity" wirkt sich auf Ihre Position in der Übersicht aus. "Schwerkraft" beeinflusst die Position Ihrer Unteransichten in Ihnen. Anders gesagt, Layout Gravity positioniert Sie selbst, während Gravity Ihre Kinder positioniert.

Es gibt viele Unterschiede im gravityund layout-gravity. Ich werde meine Erfahrungen mit diesen beiden Konzepten erläutern ( alle Informationen, die ich aufgrund meiner Beobachtung und einiger Websites erhalten habe ).

Verwendung von Schwerkraft und Layout-Schwerkraft in FrameLayout.....

Hinweis:-

1. Die Schwerkraft wird im Ansichtsinhalt verwendet, da einige Benutzer eine Antwort haben, und sie ist für alle gleich ViewGroup Layout.

2. Layout-gravity wird mit der übergeordneten Ansicht verwendet, da einige Benutzer eine Antwort haben.

3. Gravity and Layout-gravityist die Arbeit mit den FrameLayoutKindern nützlicher . We can't use Gravity and Layout-gravityin FrameLayouts Tag ....

4. Wir können Child View überall dort einstellen, wo es FrameLayoutverwendet wird layout-gravity.

5. Wir können jeden einzelnen Wert der Schwerkraft im Innern des FrameLayout (zB: - center_vertical, center_horizontal, center, top, usw.), aber es ist nicht möglich , mit anderen Viewgroup Layouts.

6. FrameLayoutvoll arbeiten Layout-gravity. Beispiel: - Wenn Sie daran arbeiten, müssen FrameLayoutSie nicht das gesamte Layout ändern, um eine neue Ansicht hinzuzufügen. Sie fügen einfach Ansicht als letzte in der hinzu FrameLayoutund geben ihm Layout-gravityWert. ( Dies ist ein Vorteil der Layout-Schwerkraft mit FrameLayout ).

schau dir das Beispiel an ......

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="center"
        android:text="Center Layout Gravity"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#1b64b9"
        android:gravity="bottom"
        android:layout_gravity="bottom|center"
        android:text="Bottom Layout Gravity" />

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#d75d1c"
        android:gravity="top"
        android:layout_gravity="top|center"
        android:text="Top Layout Gravity"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="100dp"
        android:textColor="#d71f1c"
        android:gravity="top|right"
        android:layout_gravity="top|right"
        android:text="Top Right Layout Gravity"/>


    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="bottom"
        android:gravity="bottom"
        android:text="Top Left Layout Gravity"/>

</FrameLayout>

Ausgabe:-

Verwendung von Schwerkraft und Layout-Schwerkraft in LinearLayout .....

Gravityfunktioniert wie oben, aber hier ist der Unterschied, dass wir die Schwerkraft innerhalb der verwenden können LinearLayout Viewund RelativeLayout Viewwas in nicht möglich ist FrameLayout View.

LinearLayout mit vertikaler Ausrichtung ....

Hinweis: - Hier können wir nur 3 Werte davon einstellen layout_gravity( left| right| center(auch genannt center_horizontal)).

Schauen Sie sich das Beispiel an: -

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:orientation="vertical"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="center_horizontal"
        android:text="Center Layout Gravity \nor \nCenter_Horizontal"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="20dp"
        android:textColor="#d75d1c"
        android:layout_gravity="right"
        android:text="Right Layout Gravity"/>


    <TextView
        android:layout_width="wrap_content"
        android:layout_height="80dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="left"
        android:layout_marginTop="20dp"
        android:gravity="bottom"
        android:text="Left Layout Gravity"/>

</LinearLayout>

Ausgabe:-

LinearLayout mit horizontaler Ausrichtung ....

Hinweis: - Hier können wir auch 3 Werte davon einstellen layout_gravity( top| bottom| center(auch genannt center_vertical)).

Schauen Sie sich das Beispiel an: -

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:orientation="horizontal"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="120dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:textColor="#264bd1"
        android:gravity="center"
        android:layout_gravity="bottom"
        android:text="Bottom \nLayout \nGravity"/>

    <TextView
        android:layout_width="120dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginTop="20dp"
        android:textColor="#d75d1c"
        android:layout_gravity="center"
        android:text="Center \nLayout \nGravity"/>


    <TextView
        android:layout_width="150dp"
        android:layout_height="100dp"
        android:textSize="25dp"
        android:background="#000"
        android:layout_marginBottom="100dp"
        android:textColor="#d71cb2"
        android:layout_gravity="left"
        android:layout_marginTop="20dp"
        android:text="Left \nLayout \nGravity"/>

</LinearLayout>

Ausgabe:-

Hinweis: - Wir können nicht layout_gravityin der verwenden, RelativeLayout Viewsaber wir können verwenden gravity, um RelativeLayoutKinder auf die gleiche Position zu setzen ....

Ein einfacher Trick, um sich daran zu erinnern, dass die Schwerkraft auf uns in der Erde zutrifft. Also, android:gravityist für innerhalb der Ansicht.

Merken aus dem heraus in lay out _gravity , die Sie zu erinnern , dass würde helfen android:layout_gravitywürde sagen , dass außerhalb der Ansicht

Etwas, das ich auf Sandips Blog gesehen habe und das ich fast verpasst hätte, hat mein Problem behoben. Er sagte, layout_gravityarbeitet nicht mit LinearLayout.

Wenn Sie ein verwenden LinearLayoutund die Schwerkrafteinstellungen Sie verrückt machen (wie ich), wechseln Sie zu etwas anderem.

Ich wechselte tatsächlich zu einem RelativeLayoutdann verwendeten layout_alignParentLeftund layout_alignParentRightauf den 2 enthaltenen TextViews, um sie in einer Zeile ganz nach links und ganz rechts zu bringen.

Der grundlegende Unterschied zwischen den beiden ist, dass

android: Die Schwerkraft wird für untergeordnete Elemente der Ansicht verwendet.

android: layout_gravity wird für dieses Element in Bezug auf die übergeordnete Ansicht verwendet.

android:gravitywird verwendet, um anzugeben, wie der Inhalt des Objekts innerhalb des Objekts selbst platziert werden soll. Mit anderen Worten, Android: Schwerkraft wird verwendet, um die Schwerkraft des Inhalts der Ansicht anzugeben.

android:layout_gravity ist eine Zuschreibung, die das Kind seinem Elternteil geben kann, um die Schwerkraft der Ansicht innerhalb seiner Eltern zu spezifizieren.

Für weitere Details können Sie besuchen

http://developer.android.com/reference/android/widget/LinearLayout.LayoutParams.html

Schwerkraft: Ermöglicht das Verschieben des Inhalts in einen Container. (Wie Unteransichten platziert werden).

Wichtig: (BEWEGEN Sie sich innerhalb des verfügbaren Platzes entlang der X- oder Y-Achse).

Beispiel: Wenn Sie mit LinearLayout (Höhe: match_parent, Breite: match_parent) als Element auf Stammebene arbeiten, steht Ihnen der gesamte Frame-Speicherplatz zur Verfügung. In den untergeordneten Ansichten heißt es, dass 2 Textansichten (Höhe: wrap_content, Breite: wrap_content) innerhalb des LinearLayout entlang der x / y-Achse verschoben werden können, wobei entsprechende Werte für die Schwerkraft auf dem übergeordneten Element verwendet werden.

Layout_Gravity: Ermöglicht das Überschreiben des übergeordneten Schwerkraftverhaltens NUR entlang der x-Achse.

Wichtig: (BEWEGEN [Überschreiben] entlang der X-Achse innerhalb des verfügbaren Platzes).

Beispiel: Wenn Sie das vorherige Beispiel berücksichtigen, wissen wir, dass die Schwerkraft es uns ermöglicht hat, uns entlang der x / y-Achse zu bewegen, dh; die Stelle TextViews in LinearLayout. Sagen wir einfach, LinearLayout gibt die Schwerkraft an: center; Das bedeutet, dass jede Textansicht sowohl vertikal als auch horizontal zentriert sein muss. Wenn nun eine der Textansichten nach links / rechts verschoben werden soll, können wir das angegebene Schwerkraftverhalten mithilfe von layout_gravity in der Textansicht überschreiben.

Bonus: Wenn Sie tiefer graben, werden Sie feststellen, dass Text in der Textansicht als Unteransicht fungiert. Wenn Sie also die Schwerkraft auf TextView anwenden, bewegt sich der Text in der TextView. (das gesamte Konzept gilt auch hier)

Die Schwerkraft wird verwendet, um die Textausrichtung in Ansichten festzulegen, aber layout_gravity wird verwendet, um Ansichten selbst festzulegen. Nehmen wir ein Beispiel, wenn Sie in editText geschriebenen Text ausrichten und dann die Schwerkraft verwenden möchten und diesen editText oder eine beliebige Schaltfläche oder Ansicht ausrichten möchten, dann verwenden Sie layout_gravity. Es ist also sehr einfach.

Schwerkraft : wird für einfache Ansichten wie Textansicht, Edittext usw. verwendet.

layout_gravity : wird für die aktuelle Ansicht nur die Schwerkraft im Kontext der relativen übergeordneten Ansicht wie lineares Layout oder FrameLayout verwendet, um die Ansicht in der Mitte oder einer anderen Schwerkraft der übergeordneten Ansicht zu erstellen.

android:gravity

wird verwendet, um den Inhalt der Ansicht relativ zu ihrer angegebenen Position (zugewiesener Bereich) anzupassen. android:gravity="left" würde nichts tun, wenn layout_widthgleich ist"wrap_content"

android:layout_gravity 

wird für die Ansicht selbst relativ zur übergeordneten oder Layoutdatei verwendet.

android:gravity -> Legt die Schwerkraft des Inhalts der Ansicht fest, für die sie verwendet wird.

android:layout_gravity -> Legt die Schwerkraft der Ansicht oder des Layouts der Eltern fest

Schwerkraft - Gilt für seine eigene Ansicht.

Layout-Schwerkraft --- Gilt für die Ansicht, die sich auf das übergeordnete Element bezieht.

Das android:gravitylegt die Schwerkraft (Position) der Kinder fest, während das android:layout_gravitydie Position der Ansicht selbst festlegt. Ich hoffe es hilft