Best Practice zum Instanziieren eines neuen Android-Fragments

Ich habe zwei allgemeine Methoden zum Instanziieren eines neuen Fragments in einer Anwendung gesehen:

Fragment newFragment = new MyFragment();

und

Fragment newFragment = MyFragment.newInstance();

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

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

Zuerst dachte ich, der Hauptvorteil sei die Tatsache, dass ich die newInstance () -Methode ü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 eine gute Übung?

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

Wenn dies gesagt ist, 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 setArgumentsMethode zu übergeben.

Wenn wir beispielsweise eine Ganzzahl an das Fragment übergeben möchten, verwenden wir Folgendes:

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 können onCreate()Sie auf diese Ganzzahl zugreifen, indem Sie Folgendes verwenden:

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

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

Beachten Sie auch: setArgumentsKann nur aufgerufen werden, bevor das Fragment an die Aktivität angehängt ist.

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 eine einzige Stelle, an der 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. Dies ist eine gute Möglichkeit, anderen Klassen mitzuteilen, welche Argumente voraussichtlich korrekt funktionieren (obwohl Sie in der Lage sein sollten, Fälle zu behandeln, wenn in der Fragmentinstanz keine Argumente gebündelt sind).

Ich gehe davon aus, dass die Verwendung einer Statik newInstance()zum Instanziieren eines Fragments eine gute Vorgehensweise ist.

Es gibt auch einen anderen Weg:

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

Während @yydl einen überzeugenden Grund dafür angibt, warum die newInstanceMethode besser ist:

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

Es ist immer noch möglich, einen Konstruktor zu verwenden . Um zu sehen, warum dies 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 YourFragment()(der Konstruktor ohne Argumente ) auf, um eine Instanz des Fragments zu erstellen. Hier wird jeder überladene Konstruktor, den Sie schreiben, ignoriert, da Android nicht wissen kann, welchen Sie verwenden sollen.

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

Um dies zu umgehen, fordert Android Sie auf, Daten mit einem Bundle(Aufruf setArguments()) zu speichern , auf den dann zugegriffen werden kann YourFragment. Argumente bundlewerden von Android geschützt und sind daher garantiert dauerhaft .

Eine Möglichkeit, dieses Bundle festzulegen, ist die Verwendung einer statischen newInstanceMethode:

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

Ein Konstruktor:

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

kann genau das gleiche tun wie die newInstanceMethode.

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

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

Zur weiteren Erklärung hier die Fragmentklasse 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 darum bittet, dass die Argumente nur bei der Erstellung festgelegt werden, und garantiert, dass diese beibehalten werden.

BEARBEITEN : Wie in den Kommentaren von @JHH ausgeführt, stellt Java Ihrem Fragment keinen Standardkonstruktor ohne Argumente zur Verfügung, wenn Sie einen benutzerdefinierten Konstruktor bereitstellen, für den einige Argumente erforderlich sind . Dazu müssten Sie einen Konstruktor ohne Argumente definieren. Dies ist Code, den Sie mit der newInstanceFactory-Methode vermeiden können .

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

Ich bin nicht einverstanden mit yydi Antwort sagen:

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

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

Es ist wahr, dass Android-System Ihre zerstören und neu erstellen kann Fragment. So können Sie 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 ermöglicht Ihnen, someIntvon getArguments()letzterem an zu ziehen , selbst wenn das Fragmentvom System neu erstellt wurde. Dies ist eine elegantere Lösung als der staticKonstruktor.

Meiner Meinung nach sind staticKonstruktoren nutzlos und sollten nicht verwendet werden. Sie werden Sie auch einschränken, wenn Sie dies in Zukunft erweitern Fragmentund dem Konstruktor weitere Funktionen hinzufügen möchten . Mit dem staticKonstruktor 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.

Einige Kotlin- Codes:

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

Die beste Vorgehensweise zum Instanzieren 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 vermeiden, Ihre Felder mit der Instanz eines Fragments festzulegen. Denn wenn das Android-System Ihr Fragment neu erstellt und das System mehr Speicher benötigt, wird das Fragment mithilfe eines Konstruktors ohne Argumente neu erstellt.

Weitere Informationen zu bewährten Methoden zum Instanziieren von Fragmenten mit Argumenten finden Sie hier.

Aufgrund der Fragen zu Best Practices möchte ich hinzufügen, dass es sehr oft eine gute Idee ist, bei der Arbeit mit einigen REST-Webdiensten einen hybriden Ansatz zum Erstellen von Fragmenten zu verwenden

Wir können keine komplexen Objekte übergeben, z. B. ein Benutzermodell, um ein Benutzerfragment anzuzeigen

Was wir aber tun können, ist, onCreatediesen Benutzer einzuchecken ! = Null und wenn nicht - dann bringen Sie ihn aus der Datenschicht, andernfalls - verwenden Sie vorhandene.

Auf diese Weise erhalten wir sowohl die Fähigkeit, im Falle einer Fragmentwiederherstellung durch Android durch userId neu zu erstellen, als auch die Schnelligkeit für Benutzeraktionen, sowie die Fähigkeit, Fragmente zu erstellen, indem wir das Objekt selbst oder nur dessen ID gedrückt halten

So etwas gefällt mir:

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

Verwenden Sie diesen Code 100% beheben Sie Ihr Problem

Geben Sie diesen Code in firstFragment ein

public static yourNameParentFragment newInstance() {

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

Dieses Beispiel sendet boolesche Daten

und in SecendFragment

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

Der Wert im ersten Fragment ist statisch

fröhlicher Code

Die beste Methode zum Instanziieren des Fragments ist die Verwendung der Standardmethode Fragment.instantiate oder der Factory-Methode zum Instanziieren des Fragments.
Achtung: Erstellen Sie immer einen leeren Konstruktor im Fragment eines anderen, während das Wiederherstellen des Fragmentspeichers eine Laufzeitausnahme auslöst.

Ich bin in letzter Zeit hier. Aber etwas, von dem ich gerade wusste, dass es dir ein bisschen helfen könnte.

Wenn Sie Java verwenden, gibt es nicht viel zu ändern. Aber für Kotlin-Entwickler gibt es hier einen folgenden Ausschnitt, der Sie zu einem Keller machen kann, auf dem Sie laufen können:

• Übergeordnetes Fragment:

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

• Normaler Anruf

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

• Sie können die übergeordnete Init-Operation in der untergeordneten Fragmentklasse erweitern um:

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

Viel Spaß beim Codieren.

setArguments()ist nutzlos. Es bringt nur ein Durcheinander.

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

Ich glaube, ich habe eine viel einfachere Lösung dafür.

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