Найкраща практика для створення нового фрагмента Android

Я бачив дві загальні практики для створення нового Фрагменту в додатку:

Fragment newFragment = new MyFragment();

і

Fragment newFragment = MyFragment.newInstance();

Другий варіант використовує статичний метод newInstance()і, як правило, містить наступний метод.

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

Спочатку я подумав, що головна вигода полягає в тому, що я можу перевантажити метод newInstance (), щоб надати гнучкість при створенні нових екземплярів фрагмента, але я також міг би це зробити, створивши перевантажений конструктор для Fragment.

Я щось пропустив?

Які переваги одного підходу над іншим? Або це просто хороша практика?

Якщо Android вирішить відтворити ваш фрагмент пізніше, він викличе конструктор без аргументу вашого фрагмента. Тож перевантаження конструктора - це не рішення.

Зважаючи на це, спосіб передавати матеріали до Вашого Фрагменту, щоб вони були доступні після того, як Android відтворив Фрагмент, - це передати пакет setArgumentsметоду.

Так, наприклад, якби ми хотіли передати фрагмент цілому числу, ми використали б щось на зразок:

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

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

    return myFragment;
}

А пізніше у Фрагменті onCreate()ви можете отримати доступ до цього цілого числа за допомогою:

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

Цей пакет буде доступний, навіть якщо фрагмент якимось чином відтворений Android.

Також зверніть увагу: setArgumentsможна викликати лише до того, як фрагмент буде приєднано до активності.

Цей підхід також задокументований у довідці для розробників Android: https://developer.android.com/reference/android/app/Fragment.html

Єдиною перевагою використання того, newInstance()що я бачу, є наступне:

1. У вас буде єдине місце, де всі аргументи, використані фрагментом, можуть бути зв'язані, і вам не доведеться писати код нижче кожного разу, коли фрагмент інстанціюється.

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

2. Це хороший спосіб розповісти іншим класам, які аргументи очікують, щоб вони сумлінно працювали (хоча ви повинні мати можливість обробляти випадки, якщо в екземплярі фрагмента не вкладені аргументи).

Отже, я вважаю, що використання статики newInstance()для екземпляру фрагмента є хорошою практикою.

Існує також інший спосіб:

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

Хоча @yydl наводить вагомі причини, чому newInstanceметод краще:

Якщо Android вирішить відтворити ваш фрагмент пізніше, він викличе конструктор без аргументу вашого фрагмента. Тож перевантаження конструктора - це не рішення.

все-таки цілком можливо використовувати конструктор . Щоб зрозуміти, чому це так, спершу нам потрібно розібратися, чому саме вищевказане рішення використовується Android.

Перш ніж фрагмент можна буде використовувати, потрібен екземпляр. Android закликає YourFragment()( конструктор без аргументів ), щоб сконструювати примірник фрагмента. Тут будь-який перевантажений конструктор, який ви пишете, буде ігнорований, оскільки Android не може знати, який з них використовувати.

За час діяльності фрагмент створюється як вище та знищується Android декілька разів. Це означає, що якщо ви введете дані в сам об’єкт фрагмента, він буде втрачений, як тільки фрагмент буде знищений.

Для вирішення проблеми Android вимагає, щоб ви зберігали дані за допомогою Bundle(дзвінка setArguments()), до якого потім можна отримати доступ YourFragment. Аргументи bundleзахищені Android, а значить, гарантовано зберігаються .

Один із способів встановити цей пакет - за допомогою статичного newInstanceметоду:

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

Однак конструктор:

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

може зробити те саме, що і newInstanceметод.

Звичайно, це не вдасться, і це одна з причин Android хоче, щоб ви використовували newInstanceметод:

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

Для подальшого пояснення ось клас фрагментів 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;
}

Зауважте, що Android просить встановити аргументи лише під час будівництва, і гарантує, що вони будуть збережені.

EDIT : Як зазначалося в коментарях @JHH, якщо ви надаєте користувальницький конструктор, який вимагає певних аргументів, Java не надасть вашому фрагменту конструктор за замовчуванням без аргументів . Тому для цього потрібно визначити конструктор no arg , який є кодом, якого ви можете уникнути newInstanceфабричним методом.

EDIT : Android більше не дозволяє використовувати перевантажений конструктор для фрагментів. Ви повинні використовувати newInstanceметод.

Я не погоджуюся з відповіддю yydi :

Якщо Android вирішить відтворити ваш фрагмент пізніше, він викличе конструктор без аргументу вашого фрагмента. Тож перевантаження конструктора - це не рішення.

Я думаю, що це рішення і добре, саме ця причина була розроблена базовою мовою Java.

Це правда, що система Android може знищити та відтворити вашу Fragment. Тож ви можете зробити це:

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

Це дозволить вам витягнути someIntз getArguments()останнього, навіть якщо система Fragmentбула відтворена. Це більш елегантне рішення, ніж staticконструктор.

На мою думку, staticконструктори марні і їх не слід використовувати. Крім того, вони обмежать вас, якщо в майбутньому ви хочете розширити це Fragmentі додати більше функціональних можливостей конструктору. З staticконструктором ви не можете цього зробити.

Оновлення:

Android додав перевірку, що позначає помилки всіх конструкторів, що не використовуються за замовчуванням, з помилкою.
Рекомендую відключити його з причин, зазначених вище.

Деякий Котлин код:

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

І ви можете отримати аргументи з цим:

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

Найкраща практика для встановлення фрагментів з аргументами в android - це статичний заводський метод у вашому фрагменті.

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

Вам слід уникати встановлення полів з екземпляром фрагмента. Тому що, коли android система відтворює ваш фрагмент, якщо він відчуває, що системі потрібно більше пам'яті, то вона відтворить ваш фрагмент, використовуючи конструктор без аргументів.

Ви можете знайти більше інформації про найкращу практику інсталяції фрагментів з аргументами тут.

Оскільки до питань найкращої практики я додам, що дуже часто добре використовувати гібридний підхід для створення фрагмента під час роботи з деякими веб-сервісами REST

Ми не можемо передавати складні об'єкти, наприклад, якусь модель користувача, для відображення фрагмента користувача

Але те, що ми можемо зробити, - це перевірити onCreateцього користувача! = Null, а якщо ні - то вивести його з рівня даних, інакше - використовувати існуючий.

Таким чином ми отримуємо як здатність відтворювати користувальницьким користувачем у випадку відтворення фрагментів на Android, так і легкість для дій користувача, а також можливість створювати фрагменти, тримаючи за об’єкт себе або лише його ідентифікатор

Щось подібне:

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

використовувати цей код на 100% виправити свою проблему

введіть цей код у firstFragment

public static yourNameParentFragment newInstance() {

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

цей зразок надсилає булеві дані

і в SecendFragment

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

Значення "must" в першому фрагменті є статичним

щасливий код

Найкращий спосіб інстанціювати фрагмент - це використовувати метод Fragment.instantiate за замовчуванням або створити заводський метод для інстанціювання фрагмента
Обережно: завжди створюйте один порожній конструктор у фрагменті інший, тоді як відновлення пам’яті фрагмента призведе до виключення часу виконання.

Я останнім часом тут. Але я щойно знав, що може вам трохи допомогти.

Якщо ви використовуєте Java, нічого особливо змінити не можна. Але для розробників kotlin ось наступний фрагмент, який я думаю, що може зробити вас підвалом для роботи:

• Батьківський фрагмент:

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

• Нормальний дзвінок

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

• Ви можете продовжити батьківську операцію init у класі дочірнього фрагмента:

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

Щасливе кодування.

setArguments()марно. Це лише вносить безлад.

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

Я вважаю, що у мене є набагато спрощене рішення для цього.

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