Yeni bir Android Parçası oluşturmak için en iyi uygulama

Bir uygulamada yeni bir Parçayı başlatmak için iki genel uygulama gördüm:

Fragment newFragment = new MyFragment();

ve

Fragment newFragment = MyFragment.newInstance();

İkinci seçenek statik bir yöntem kullanır newInstance()ve genellikle aşağıdaki yöntemi içerir.

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

İlk başta, ana fayda, bir Fragment'ın yeni örneklerini oluştururken esneklik sağlamak için newInstance () yöntemini aşırı yükleyebileceğimi düşündüm - ama bunu Fragment için aşırı yüklenmiş bir kurucu oluşturarak da yapabilirim.

Bir şey mi kaçırdım?

Bir yaklaşımın diğerine göre faydaları nelerdir? Yoksa sadece iyi bir uygulama mı?

Android, Parçanızı daha sonra yeniden oluşturmaya karar verirse, parçanızın bağımsız değişken yapıcısını çağırır. Yani kurucuyu aşırı yüklemek bir çözüm değildir.

Bununla birlikte, bir Parçanın Android tarafından yeniden oluşturulduktan sonra kullanılabilir olmaları için parçanıza bir şeyler iletmenin yolu, setArgumentsyönteme bir paket iletmektir .

Örneğin, parçaya bir tamsayıyı iletmek isteseydik şöyle bir şey kullanırdık:

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

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

    return myFragment;
}

Ve daha sonra Fragment'ta onCreate()bu tamsayıya aşağıdakileri kullanarak erişebilirsiniz:

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

Parça bir şekilde Android tarafından yeniden oluşturulmuş olsa bile bu Paket kullanılabilir olacak.

Ayrıca not: setArgumentsyalnızca Fragman Aktiviteye eklenmeden önce çağrılabilir.

Bu yaklaşım aynı zamanda android geliştirici referansında da belgelenmiştir: https://developer.android.com/reference/android/app/Fragment.html

newInstance()Gördüğüm kullanmanın tek yararı şunlardır:

1. Parçanın kullandığı tüm argümanların bir araya getirilebileceği tek bir yeriniz olacak ve bir parçayı her başlattığınızda aşağıdaki kodu yazmak zorunda kalmayacaksınız.

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

2. Diğer sınıflara sadakatle çalışmayı beklediğini söylemenin iyi bir yoludur (ancak parça örneğinde hiçbir argüman paketlenmemişse vakaları işleyebilmelisiniz).

Yani, benim bir newInstance()parçamın örneğini oluşturmak için statik kullanmak iyi bir uygulamadır.

Başka bir yol daha var:

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

@Yydl, newInstanceyöntemin neden daha iyi olduğuna dair zorlayıcı bir neden verirken :

Android, Parçanızı daha sonra yeniden oluşturmaya karar verirse, parçanızın bağımsız değişken yapıcısını çağırır. Yani kurucuyu aşırı yüklemek bir çözüm değildir.

bir kurucu kullanmak hala mümkün . Bunun nedenini görmek için, öncelikle yukarıdaki geçici çözümün Android tarafından neden kullanıldığını görmemiz gerekir.

Bir parçanın kullanılabilmesi için önce bir örneğe ihtiyaç vardır. Parçanın bir örneğini oluşturmak için Android çağrıları YourFragment()( argüman oluşturucu yok ). Android, hangisini kullanacağını bilemediğinden, yazdığınız aşırı yüklenmiş kurucu yok sayılır.

Bir Faaliyetin ömrü boyunca, parça yukarıdaki gibi oluşturulur ve Android tarafından birçok kez imha edilir. Bu, parça nesnesinin kendisine veri koyarsanız, parça yok edildiğinde verilerin kaybolacağı anlamına gelir.

Geçici çözüm olarak, android daha sonra erişilebilen bir Bundle(çağrı setArguments()) kullanarak veri depolamanızı ister YourFragment. Bağımsız değişkenler bundleAndroid tarafından korunur ve bu nedenle kalıcı olması garanti edilir .

Bu paketi ayarlamanın bir yolu statik bir newInstanceyöntem kullanmaktır:

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

Ancak bir kurucu:

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

newInstanceyöntemle tam olarak aynı şeyi yapabilir .

Doğal olarak, bu başarısız olur ve Android'in newInstanceyöntemi kullanmanızı istemesinin nedenlerinden biridir :

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

Daha fazla açıklama olarak, Android'in Fragment Sınıfı:

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

Android'in, argümanların yalnızca yapım aşamasında ayarlanmasını istediğini ve bunların saklanacağını garanti ettiğini unutmayın.

DÜZENLEME : @JHH tarafından yapılan açıklamalarda belirtildiği gibi, bazı bağımsız değişkenler gerektiren özel bir yapıcı sağlıyorsanız, Java parçanıza arg varsayılan yapıcısı sağlamaz . Bu nedenle, bir arg yapıcısı tanımlamanız gerekir , bu da newInstancefabrika yöntemiyle kaçınabileceğiniz koddur .

EDIT : Android artık fragmanlar için aşırı yüklenmiş bir kurucu kullanılmasına izin vermiyor. newInstanceYöntemi kullanmalısınız .

Ben yydi cevap söyleyerek katılmıyorum :

Android, Parçanızı daha sonra yeniden oluşturmaya karar verirse, parçanızın bağımsız değişken yapıcısını çağırır. Yani kurucuyu aşırı yüklemek bir çözüm değildir.

Bence bu bir çözüm ve iyi bir çözüm, Java çekirdek dili tarafından geliştirilmesinin nedeni de tam olarak bu.

Android sistemi yok edebilir ve yeniden oluşturabilirsiniz doğrudur Fragment. Böylece bunu yapabilirsiniz:

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

Sistem tarafından yeniden oluşturulmuş olsa bile someInt, getArguments()ikincisini çekmenize izin verecektir Fragment. Bu, kurucudan daha zarif bir çözümdür static.

Bence staticinşaatçılar işe yaramaz ve kullanılmamalıdır. Ayrıca gelecekte bunu genişletmek Fragmentve yapıcıya daha fazla işlevsellik eklemek isterseniz sizi sınırlarlar . İle staticyapıcı bunu yapamaz.

Güncelleme:

Android, varsayılan olmayan tüm kurucuları hata ile işaretleyen inceleme ekledi.
Yukarıda belirtilen nedenlerden dolayı devre dışı bırakmanızı öneririm.

Bazı kotlin kodu:

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

Ve bununla tartışabilirsiniz:

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

Android'de argümanları olan parçaları örneklemek için en iyi uygulama, parçanızda statik fabrika yöntemine sahip olmaktır.

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

Alanlarınızı bir parça örneği ile ayarlamaktan kaçınmalısınız. Çünkü android sistem parçanızı yeniden oluşturduğunda, sistemin daha fazla belleğe ihtiyacı olduğunu hissediyorsa, argümansız yapıcı kullanarak parçanızı yeniden oluşturacaktır.

Burada argümanlarla fragmanları başlatmak için en iyi uygulama hakkında daha fazla bilgi bulabilirsiniz .

En iyi uygulama ile ilgili sorulardan beri, bazı REST web hizmetleriyle çalışırken parça oluşturmak için hibrit yaklaşımı kullanmak için çok iyi bir fikir olduğunu ekliyorum.

Kullanıcı parçasını görüntüleme durumunda karmaşık nesneleri, örneğin bazı Kullanıcı modelini geçiremeyiz

Ama yapabileceğimiz, check-in yapmak onCreate o kullanıcıyı ! = Null ve eğer değilse - veri katmanından getirin, aksi takdirde - mevcut kullanın.

Bu şekilde, hem Android tarafından parça rekreasyonu ve kullanıcı eylemleri için snappiness durumunda userId tarafından yeniden oluşturma yeteneği, hem de kendisini nesneye tutarak veya yalnızca kimliğini tutarak parça oluşturma yeteneği kazanırız

Bir şey bunu seviyor:

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

bu kodu kullanın% 100 sorununuzu düzeltin

Bu kodu girmek firstFragment

public static yourNameParentFragment newInstance() {

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

bu örnek boole verileri gönderir

ve SecendFragment içinde

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

ilk parçadaki değer statik olmalıdır

mutlu kod

Parçayı örneklemenin en iyi yolu, varsayılan Fragment.instantiate yöntemini kullanmaktır veya parçayı örneklemek için fabrika yöntemi oluşturmaktır
Dikkat: parça belleğini geri yüklerken her zaman parçada bir boş yapıcı oluşturun, çalışma zamanı istisnası atar.

Son zamanlarda buradayım. Ama bildiğim bazı şeyler sana biraz yardımcı olabilir.

Java kullanıyorsanız, değiştirecek çok şey yoktur. Ancak kotlin geliştiricileri için, aşağıdaki bazı snippet'i düşünüyorum, bu da sizi çalıştırmak için bir bodrum yapabilir:

• Üst parça:

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

• Normal çağrı

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

• Alt parça sınıfındaki üst başlatma işlemini şu yollarla genişletebilirsiniz:

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

Mutlu kodlama.

setArguments()yararsızdır. Sadece bir karmaşa getirir.

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

Bunun için çok daha basit bir çözümüm olduğuna inanıyorum.

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