Najlepsza praktyka tworzenia instancji nowego fragmentu Androida

Widziałem dwie ogólne praktyki tworzenia nowego fragmentu w aplikacji:

Fragment newFragment = new MyFragment();

i

Fragment newFragment = MyFragment.newInstance();

Druga opcja wykorzystuje metodę statyczną newInstance()i ogólnie zawiera następującą metodę.

public static Fragment newInstance() 
{
    MyFragment myFragment = new MyFragment();
    return myFragment;
}

Na początku myślałem, że główną korzyścią jest to, że mogę przeciążać metodę newInstance (), aby zapewnić elastyczność podczas tworzenia nowych instancji Fragmentu - ale mogę to również zrobić, tworząc przeciążony konstruktor Fragmentu.

Przegapiłem coś?

Jakie są zalety jednego podejścia względem drugiego? Czy to tylko dobra praktyka?

Jeśli Android zdecyduje się później odtworzyć Fragment, wywoła konstruktor fragmentu bez argumentu. Przeciążenie konstruktora nie jest rozwiązaniem.

Biorąc to pod uwagę, sposobem przekazywania rzeczy do Fragmentu, aby były one dostępne po odtworzeniu Fragmentu przez Androida, jest przekazanie pakietu do setArgumentsmetody.

Na przykład, jeśli chcielibyśmy przekazać liczbę całkowitą do fragmentu, użylibyśmy czegoś takiego:

public static MyFragment newInstance(int someInt) {
    MyFragment myFragment = new MyFragment();

    Bundle args = new Bundle();
    args.putInt("someInt", someInt);
    myFragment.setArguments(args);

    return myFragment;
}

Później we fragmencie onCreate()możesz uzyskać dostęp do tej liczby całkowitej, używając:

getArguments().getInt("someInt", 0);

Ten pakiet będzie dostępny, nawet jeśli fragment zostanie w jakiś sposób odtworzony przez system Android.

Uwaga: setArgumentsmożna wywołać tylko przed dołączeniem fragmentu do działania.

To podejście jest również udokumentowane w odnośniku dla programistów Androida: https://developer.android.com/reference/android/app/Fragment.html

Jedyne korzyści z korzystania z newInstance()tego, co widzę, są następujące:

1. Będziesz miał jedno miejsce, w którym wszystkie argumenty użyte przez fragment mogą być spakowane i nie musisz pisać kodu poniżej za każdym razem, gdy utworzysz fragment.

   Bundle args = new Bundle();
   args.putInt("someInt", someInt);
   args.putString("someString", someString);
   // Put any other arguments
   myFragment.setArguments(args);

2. Jest to dobry sposób, aby powiedzieć innym klasom, jakich argumentów oczekuje wiernie działać (chociaż powinieneś być w stanie obsługiwać przypadki, jeśli w instancji fragmentu nie ma żadnego argumentu).

Uważam więc, że newInstance()dobrym pomysłem jest użycie elementu statycznego do utworzenia fragmentu.

Jest też inny sposób:

Fragment.instantiate(context, MyFragment.class.getName(), myBundle)

Podczas gdy @yydl daje przekonujący powód, dla którego newInstancemetoda jest lepsza:

Jeśli Android zdecyduje się później odtworzyć Fragment, wywoła konstruktor fragmentu bez argumentu. Przeciążenie konstruktora nie jest rozwiązaniem.

nadal jest całkiem możliwe użycie konstruktora . Aby zrozumieć, dlaczego tak jest, najpierw musimy dowiedzieć się, dlaczego powyższe obejście jest używane przez system Android.

Przed użyciem fragmentu potrzebna jest instancja. Wywołania Androida YourFragment()(konstruktor bez argumentów ) w celu skonstruowania instancji fragmentu. Tutaj każdy przeciążony konstruktor, który napiszesz, zostanie zignorowany, ponieważ Android nie może wiedzieć, którego użyć.

W czasie trwania działania fragment jest tworzony jak wyżej i wielokrotnie niszczony przez Androida. Oznacza to, że jeśli umieścisz dane w samym obiekcie fragmentu, zostaną one utracone po zniszczeniu fragmentu.

Aby obejść ten problem, Android prosi o przechowywanie danych za pomocą Bundle(połączenia setArguments()), do którego można uzyskać dostęp YourFragment. Argumenty bundlesą chronione przez system Android, a zatem gwarantuje się, że będą trwałe .

Jednym ze sposobów ustawienia tego pakietu jest użycie newInstancemetody statycznej :

public static YourFragment newInstance (int data) {
    YourFragment yf = new YourFragment()
    /* See this code gets executed immediately on your object construction */
    Bundle args = new Bundle();
    args.putInt("data", data);
    yf.setArguments(args);
    return yf;
}

Jednak konstruktor:

public YourFragment(int data) {
    Bundle args = new Bundle();
    args.putInt("data", data);
    setArguments(args);
}

może zrobić dokładnie to samo co newInstancemetoda.

Oczywiście to się nie powiedzie i jest to jeden z powodów, dla których Android chce, abyś użył tej newInstancemetody:

public YourFragment(int data) {
    this.data = data; // Don't do this
}

Jako dalsze wyjaśnienie, oto klasa fragmentów Androida:

/**
 * Supply the construction arguments for this fragment.  This can only
 * be called before the fragment has been attached to its activity; that
 * is, you should call it immediately after constructing the fragment.  The
 * arguments supplied here will be retained across fragment destroy and
 * creation.
 */
public void setArguments(Bundle args) {
    if (mIndex >= 0) {
        throw new IllegalStateException("Fragment already active");
    }
    mArguments = args;
}

Pamiętaj, że Android prosi o ustawienie argumentów tylko na etapie budowy i gwarantuje, że zostaną one zachowane.

EDYCJA : Jak wskazano w komentarzach @JHH, jeśli udostępniasz niestandardowy konstruktor, który wymaga pewnych argumentów, wówczas Java nie dostarczy twojemu fragmentowi domyślnego konstruktora bez arg . Wymagałoby to więc zdefiniowania konstruktora no arg , czyli kodu, którego można by uniknąć za pomocą newInstancemetody fabrycznej.

EDYCJA : Android nie pozwala już na używanie przeciążonego konstruktora dla fragmentów. Musisz użyć tej newInstancemetody.

Nie zgadzam się z odpowiedzią yydi mówiącą:

Jeśli Android zdecyduje się później odtworzyć Fragment, wywoła konstruktor fragmentu bez argumentu. Przeciążenie konstruktora nie jest rozwiązaniem.

Myślę, że to rozwiązanie i dobre, to jest właśnie powód, dla którego został opracowany przez podstawowy język Java.

Prawdą jest, że system Android może zniszczyć i odtworzyć Twoje Fragment. Możesz to zrobić:

public MyFragment() {
//  An empty constructor for Android System to use, otherwise exception may occur.
}

public MyFragment(int someInt) {
    Bundle args = new Bundle();
    args.putInt("someInt", someInt);
    setArguments(args);
}

Pozwoli ci to kontynuować someIntod getArguments()ostatniego, nawet jeśli Fragmentzostały odtworzone przez system. To jest bardziej eleganckie rozwiązanie niż statickonstruktor.

Moim zdaniem statickonstruktory są bezużyteczne i nie powinny być używane. Ograniczą cię również, jeśli w przyszłości chcesz to rozszerzyć Fragmenti dodać więcej funkcji do konstruktora. Z statickonstruktorem nie możesz tego zrobić.

Aktualizacja:

System Android dodał inspekcję, która oznacza błąd wszystkich konstruktorów innych niż domyślne.
Polecam ją wyłączyć z wyżej wymienionych powodów.

Niektóre kody kotlin :

companion object {
    fun newInstance(first: String, second: String) : SampleFragment {
        return SampleFragment().apply {
            arguments = Bundle().apply {
                putString("firstString", first)
                putString("secondString", second)
            }
        }
    }
}

I możesz uzyskać z tym argumenty:

val first: String by lazy { arguments?.getString("firstString") ?: "default"}
val second: String by lazy { arguments?.getString("secondString") ?: "default"}

Najlepszą praktyką w przypadku instancji fragmentów z argumentami w Androidzie jest posiadanie statycznej metody fabrycznej we fragmencie.

public static MyFragment newInstance(String name, int age) {
    Bundle bundle = new Bundle();
    bundle.putString("name", name);
    bundle.putInt("age", age);

    MyFragment fragment = new MyFragment();
    fragment.setArguments(bundle);

    return fragment;
}

Należy unikać ustawiania pól za pomocą instancji fragmentu. Ponieważ ilekroć system Android odtworzy Twój fragment, jeśli poczuje, że system potrzebuje więcej pamięci, wówczas odtworzy Twój fragment przy użyciu konstruktora bez argumentów.

Więcej informacji o najlepszych praktykach tworzenia instancji fragmentów z argumentami znajduje się tutaj.

Ponieważ mam pytania dotyczące najlepszych praktyk, dodam, że bardzo często dobrym pomysłem jest zastosowanie podejścia hybrydowego do tworzenia fragmentu podczas pracy z niektórymi usługami sieciowymi REST

Nie możemy przekazać złożonych obiektów, na przykład niektórych modeli użytkownika, na wypadek wyświetlenia fragmentu użytkownika

Ale co możemy zrobić, to zarejestrować onCreatetego użytkownika! = Null, a jeśli nie - to zabierz go z warstwy danych, w przeciwnym razie - użyj istniejącego.

W ten sposób zyskujemy zarówno zdolność do odtwarzania przez userId w przypadku odtwarzania fragmentów przez system Android, jak i snappiness do akcji użytkownika, a także możliwość tworzenia fragmentów przez trzymanie się obiektu lub samego jego identyfikatora

Coś lubi to:

public class UserFragment extends Fragment {
    public final static String USER_ID="user_id";
    private User user;
    private long userId;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        userId = getArguments().getLong(USER_ID);
        if(user==null){
            //
            // Recreating here user from user id(i.e requesting from your data model,
            // which could be services, direct request to rest, or data layer sitting
            // on application model
            //
             user = bringUser();
        }
    }

    public static UserFragment newInstance(User user, long user_id){
        UserFragment userFragment = new UserFragment();
        Bundle args = new Bundle();
        args.putLong(USER_ID,user_id);
        if(user!=null){
            userFragment.user=user;
        }
        userFragment.setArguments(args);
        return userFragment;

    }

    public static UserFragment newInstance(long user_id){
        return newInstance(null,user_id);
    }

    public static UserFragment newInstance(User user){
        return newInstance(user,user.id);
    }
}

użyj tego kodu w 100% napraw swój problem

wprowadź ten kod w firstFragment

public static yourNameParentFragment newInstance() {

    Bundle args = new Bundle();
    args.putBoolean("yourKey",yourValue);
    YourFragment fragment = new YourFragment();
    fragment.setArguments(args);
    return fragment;
}

ta próbka wysyła dane logiczne

oraz w SecendFragment

yourNameParentFragment name =yourNameParentFragment.newInstance();
   Bundle bundle;
   bundle=sellDiamondFragments2.getArguments();
  boolean a= bundle.getBoolean("yourKey");

wartość musi w pierwszym fragmencie jest statyczna

szczęśliwy kod

Najlepszym sposobem na utworzenie instancji fragmentu jest użycie domyślnej metody Fragment.instantiate lub utworzenie metody fabrycznej w celu utworzenia instancji fragmentu
Uwaga: zawsze twórz jeden pusty konstruktor w innym fragmencie, a przywrócenie pamięci fragmentu spowoduje wygenerowanie wyjątku w czasie wykonywania.

Ostatnio tu jestem. Ale coś, co właśnie wiedziałem, może ci trochę pomóc.

Jeśli korzystasz z Javy, nie musisz wiele zmieniać. Ale dla deweloperów kotlin, oto poniższy fragment, który moim zdaniem może sprawić, że będziesz piwnicą:

• Fragment macierzysty:

inline fun <reified T : SampleFragment> newInstance(text: String): T {
    return T::class.java.newInstance().apply {
        arguments = Bundle().also { it.putString("key_text_arg", text) }
    }
}

• Normalne połączenie

val f: SampleFragment = SampleFragment.newInstance("ABC")
// or val f = SampleFragment.newInstance<SampleFragment>("ABC")

• Możesz rozszerzyć rodzicielską operację inicjującą w klasie fragmentów potomnych o:

fun newInstance(): ChildSampleFragment {
    val child = UserProfileFragment.newInstance<ChildSampleFragment>("XYZ")
    // Do anything with the current initialized args bundle here
    // with child.arguments = ....
    return child
}

Szczęśliwego kodowania.

setArguments()jest bezużyteczny. To tylko wprowadza bałagan.

public class MyFragment extends Fragment {

    public String mTitle;
    public String mInitialTitle;

    public static MyFragment newInstance(String param1) {
        MyFragment f = new MyFragment();
        f.mInitialTitle = param1;
        f.mTitle = param1;
        return f;
    }

    @Override
    public void onSaveInstanceState(Bundle state) {
        state.putString("mInitialTitle", mInitialTitle);
        state.putString("mTitle", mTitle);
        super.onSaveInstanceState(state);
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle state) {
        if (state != null) {
            mInitialTitle = state.getString("mInitialTitle");
            mTitle = state.getString("mTitle");
        } 
        ...
    }
}

Wierzę, że mam na to rozwiązanie o wiele prostsze.

public class MyFragment extends Fragment{

   private String mTitle;
   private List<MyObject> mObjects;

   public static MyFragment newInstance(String title, List<MyObject> objects)
   MyFragment myFrag = new MyFragment();
   myFrag.mTitle = title;
   myFrag.mObjects = objects;
   return myFrag;
   }