Best Practice zum Instanziieren eines neuen Android-Fragments

Ich habe zwei allgemeine Praktiken gesehen, um ein neues Fragment in einer Anwendung zu instanziieren:

Fragment newFragment = new MyFragment();

und

Fragment newFragment = MyFragment.newInstance();

Die zweite Option verwendet eine statische Methode newInstance() und allgemein enthält die folgende Methode.

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

Zuerst dachte ich, der Hauptvorteil sei die Tatsache, dass ich die Methode newInstance() überladen könnte, um beim Erstellen neuer Instanzen eines Fragments Flexibilität zu bieten – aber ich könnte dies auch tun, indem ich einen überladenen Konstruktor für das Fragment erstelle.

Habe ich etwas verpasst?

Was sind die Vorteile eines Ansatzes gegenüber dem anderen? Oder ist es nur gute Praxis?

Wenn Android beschließt, Ihr Fragment später neu zu erstellen, ruft es den Konstruktor ohne Argumente Ihres Fragments auf. Das Überladen des Konstruktors ist also keine Lösung.

Abgesehen davon besteht die Möglichkeit, Inhalte an Ihr Fragment zu übergeben, damit sie verfügbar sind, nachdem ein Fragment von Android neu erstellt wurde, darin, ein Bundle an die zu übergeben setArguments Methode.

Wenn wir also zum Beispiel eine ganze Zahl an das Fragment übergeben wollten, würden wir so etwas verwenden:

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

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

    return myFragment;
}

Und später im Fragment onCreate() Sie können auf diese Ganzzahl zugreifen, indem Sie Folgendes verwenden:

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

Dieses Bundle ist auch dann verfügbar, wenn das Fragment irgendwie von Android neu erstellt wird.

Beachten Sie auch: setArguments kann nur aufgerufen werden, bevor das Fragment an die Aktivität angehängt wird.

Dieser Ansatz ist auch in der Android-Entwicklerreferenz dokumentiert: https://developer.android.com/reference/android/app/Fragment.html

Der einzige Vorteil bei der Verwendung der newInstance() die ich sehe sind die folgenden:

1. Sie haben einen einzigen Ort, an dem alle vom Fragment verwendeten Argumente gebündelt werden können, und Sie müssen den folgenden Code nicht jedes Mal schreiben, wenn Sie ein Fragment instanziieren.

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

2. Es ist eine gute Möglichkeit, anderen Klassen mitzuteilen, welche Argumente es hat erwartet um treu zu arbeiten (obwohl Sie in der Lage sein sollten, Fälle zu behandeln, wenn keine Argumente in der Fragmentinstanz gebündelt sind).

Ich nehme also an, dass ich eine Statik verwende newInstance() Ein Fragment zu instanziieren ist eine bewährte Vorgehensweise.

Es gibt auch einen anderen Weg:

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

Während @yydl einen zwingenden Grund dafür angibt, warum die newInstance Methode ist besser:

Wenn Android beschließt, Ihr Fragment später neu zu erstellen, ruft es den Konstruktor ohne Argumente Ihres Fragments auf. Das Überladen des Konstruktors ist also keine Lösung.

es ist immer noch möglich, a zu verwenden Konstrukteur. Um zu sehen, warum das so ist, müssen wir zuerst sehen, warum die obige Problemumgehung von Android verwendet wird.

Bevor ein Fragment verwendet werden kann, wird eine Instanz benötigt. Android ruft an YourFragment() (der keine Argumente Konstruktor), um eine Instanz des Fragments zu erstellen. Hier wird jeder überladene Konstruktor, den Sie schreiben, ignoriert, da Android nicht wissen kann, welcher verwendet werden soll.

Während der Lebensdauer einer Aktivität wird das Fragment wie oben erstellt und mehrmals von Android zerstört. Das bedeutet, dass Daten, die Sie in das Fragmentobjekt selbst einfügen, verloren gehen, sobald das Fragment zerstört wird.

Um dies zu umgehen, fordert Android Sie auf, Daten mit a zu speichern Bundle (Berufung setArguments()), auf die dann zugegriffen werden kann YourFragment. Streit bundles sind durch Android geschützt und daher garantiert hartnäckig.

Eine Möglichkeit, dieses Bundle festzulegen, ist die Verwendung eines statischen newInstance Methode:

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

Allerdings ein Konstruktor:

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

kann genau das gleiche wie die newInstance Methode.

Dies würde natürlich fehlschlagen und ist einer der Gründe, warum Android möchte, dass Sie die verwenden newInstance Methode:

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

Zur weiteren Erläuterung hier die Fragment-Klasse von Android:

/**
 * 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;
}

Beachten Sie, dass Android Sie auffordert, die Argumente festzulegen nur beim Bau und garantiert, dass diese erhalten bleiben.

BEARBEITEN: Wie in den Kommentaren von @JHH erwähnt, stellt Java Ihr Fragment nicht mit einem bereit, wenn Sie einen benutzerdefinierten Konstruktor bereitstellen, der einige Argumente erfordert nein arg Standardkonstruktor. Dazu müssten Sie also a definieren nein arg Konstruktor, das ist Code, den Sie mit dem vermeiden könnten newInstance Fabrikmethode.

BEARBEITEN: Android erlaubt die Verwendung eines überladenen Konstruktors für Fragmente nicht mehr. Sie müssen die verwenden newInstance Methode.

Etwas kotlin Code:

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

Und Sie können Argumente damit bekommen:

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

ich nicht zustimmen mit yydi antwort sagen:

Wenn Android beschließt, Ihr Fragment später neu zu erstellen, ruft es den Konstruktor ohne Argumente Ihres Fragments auf. Das Überladen des Konstruktors ist also keine Lösung.

Ich denke, es ist eine Lösung und eine gute, genau aus diesem Grund wurde es von der Java-Kernsprache entwickelt.

Es stimmt, dass ein Android-System Ihr System zerstören und neu erstellen kann Fragment. Sie können also Folgendes tun:

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

Es wird Ihnen erlauben zu ziehen someInt von getArguments() letzteres auf, auch wenn die Fragment wurde vom System neu erstellt. Dies ist eine elegantere Lösung als static Konstrukteur.

Meiner Meinung nach static Konstruktoren sind nutzlos und sollten nicht verwendet werden. Sie werden Sie auch einschränken, wenn Sie dies in Zukunft erweitern möchten Fragment und fügen Sie dem Konstruktor weitere Funktionen hinzu. Mit static Konstruktor können Sie dies nicht tun.

Aktualisieren:

Android hat eine Inspektion hinzugefügt, die alle nicht standardmäßigen Konstruktoren mit einem Fehler kennzeichnet.
Ich empfehle, es aus den oben genannten Gründen zu deaktivieren.

Die beste Vorgehensweise zum Instanziieren von Fragmenten mit Argumenten in Android besteht darin, eine statische Factory-Methode in Ihrem Fragment zu haben.

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

Sie sollten es vermeiden, Ihre Felder mit der Instanz eines Fragments zu setzen. Denn wann immer das Android-System Ihr Fragment neu erstellt, wenn es das Gefühl hat, dass das System mehr Speicher benötigt, wird es Ihr Fragment neu erstellen, indem es den Konstruktor ohne Argumente verwendet.

Weitere Informationen finden Sie unter Best Practice zum Instanziieren von Fragmenten mit Argumenten Hier.