Praktik terbaik untuk membuat Instansiasi Android baru

Saya telah melihat dua praktik umum untuk membuat Instansi baru dalam aplikasi:

Fragment newFragment = new MyFragment();

dan

Fragment newFragment = MyFragment.newInstance();

Opsi kedua menggunakan metode statis newInstance()dan umumnya berisi metode berikut.

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

Pada awalnya, saya pikir manfaat utama adalah fakta bahwa saya dapat membebani metode newInstance () untuk memberikan fleksibilitas ketika membuat instance Fragmen baru - tetapi saya juga bisa melakukan ini dengan membuat konstruktor yang kelebihan beban untuk Fragmen.

Apakah saya melewatkan sesuatu?

Apa manfaat dari satu pendekatan di atas yang lain? Atau hanya praktik yang baik?

Jika Android memutuskan untuk membuat ulang Fragmen Anda nanti, itu akan memanggil konstruktor no-argumen fragmen Anda. Jadi kelebihan konstruktor bukanlah solusi.

Dengan itu dikatakan, cara untuk mengirimkan barang ke Fragmen Anda sehingga mereka tersedia setelah Fragment diciptakan kembali oleh Android adalah dengan mengirimkan bundel ke setArgumentsmetode.

Jadi, misalnya, jika kami ingin memberikan bilangan bulat ke fragmen kami akan menggunakan sesuatu seperti:

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

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

    return myFragment;
}

Dan nanti di Fragmen onCreate()Anda dapat mengakses integer itu dengan menggunakan:

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

Bundel ini akan tersedia bahkan jika Fragmennya dibuat ulang oleh Android.

Perhatikan juga: setArgumentshanya dapat dipanggil sebelum Fragmen dilampirkan ke Aktivitas.

Pendekatan ini juga didokumentasikan dalam referensi pengembang android: https://developer.android.com/reference/android/app/Fragment.html

Satu-satunya manfaat dalam menggunakan newInstance()yang saya lihat adalah sebagai berikut:

1. Anda akan memiliki satu tempat di mana semua argumen yang digunakan oleh fragmen dapat digabungkan dan Anda tidak harus menulis kode di bawah ini setiap kali Anda membuat fragmen.

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

2. Ini cara yang bagus untuk memberi tahu kelas lain argumen apa yang diharapkan akan berfungsi dengan baik (meskipun Anda harus dapat menangani kasus jika tidak ada argumen yang dibundel dalam contoh fragmen).

Jadi, pendapat saya adalah menggunakan statik newInstance()untuk membuat fragmen adalah praktik yang baik.

Ada juga cara lain:

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

Sementara @yydl memberikan alasan kuat mengapa newInstancemetode ini lebih baik:

Jika Android memutuskan untuk membuat ulang Fragmen Anda nanti, itu akan memanggil konstruktor no-argumen fragmen Anda. Jadi kelebihan konstruktor bukanlah solusi.

masih sangat mungkin menggunakan konstruktor . Untuk melihat mengapa ini, pertama-tama kita perlu melihat mengapa solusi di atas digunakan oleh Android.

Sebelum sebuah fragmen dapat digunakan, sebuah instance dibutuhkan. Android memanggil YourFragment()( konstruktor tanpa argumen ) untuk membuat instance fragmen. Di sini konstruktor kelebihan beban apa pun yang Anda tulis akan diabaikan, karena Android tidak dapat mengetahui mana yang akan digunakan.

Dalam masa Aktivitas, fragmen dibuat seperti di atas dan dihancurkan beberapa kali oleh Android. Ini berarti bahwa jika Anda menempatkan data dalam objek fragmen itu sendiri, itu akan hilang setelah fragmen dihancurkan.

Untuk mengatasinya, android meminta Anda menyimpan data menggunakan Bundle(panggilan setArguments()), yang kemudian dapat diakses dari YourFragment. Argumen bundledilindungi oleh Android, dan karenanya dijamin akan tetap ada .

Salah satu cara untuk mengatur bundel ini adalah dengan menggunakan newInstancemetode statis :

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

Namun, seorang konstruktor:

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

dapat melakukan hal yang persis sama dengan newInstancemetode.

Secara alami, ini akan gagal, dan merupakan salah satu alasan Android ingin Anda menggunakan newInstancemetode ini:

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

Sebagai penjelasan lebih lanjut, inilah Kelas Fragmen 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;
}

Perhatikan bahwa Android meminta agar argumen ditetapkan hanya pada konstruksi, dan menjamin bahwa ini akan dipertahankan.

EDIT : Seperti yang ditunjukkan dalam komentar oleh @JHH, jika Anda menyediakan konstruktor khusus yang memerlukan beberapa argumen, maka Java tidak akan memberikan fragmen Anda dengan konstruktor default no arg . Jadi ini akan mengharuskan Anda untuk mendefinisikan konstruktor no arg , yang merupakan kode yang dapat Anda hindari dengan newInstancemetode pabrik.

EDIT : Android tidak lagi mengizinkan konstruktor yang kelebihan beban untuk fragmen. Anda harus menggunakan newInstancemetode ini.

Saya tidak setuju dengan jawaban yydi yang mengatakan:

Jika Android memutuskan untuk membuat ulang Fragmen Anda nanti, itu akan memanggil konstruktor no-argumen fragmen Anda. Jadi kelebihan konstruktor bukanlah solusi.

Saya pikir ini adalah solusi dan yang bagus, inilah alasan mengapa ini dikembangkan oleh bahasa inti Java.

Benar bahwa sistem Android dapat menghancurkan dan membuat ulang Fragment. Jadi Anda bisa melakukan ini:

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

Ini akan memungkinkan Anda untuk menarik someIntdari yang getArguments()terakhir aktif, bahkan jika Fragmenttelah diciptakan ulang oleh sistem. Ini adalah solusi yang lebih elegan daripada statickonstruktor.

Untuk pendapat saya statickonstruktor tidak berguna dan tidak boleh digunakan. Juga mereka akan membatasi Anda jika di masa depan Anda ingin memperpanjang ini Fragmentdan menambahkan lebih banyak fungsi ke konstruktor. Dengan statickonstruktor Anda tidak dapat melakukan ini.

Memperbarui:

Android menambahkan inspeksi yang menandai semua konstruktor non-default dengan kesalahan.
Saya sarankan untuk menonaktifkannya, untuk alasan yang disebutkan di atas.

Beberapa kode kotlin :

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

Dan Anda bisa mendapatkan argumen dengan ini:

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

Praktik terbaik untuk instance fragmen dengan argumen di android adalah memiliki metode pabrik statis di fragmen Anda.

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

Anda harus menghindari pengaturan bidang Anda dengan contoh fragmen. Karena setiap kali sistem android membuat ulang fragmen Anda, jika terasa bahwa sistem membutuhkan lebih banyak memori, daripada itu akan membuat ulang fragmen Anda dengan menggunakan konstruktor tanpa argumen.

Anda dapat menemukan lebih banyak info tentang praktik terbaik untuk membuat instance fragmen dengan argumen di sini.

Karena pertanyaan tentang praktik terbaik, saya akan menambahkan, itu sering kali ide yang baik untuk menggunakan pendekatan hybrid untuk membuat fragmen ketika bekerja dengan beberapa layanan web REST

Kami tidak dapat melewatkan objek yang kompleks, misalnya beberapa model Pengguna, untuk kasus menampilkan fragmen pengguna

Tapi yang bisa kita lakukan adalah mengecek onCreatepengguna itu! = Nol dan jika tidak - maka bawalah dia dari lapisan data, jika tidak - gunakan yang ada.

Dengan cara ini kita mendapatkan kedua kemampuan untuk membuat ulang oleh userId dalam hal rekreasi fragmen oleh Android dan ketangkasan untuk tindakan pengguna, serta kemampuan untuk membuat fragmen dengan memegang ke objek itu sendiri atau hanya id itu

Sesuatu menyukai ini:

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

gunakan kode ini 100% memperbaiki masalah Anda

masukkan kode ini di firstFragment

public static yourNameParentFragment newInstance() {

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

sampel ini mengirim data boolean

dan di SecendFragment

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

nilai harus di fragmen pertama adalah statis

kode bahagia

Cara terbaik untuk membuat instance fragmen adalah menggunakan metode Fragment.instantiate default atau membuat metode pabrik untuk instantiate fragmen
Perhatian: selalu buat satu konstruktor kosong dalam fragmen yang lain sementara mengembalikan memori fragmen akan membuang pengecualian run-time.

Akhir-akhir ini saya di sini. Tapi kadang-kadang saya tahu itu mungkin sedikit membantu Anda.

Jika Anda menggunakan Java, tidak ada banyak yang berubah. Tetapi untuk pengembang kotlin, berikut adalah beberapa cuplikan berikut yang menurut saya dapat membuat Anda menjadi ruang bawah tanah untuk dijalankan:

• Fragmen induk:

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

• Panggilan normal

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

• Anda dapat memperluas operasi init induk di kelas fragmen anak dengan:

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

Selamat coding.

setArguments()tidak berguna. Itu hanya membawa kekacauan.

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

Saya yakin saya punya solusi yang lebih sederhana untuk ini.

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