Wiem, że możemy ustawić następujące wartości dla właściwości android:gravityi android:layout_gravity:

1. center
2. center_vertical
3. center_horizontalitp.

Ale jestem zdezorientowany, jeśli chodzi o oba z nich.

Jaka jest różnica między użyciem android:gravitya android:layout_gravity?

Ich imiona powinny ci pomóc:

• android:gravityustawia grawitację zawartości (tj. jej widoków podrzędnych) Viewużywanego.
• android:layout_gravityustawia grawitację Viewlub Layoutwzględem jego rodzica.

I przykład jest tutaj .

Wewnątrz zewnątrz

• gravityporządkuje zawartość w widoku.
• layout_gravityustawia pozycję widoku poza sobą.

Czasami pomaga też zobaczyć zdjęcie. Są zielony i niebieski, TextViewsa pozostałe dwa kolory tła LinearLayouts.

Notatki

• layout_gravityNie działa widokami w RelativeLayout. Użyj go do wyświetlania w a LinearLayoutlub FrameLayout. Zobacz moją dodatkową odpowiedź, aby uzyskać więcej informacji.
• Szerokość (lub wysokość) widoku musi być większa niż jego zawartość. W przeciwnym razie gravitynie będzie żadnego efektu. Tak więc wrap_contenti gravitysą razem bez znaczenia.
• Szerokość (lub wysokość) widoku musi być mniejsza niż nadrzędna. W przeciwnym razie layout_gravitynie będzie żadnego efektu. Tak więc match_parenti layout_gravitysą razem bez znaczenia.
• layout_gravity=centerWygląda tak samo jak layout_gravity=center_horizontaltutaj, ponieważ są one w układzie pionowym liniowej. W tym przypadku nie można wyśrodkować w pionie, więc wyśrodkuj layout_gravity=centertylko w poziomie.
• Ta odpowiedź dotyczyła tylko ustawienia gravityi layout_gravitywidoków w układzie. Aby zobaczyć, co się stanie po ustawieniu gravitysamego układu macierzystego, sprawdź dodatkową odpowiedź , o której wspomniałem powyżej. (Podsumowanie: gravitynie działa dobrze na, RelativeLayoutale może być przydatne w przypadku LinearLayout.)

Pamiętaj więc, że układ _grawitacja porządkuje widok w swoim układzie . Grawitacja porządkuje zawartość w widoku.

xml

Oto xml dla powyższego obrazu w celach informacyjnych:

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

Związane z

• Różnica między dopełnieniem widoku a marginesem
• Match_parent vs wrap_content
• Jak programowo ustawić grawitację i grawitację układu LinearLayout

Różnica

android:layout_gravityjest zewnętrzną grawitacją widoku. Określa kierunek, w którym widok powinien dotykać granicy jego rodzica.

android:gravityto grawitacja wewnętrzna tego widoku. Określa kierunek, w którym jego zawartość powinna być wyrównana.

Odpowiedniki HTML / CSS

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

Prosta sztuczka, która pomoże Ci zapamiętać

Przyjmij layout-gravityjako „grawitację zewnętrzną”.

Krótka odpowiedź: użyj android:gravitylub setGravity()do kontroli grawitacji wszystkich widoków podrzędnych kontenera; używać android:layout_gravitylub setLayoutParams()kontrolować grawitację pojedynczego widoku w pojemniku.

Długa historia: aby kontrolować grawitację w kontenerze o układzie liniowym, takim jak LinearLayoutlub RadioGroup, istnieją dwa podejścia:

1) Aby kontrolować grawitację WSZYSTKICH widoków podrzędnych LinearLayoutkontenera (tak jak w książce), użyj android:gravity(nie android:layout_gravity) w pliku XML układu lub setGravity()metody w kodzie.

2) Aby kontrolować grawitację widoku potomnego w jego kontenerze, użyj android:layout_gravityatrybutu XML. W kodzie należy uzyskać LinearLayout.LayoutParamswidok i ustawić jego grawitację. Oto przykład kodu, który ustawia przycisk na dole w poziomo zorientowanym kontenerze:

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

W przypadku LinearLayoutkontenera poziomego grawitacja pozioma jego widoku potomnego jest wyrównana do lewej jeden po drugim i nie można go zmienić. Ustawienie android:layout_gravityna center_horizontalnie ma wpływu. Domyślna grawitacja pionowa to środek (lub środek_werkalny) i można ją zmienić na górną lub dolną. W rzeczywistości layout_gravitywartością domyślną jest, -1ale Android ustawia ją w pozycji środkowej w pionie.

Aby zmienić poziome pozycje widoków potomnych w poziomym pojemniku liniowym, można użyć layout_weightmarginesu i wypełnienia widoku potomnego.

Podobnie w przypadku pionowego kontenera grupy widoków, pionowy ciężar jego widoku potomnego jest wyrównany do góry jeden pod drugim i nie można go zmienić. Domyślna grawitacja pozioma to środek (lub center_horizontal) i można ją zmienić w lewo lub w prawo.

W rzeczywistości widok potomny, taki jak przycisk, ma również android:gravityatrybut XML i setGravity()metodę kontrolowania jego widoków potomnych - tekstu w nim. Button.setGravity(int)Jest związana z tym wejściem developer.android.com .

Z tego, co mogę zebrać, układ_grawitacja jest grawitacją tego widoku wewnątrz jego rodzica, a grawitacja jest grawitacją dzieci w tym widoku.

Myślę, że to prawda, ale najlepszym sposobem, aby się tego dowiedzieć, jest zabawa.

Spójrz na zdjęcie, aby wyraźnie określić grawitację

Jeśli chcemy ustawić grawitację zawartości w widoku, użyjemy „android: grawitacja”, a jeśli chcemy ustawić grawitację tego widoku (jako całości) w jego widoku nadrzędnym, użyjemy „android: układ_grawitacji ”.

Pomyślałem, że dodam tutaj moje własne wyjaśnienie - wywodząc się z tła na iOS, w ten sposób zinternalizowałem je w terminach iOS: „Układ grawitacji” wpływa na twoją pozycję w superwizji. „Grawitacja” wpływa na pozycję twoich podstron w tobie. Mówiąc inaczej, układ grawitacji pozycjonuje ciebie, podczas gdy grawitacja pozycjonuje twoje dzieci.

Istnieje wiele różnic w gravityi layout-gravity. Wyjaśnię moje doświadczenie na temat tych 2 pojęć ( wszystkie informacje, które otrzymałem dzięki mojej obserwacji i niektórym stronom internetowym ).

Użycie grawitacji i układu grawitacyjnego w FrameLayout.....

Uwaga:-

1. Grawitacja jest używana w widoku zawartości, ponieważ niektórzy użytkownicy mają odpowiedź i jest taka sama dla wszystkich ViewGroup Layout.

2. Layout-gravity jest używany z widokiem nadrzędnym, ponieważ niektórzy użytkownicy mają odpowiedź.

3. Gravity and Layout-gravityjest praca bardziej przydatna dla FrameLayoutdzieci. We can't use Gravity and Layout-gravityw znaczniku FrameLayout ....

4. Możemy ustawić Widok dziecka w dowolnym miejscu w FrameLayoutużyciu layout-gravity.

5. Możemy wykorzystać każdą pojedynczą wartość grawitacji wewnątrz FrameLayout (np: - center_vertical, center_horizontal, center, topitp), ale nie jest to możliwe z innych układów ViewGroup.

6. FrameLayoutw pełni działa Layout-gravity. Przykład: - Jeśli pracujesz FrameLayout, nie musisz zmieniać całego Układu, aby dodać nowy Widok. Po prostu dodajesz View jako ostatni w FrameLayouti dajesz mu Layout-gravitywartość ( jest to zaleta grawitacji układu dzięki FrameLayout ).

spójrz na przykład ......

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

Wynik:-

Użycie grawitacji i układu grawitacyjnego w LinearLayout .....

Gravitydziałając tak samo jak powyżej, ale tutaj jest różnica, że ​​możemy użyć grawitacji wewnątrz LinearLayout Viewi RelativeLayout Viewco nie jest możliwe w FrameLayout View.

Układ liniowy z orientacją pionową ....

Uwaga: - Tutaj możemy ustawić tylko 3 wartości layout_gravitytego ( left| right| center(również nazywane center_horizontal)).

spójrz na przykład: -

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

Wynik:-

Układ liniowy z orientacją poziomą ....

Uwaga: - Tutaj możemy ustawić również 3 wartości layout_gravitytego (( top| bottom| center(również nazywane center_vertical)).

spójrz na przykład: -

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

wynik:-

Uwaga: - Nie możemy użyć layout_gravityw, RelativeLayout Viewsale możemy gravityustawić RelativeLayoutdziecko w tej samej pozycji ....

Łatwą sztuczką do zapamiętania jest to, że grawitacja dotyczy nas wewnątrz Ziemi. Tak, android:gravityjest na środku widoku.

Rememeber na out w świeckich out _gravity które pomogą Ci pamiętać, że android:layout_gravityodsyła do zewnątrz widoku

Coś, co zobaczyłem na blogu Sandip, którego prawie przegapiłem, naprawiło mój problem. Powiedział, że layout_gravityNIE PRACUJE LinearLayout.

Jeśli używasz A, LinearLayouta ustawienia grawitacji doprowadzają Cię do szału (jak ja), przełącz się na coś innego.

Właściwie przełączyłem się na RelativeLayoutużywany wtedy layout_alignParentLefti layout_alignParentRightna 2 zawarte TextViews, aby uzyskać je w jednej linii, aby przejść daleko w lewo i daleko w prawo.

Podstawowa różnica między nimi polega na tym, że-

android: grawitacja jest używana w elementach potomnych widoku.

android: układ_grawitacja jest używany dla tego elementu w odniesieniu do widoku rodzica.

android:gravitysłuży do określania sposobu umieszczenia zawartości obiektu w samym obiekcie. Innymi słowy, android: grawitacja służy do określenia grawitacji zawartości widoku.

android:layout_gravity to atrybucja, którą dziecko może podać swojemu rodzicowi, aby określić wagę widoku w jego rodzicach.

Aby uzyskać więcej informacji, możesz odwiedzić

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

Grawitacja: pozwala przenosić zawartość wewnątrz kontenera. (Jak zostaną umieszczone widoki podrzędne).

Ważne: (PRZENIEŚ wzdłuż osi X lub osi Y w dostępnej przestrzeni).

Przykład: załóżmy, że jeśli chcesz pracować z LinearLayout (Height: match_parent, Width: match_parent) jako elementem na poziomie katalogu głównego, to będziesz mieć pełną przestrzeń na klatkę; a widoki potomne mówią, że 2 TextViews (Height: wrap_content, Width: wrap_content) wewnątrz LinearLayout można przesuwać wzdłuż osi x / y przy użyciu odpowiednich wartości grawitacji na obiekcie nadrzędnym.

Layout_Gravity: Pozwala na przesłonięcie nadrzędnego zachowania grawitacyjnego TYLKO wzdłuż osi x.

Ważne: (PRZESUŃ [przesłonięcie] wzdłuż osi X w dostępnym miejscu).

Przykład: jeśli pamiętasz o poprzednim przykładzie, wiemy, że grawitacja umożliwiła nam poruszanie się wzdłuż osi x / y, tj. miejsce TextViews wewnątrz LinearLayout. Powiedzmy, że LinearLayout określa grawitację: środek; co oznacza, że ​​każdy TextView musi być wyśrodkowany zarówno pionowo, jak i poziomo. Teraz, jeśli chcemy, aby jeden z TextView przesuwał się w lewo / w prawo, możemy przesłonić określone zachowanie grawitacyjne za pomocą layout_gravity w TextView.

Premia: jeśli zagłębisz się głębiej, przekonasz się, że tekst w TextView działa jako pod-widok; więc jeśli zastosujesz grawitację w TextView, tekst wewnątrz TextView będzie się poruszał. (dotyczy to również całej koncepcji)

Grawitacja służy do ustawiania wyrównania tekstu w widokach, ale układ_grawitacja służy do ustawiania widoków samodzielnie. Weźmy przykład, jeśli chcesz wyrównać tekst napisany w editText, a następnie użyć grawitacji i chcesz wyrównać ten editText lub dowolny przycisk lub dowolny widok, a następnie użyj layout_gravity, więc jest to bardzo proste.

grawitacja : służy do prostych widoków, takich jak podgląd tekstu, edycja tekstu itp.

layout_gravity : służy do bieżącego widoku tylko grawitacji w kontekście jego względnego widoku macierzystego, takiego jak układ liniowy lub FrameLayout, aby uzyskać widok w środku lub inną grawitację jego rodzica.

android:gravity

służy do dostosowania zawartości widoku względem jego określonej pozycji (przydzielonego obszaru). android:gravity="left" nie zrobiłby nic, jeśli layout_widthjest równy"wrap_content"

android:layout_gravity 

służy do wyświetlania samego względem pliku nadrzędnego lub pliku układu.

android:gravity -> Ustawia grawitację zawartości widoku, na którym jest używany.

android:layout_gravity -> Ustawia grawitację widoku rodzica lub układu

grawitacja - dotyczy własnego widoku.

layout-gravity --- Dotyczy widoku związanego z jego rodzica.

android:gravityOkreśla właściwy (pozycja) z dziećmi, natomiast w android:layout_gravityustawia położenie samego widzenia. Mam nadzieję, że to pomoże