it-swarm.com.de

Was ist der Unterschied zwischen Schwerkraft und layout_gravity in Android?

Ich weiß, dass wir die folgenden Werte für die Eigenschaften Android:gravity und Android:layout_gravity festlegen können:

  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:gravity_ und _Android:layout_gravity_?

1262
Paresh Mayani

Ihre Namen sollen Ihnen helfen:

  • Android:gravity legt den Schweregrad des Inhalts (d. H. Der Unteransichten) des verwendeten View fest.
  • Android:layout_gravity legt die Schwere des View oder Layout relativ zu seinem übergeordneten Element fest.

Und ein Beispiel ist hier .

1292
Sephy

Innen - Außen

  • gravity ordnet den Inhalt innerhalb der Ansicht an.
  • layout_gravity ordnet die Position der Ansicht außerhalb von sich selbst an.

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

enter image description here

Anmerkungen

  • Der layout_gravity funktioniert nicht für Ansichten in einem RelativeLayout. Verwenden Sie diese Option für Ansichten in LinearLayout oder FrameLayout. Siehe mein ergänzende Antwort für weitere Einzelheiten.
  • Die Breite (oder Höhe) der Ansicht muss größer sein als der Inhalt. Andernfalls hat gravity keine Auswirkung. Somit sind wrap_content und gravity zusammen bedeutungslos.
  • Die Breite (oder Höhe) der Ansicht muss kleiner sein als die des übergeordneten Elements. Andernfalls hat layout_gravity keine Wirkung. Somit sind match_parent und layout_gravity zusammen bedeutungslos.
  • Der layout_gravity=center sieht hier genauso aus wie layout_gravity=center_horizontal, da sie sich in einem vertikalen linearen Layout befinden. In diesem Fall können Sie nicht vertikal zentrieren, daher wird layout_gravity=center nur horizontal zentriert.
  • Diese Antwort bezog sich nur auf die Einstellung von gravity und layout_gravity für die Ansichten innerhalb eines Layouts. Um zu sehen, was passiert, wenn Sie gravity für das übergeordnete Layout selbst festlegen, lesen Sie das Zusatzantwort , auf das ich oben verwiesen habe. (Zusammenfassung: gravity funktioniert bei RelativeLayout nicht gut, kann aber bei LinearLayout nützlich sein.)

Also denken Sie daran, Layout _ die Schwerkraft ordnet eine Ansicht in ihrem Layout . 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

490
Suragch

Der Unterschied

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

Android:gravity ist 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

Ein einfacher Trick, der Ihnen hilft, sich zu erinnern

Nehmen Sie layout-gravity als "Lay-outside-gravity".

455
Vishnu Haridas

Kurze Antwort: Verwenden Sie Android:gravity oder setGravity(), um die Schwerkraft aller untergeordneten Ansichten eines Containers zu steuern. Verwenden Sie Android:layout_gravity oder setLayoutParams(), um die Schwerkraft einer einzelnen Ansicht in einem Container zu steuern.

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

1) Um den Schweregrad ALLER untergeordneten Ansichten eines LinearLayout Containers (wie in Ihrem Buch) zu steuern, verwenden Sie Android:gravity (nicht Android:layout_gravity) in der Layout-XML-Datei oder in der Methode setGravity() im Code .

2) Um die Schwere einer untergeordneten Ansicht in ihrem Container zu steuern, verwenden Sie das XML-Attribut Android:layout_gravity. Im Code muss man den LinearLayout.LayoutParams der Ansicht abrufen und dessen Schweregrad festlegen. Hier ist ein Codebeispiel, mit dem eine Schaltfläche in einem horizontal ausgerichteten Container auf den Boden 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);

Beim horizontalen Container LinearLayout wird die horizontale Schwerkraft der untergeordneten Ansicht nacheinander linksbündig ausgerichtet und kann nicht geändert werden. Das Einstellen von Android:layout_gravity auf center_horizontal hat keine Auswirkung. Die voreingestellte vertikale Schwerkraft ist center (oder center_vertical) und kann nach oben oder unten geändert werden. Tatsächlich ist der layout_gravity Standardwert -1, aber Android zentriert ihn vertikal.

Um die horizontale Position von untergeordneten Ansichten in einem horizontalen linearen Container zu ändern, können Sie layout_weight, den Rand und das Auffüllen der untergeordneten Ansicht verwenden.

In ähnlicher Weise ist für den Container "Vertikale Ansichtsgruppe" die vertikale Schwerkraft der untergeordneten Ansicht übereinander ausgerichtet und kann nicht geändert werden. Die voreingestellte horizontale Schwerkraft ist die Mitte (oder center_horizontal) und kann nach links oder rechts geändert werden.

Tatsächlich verfügt eine untergeordnete Ansicht wie eine Schaltfläche auch über das XML-Attribut Android:gravity und die Methode setGravity(), um die untergeordneten Ansichten zu steuern - den darin enthaltenen Text. Die Button.setGravity(int) ist mit diesem developer.Android.com-Eintrag verknüpft.

38
Ying

Nach allem, was ich erfassen kann, ist layout_gravity die Schwerkraft dieser Ansicht in ihrem übergeordneten Element und schwerkraft die Schwerkraft der Kinder in dieser Ansicht.

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

35
matto1990

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

25
Akshay Paliwal

Obwohl die Frage bereits beantwortet wurde, habe ich einige Beispiele, die die Verwendung von Schwerkraft, Layout_Gravity und Layout_Gewicht demonstrieren.

Sie finden die Beispiele unter http://juanpickselov.com/LayoutExamples.Zip

Ich habe die Dateien in Eclipse erstellt, die .svn-Unterordner entfernt und Stile, Zeichenfolgen, Farben usw. eingefügt. Die Layoutdateien sind der Hauptpunkt der Demos. Da ich ein Java - und Android -Entwicklungsneuling bin, kann es sein, dass der Java ineffizient ist. Die Dateien können in ein Eclipse-Projekt kopiert werden, oder ich habe sie auch in Netbeans mit dem für diese IDE verfügbaren Entwicklungs-Plugin Android verwendet.

13
user244298

Wenn wir den Schweregrad von Inhalten in einer Ansicht festlegen möchten, verwenden wir "Android: Schweregrad". Wenn wir den Schweregrad dieser Ansicht (als Ganzes) in der übergeordneten Ansicht festlegen möchten, verwenden wir "Android: layout_gravity ".

11
Abhishek Tamta

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

7
mszaro

Es gibt viele Unterschiede zwischen gravity und 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 in der Ansicht von Inhalten verwendet, wenn ein Benutzer eine Antwort darauf hat ist für alle ViewGroup Layout gleich.

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

  3. Gravity and Layout-gravity ist sinnvoller mit den FrameLayout childs zu arbeiten. We can't use Gravity and Layout-gravity im Tag von FrameLayout ....

  4. Wir können Child View mit layout-gravity an jeder beliebigen Stelle in FrameLayout einstellen.

  5. Wir können jeden einzelnen Wert der Schwerkraft im FrameLayout verwenden (z. B .: - center_vertical, center_horizontal, center, top usw.), dies ist jedoch mit anderen ViewGroup-Layouts nicht möglich.

  6. FrameLayout arbeitet vollständig an Layout-gravity. Beispiel: - Wenn Sie an FrameLayout arbeiten, müssen Sie nicht das gesamte Layout ändern, um eine neue Ansicht hinzuzufügen. Fügen Sie einfach View als letztes in das FrameLayout ein und geben Sie ihm Layout-gravity mit Wert. ( Dies ist Vorteile der Layout-Schwerkraft mit FrameLayout ).

siehe beispiel ......

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

g1

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

Gravity funktioniert wie oben, nur dass wir hier die Schwerkraft innerhalb von LinearLayout View und RelativeLayout View verwenden können, was in FrameLayout View nicht möglich ist.

LinearLayout mit vertikaler Ausrichtung ....

Hinweis: - Hier können nur 3 Werte von layout_gravity festgelegt werden, dh (left | right | center (auch center_horizontal genannt).

siehe beispiel:

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

g2

LinearLayout mit horizontaler Ausrichtung ....

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

siehe beispiel:

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

g3

Hinweis: - Wir können layout_gravity nicht in RelativeLayout Views verwenden, aber wir können gravity verwenden, um RelativeLayout Childs auf dieselbe Position zu setzen ....

6
sushildlh

Ein einfacher Trick, an den man sich erinnert, ist, dass die Schwerkraft auf uns im Inneren der Erde zutrifft. Also ist Android:gravity für innen die Ansicht.

Erinnern Sie sich an die out in lag out _ Schwerkraft , die Ihnen helfen würde, daran zu erinnern, dass Android:layout_gravity würde sich auf außerhalb die Ansicht beziehen

4
Mahendra Liya

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

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

Ich habe tatsächlich zu einem RelativeLayout gewechselt und dann layout_alignParentLeft und layout_alignParentRight für die 2 enthaltenen TextViews verwendet, um sie in einer Zeile ganz nach links und ganz nach rechts zu bringen.

4
JustSomeGuy

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

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

Beispiel: Angenommen, Sie arbeiten mit LinearLayout (Höhe: match_parent, Breite: match_parent) als Stammelement, dann steht Ihnen der gesamte Frame-Bereich zur Verfügung. In der untergeordneten Ansicht heißt es, dass 2 TextViews (Höhe: wrap_content, Breite: wrap_content) im LinearLayout entlang der x/y-Achse verschoben werden können, wobei entsprechende Werte für die Schwerkraft der übergeordneten Ansicht verwendet werden.

Layout_Gravity: Hiermit können Sie das übergeordnete Schwerkraftverhalten NUR entlang der x-Achse überschreiben.

Wichtig: (MOVE [override] entlang der X-Achse innerhalb des verfügbaren Raums).

Beispiel: Wenn Sie sich das vorherige Beispiel merken, wissen wir, dass die Schwerkraft es uns ermöglicht hat, uns entlang der x/y-Achse zu bewegen, d.h. die Stelle TextViews in LinearLayout. Angenommen, LinearLayout gibt die Schwerkraft an: center; Das bedeutet, dass jede Textansicht sowohl vertikal als auch horizontal zentriert sein muss. Wenn wir möchten, dass eine der Textansichten nach links/rechts verschoben wird, können wir das angegebene Schwerkraftverhalten mit layout_gravity in der Textansicht überschreiben.

Bonus: Wenn Sie tiefer graben, werden Sie feststellen, dass der 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)

2
Ali Raza

Android:gravity wird verwendet, um anzugeben, wie der Inhalt des Objekts im Objekt selbst platziert werden soll. In einem anderen Wort wird Android: gravity verwendet, um die Schwere des Inhalts der Ansicht anzugeben.

Android:layout_gravity ist eine Attribution, die das Kind seinem Elternteil zur Verfügung stellen kann, um die Schwere der Ansicht innerhalb seiner Eltern anzugeben.

Für weitere Informationen können Sie besuchen

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

2
IntelliJ Amiya

Der grundlegende Unterschied zwischen den beiden ist, dass

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

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

2
Abhishek Tandon

Mit der Schwerkraft wird die Textausrichtung in Ansichten festgelegt, mit layout_gravity werden die Ansichten selbst festgelegt. Nehmen wir ein Beispiel, wenn Sie Text ausrichten möchten, der in editText geschrieben wurde, und dann die Schwerkraft verwenden möchten, und Sie möchten diesen editText oder eine beliebige Schaltfläche oder eine beliebige Ansicht ausrichten und dann layout_gravity verwenden. Das ist also sehr einfach.

1
Praveen Gaur

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

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

1
Mayank Garg

schwerkraft - Gilt für seine eigene Ansicht.

layout-Schwerkraft --- Betrifft die Ansicht in Bezug auf das übergeordnete Element.

0
nidhi

Android:gravity -> Legt den Schweregrad des Inhalts der Ansicht fest, auf der er verwendet wird.

Android:layout_gravity -> Legt den Schwerpunkt der Ansicht oder des Layouts der Eltern fest

0
Vamsi
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_width gleich dem "wrap_content" ist

Android:layout_gravity 

wird für die Ansicht selbst relativ zur übergeordneten oder Layout-Datei verwendet.

0
Tulsi