Praktik terbaik untuk membuat Instansiasi Android baru


706

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?


Ketika ada parameter, tidak ada pilihan, dan ini dijawab secara luas di sini. Namun, pertanyaannya tetap untuk konstruksi fragmen tanpa argumen.
rds

1
Setelah mempelajari tentang pola pabrik dan bagaimana kelas panggilan yang tidak membuat instance objek itu sendiri membantu dalam memisahkan mereka, saya pikir ini akan menjadi titik kuat untuk metode newInstance (). Apakah saya salah dalam hal ini? Saya belum melihat argumen khusus ini diucapkan sebagai manfaat.
Aplikasi Mobile

Jawaban:


1137

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


7
@Vlasto sayangnya metode statis tidak dapat diganti.
AJD

8
@yydl Saya rasa saya kehilangan sesuatu di sini, tidak bisakah Anda menggunakan konstruktor di sini, yang menciptakan Bundle dan memanggil setArguments () masih karena itu hanya akan dipanggil oleh kode Anda (dan bukan ketika Android menciptakan kembali Anda pecahan)?
Mike Tunnicliffe

9
@ mgibson Anda harus menggunakan bundel jika Anda ingin data tersedia saat fragmen nanti dibuat kembali.
yydl

114
Menjadi FORCED untuk membuat konstruktor tanpa argumen untuk fragmen-fragmen berpotensi menjadi satu-satunya gotcha terbesar di semua pemrograman, di mana saja. Ini memaksa pergeseran paradigma lengkap dalam pembuatan dan inisialisasi objek. Jika Anda baru mengenal Android dan telah menemukan utas ini, harap baca jawaban di atas berulang kali.
rmirabelle

9
Saya akan berdebat dengan pernyataan itu. Pertama, keamanan jenis adalah masalah bahasa, bukan masalah kerangka kerja. Kedua, IMO, kerangka kerja ini melangkah ke bidang "hal-hal yang tidak boleh dilakukan oleh API Anda". Jika saya ingin meneruskan perpustakaan kongres ke dalam konstruktor fragmen saya, maka saya seharusnya diizinkan. Kontrak konstruktor "tanpa argumen" pada dasarnya membunuh penggunaan injeksi dependensi dalam fragmen - yuck besar.
rmirabelle

95

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.


4
1) Apa bedanya dengan meletakkan logika di konstruktor? Keduanya adalah satu tempat di mana Anda memasukkan logika ini. 2) Bagaimana perbedaan pada pabrik statis berbeda dengan parameter pada konstruktor? Keduanya memberi tahu argumen apa yang diharapkan. Maksud saya adalah paradigma yang berbeda, tentu saja, tetapi tidak ada manfaat yang jelas untuk ini daripada menggunakan konstruktor.
RJ Cuthbertson

2
Anda tidak dapat menggunakan konstruktor khusus untuk fragmen. Kerangka menggunakan konstruktor tanpa argumen untuk memulihkan fragmen.
500865

5
Ya, saya setuju dengan Anda di sana. Saya katakan secara konseptual tidak ada manfaatnya menggunakan pola pabrik statis daripada menggunakan konstruktor yang kelebihan beban, dan sebaliknya. Kedua poin Anda valid di kedua pola; tidak ada gunanya menggunakan satu di atas yang lain. Android memaksa Anda untuk menggunakan pola pabrik statis - tetapi tidak ada manfaatnya menggunakan satu atau yang lain.
RJ Cuthbertson

pastebin.com/EYJzES0j
RJ Cuthbertson

@RJCuthbertson Manfaat yang mungkin adalah kemampuan untuk membuat dan mengembalikan subclass dari kelas metode pabrik statis yaitu untuk mengembalikan subclass yang sesuai untuk situasi tersebut.
urgentx

62

Ada juga cara lain:

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

Jika saya tidak salah, ini hanya mungkin ketika Anda menggunakan pustaka Dukungan Android.
Timo

2
Mencoba ini dengan pustaka dukungan, tetapi di onCreateView (dalam fragmen saya), bundel yang berlalu adalah nol, jadi saya pergi dengan opsi setArguments / getArguments dan berhasil (bagi siapa saja yang membaca ini).
Jrop

1
Menarik, saya belum pernah melihat pendekatan ini sebelumnya. Apakah ada kelebihan dibandingkan pendekatan lain untuk membuat Instansiasi?
IgorGanapolsky

22
Dari dokumen pengembang ,instantiate() Creates a new instance of a Fragment with the given class name. This is the same as calling its empty constructor.
Brian Bowman

2
Meskipun mereka disebutkan sama dengan memanggil konstruktor kosong. "args.setClassLoader (f.getClass (). getClassLoader ());" disebut di bawah argumen Bundle
Gökhan Barış Aker

49

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.


Kapan seseorang akan membenarkan menggunakan android: configChanges = "orientasi | keyboardHidden | screenSize"?
Luke Allison

1
Android Studio sekarang melempar kesalahan untuk semua konstruktor non-default dalam fragmen, jadi ini tidak lagi berfungsi.
Sheharyar

6
Orang suci, saya bertanya-tanya berapa banyak pengembang droid yang pernah menulis kode di luar droid. Ini gila karena kami tidak bisa menggunakan pendekatan yang Anda jelaskan. Tidak ada argumen yang menarik dari komentar mengapa kami HARUS menggunakan metode pabrik statis. Ini bahkan lebih mengganggu bahwa mereka akan meningkatkan kesalahan saat kompilasi. Ini jelas merupakan jawaban terbaik yang diberikan dan menunjukkan bahwa tidak ada manfaat bagi sfm.
MPavlak

3
Nah, ada satu alasan halus. Anda bebas membuat konstruktor sendiri dengan argumen, tetapi masih harus ada konstruktor no-arg juga . Karena kelas selalu memiliki konstruktor no-arg implisit kecuali jika konstruktor dengan arg didefinisikan secara eksplisit , ini berarti Anda harus mendefinisikan konstruktor arg dan konstruktor no-arg Anda secara eksplisit, atau sistem tidak akan dapat memanggil konstruktor tanpa arg. Saya percaya ini adalah mengapa rekomendasinya adalah sebagai gantinya menggunakan metode pabrik statis - ini hanya mengurangi risiko lupa mendefinisikan konstruktor no-arg.
JHH

@ JHH yang akan gagal pada waktu kompilasi itu sendiri, jadi bukan risiko besar. Namun, masalah di sini adalah bahwa konstruktor kelebihan beban, paradigma pemrograman utama, ditolak oleh Android.
ps95

20

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.


4
Manfaat lain dari memiliki metode statis, yang tidak saya sebutkan di atas adalah bahwa Anda tidak dapat secara tidak sengaja mengatur properti darinya.
yydl

4
Selain itu, berkenaan dengan poin Anda tentang "memperpanjang fragmen ini", metode ini sebenarnya akan sangat buruk jika Anda pernah memperluas kelas. Memanggil super akan menyebabkan panggilan setArguments () hanya berlaku untuk anak atau orang tua, tetapi tidak keduanya!
yydl

2
@yydle Anda dapat menghindari situasi ini dengan memanggil argumen untuk menginisialisasi Bundle anak. Cara Jawa selalu lebih baik.
Ilya Gazman

9
Benar, tapi itu alasan lain untuk mendorong orang menggunakan pola yang disarankan Google. Tentu saja, kita semua sepakat bahwa solusi Anda 100% layak secara teknis. Sama halnya ada banyak cara untuk melakukan banyak hal. Namun, pertanyaannya adalah apakah itu yang terbaik. Dan saya sangat merasa bahwa menggunakan konstruktor tidak mewakili sifat sebenarnya dari bagaimana ini seharusnya bekerja.
yydl

3
Saya setuju dengan @yydl bahwa kreasi statis lebih baik. Satu manfaat lainnya adalah injeksi dependensi dependensi baru di masa depan - konstruktor tidak cocok untuk itu dan kemungkinan akan menyebabkan lebih banyak perubahan kode (atau lebih banyak konstruktor yang ditambahkan).
Boon

19

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

3

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.


2

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

3
Anda berkata: "Kami tidak dapat melewati objek kompleks, misalnya beberapa model Pengguna," - Itu tidak benar, kami bisa. Seperti ini: User user = /*...*/ letakkan pengguna pada bundel: Bundle bundle = new Bundle(); bundle.putParcelable("some_user", user); dan dapatkan pengguna dari argumen: User user = getArguments().getParcelable("some_user"); Objek harus mengimplementasikan antarmuka Parcelable. tautan
Adam Varhegyi

3
Ya, tapi ketika kelas kompleks dan berisi referensi ke objek lain ... Saya pribadi lebih suka membuatnya sederhana, baik saya punya objek, atau saya tidak dan kemudian perlu mendapatkannya
Tigra

1

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


0

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.


0

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.


-2

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

Kecuali Anda baru saja dipaksa untuk menimpa satu metode lagi dan membuat bidang yang bisa diisolasi ke onViewCreatedruang lingkup. Ini kenyamanan saya kira, banyak cara untuk melakukan hal yang sama. Juga ini adalah cara mudah untuk memeriksa pembaruan yang dilakukan oleh pengguna (bandingkan bundel getArgumentsdan bundel dari onSaveInstanceState)
Overclover

@ Asagen, saya suka komentar Anda tentang membandingkan nilai awal dan nilai pengguna. Saya mengedit kode dan menganggap bahwa itu masih seragam dan menghapus getArgumentshal-hal witout . Bagaimana dengan onViewCreatedruang lingkup ... Kita dapat mengembalikan bundel status di sana. Tapi saya lebih suka membuat onCreateViewringan dan cepat dan melakukan semua inisialisasi berat di dalam onActivityCreatedkarena Fragment.getActivity()kadang-kadang ingin kembali nulldan karena onAttach()perubahan dalam versi baru API 23.
Vadim Star

Yang Anda lakukan di sini adalah pindah set dan get Argumentsmasuk saveInstanceState. Anda pada dasarnya melakukan hal yang sama yang dilakukan "di bawah tenda"
OneCricketeer

1
@ cricket_007, atau sebaliknya . Menggunakan saveInstanceStateadalah "di bawah tenda". Dan penggunaan Argumentsduplikasi fungsi yang membuat Anda memeriksa ulang: Argumentsnilai pertama dan kemudian saveInstanceStatenilai. Karena Anda harus menggunakan saveInstanceStatecara apa pun. Bagaimana dengan Arguments... mereka tidak perlu.
Vadim Star

Argumen adalah setara dengan ekstra Intent untuk fragmen. Mereka tidak berguna, mereka berisi parameter awal yang berbeda dari keadaan saat ini.
BladeCoder

-12

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

12
mObjects akan dihapus jika MyFragment diciptakan ulang (pengguna pergi ke layar beranda perangkat dan kemudian membuka aplikasi yang ditinggalkan di MyFragment). Anda dapat mempertahankan mObjects dengan mengirimkan bundel MyFragment sebagai argumen.
ynnadkrap

1
Juga, bagaimana metode statis mengakses variabel anggota non-statis?
OrhanC1

2
@ynnadkrap Anda benar, menggunakan bundel adalah cara untuk pergi ke sini.
Stefan Bogaard

2
@ OrhanC1 Menurut kode contoh ini, metode statis tidak mengakses ke variabel anggota. Contoh MyFragment sedang mengakses anggota-anggotanya. Tidak ada kesalahan di sini. Namun, saya tidak merekomendasikan jawaban ini kepada siapa pun karena ketika fragmen Anda dihapus dari memori untuk membuka beberapa ruang oleh os android kemudian setelah memulai kembali aktivitas dan fragmen ini akan dibuat dengan konstruktor kosong default tanpa menetapkan variabel semut.
Gunhan

@ Gonghan Kamu benar! Ini bukan. Maaf atas kebingungannya :)
OrhanC1
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.