Android fragment 工厂方法与构造函数重载

Question

首先，我已经知道 FragmentManager 经常使用默认构造函数销毁然后重新创建 Fragment。编码人员必须在工厂方法中将重要的东西保存在 Bundle of arguments 中，然后在每次在 onCreate(Bundle) 中重新创建 Fragment 时将它们取出。

public class MyFragment extends Fragment {
    private static final String MY_STRING_CONSTANT = "param";
    private int mIntegerMember;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mIntegerMember= getArguments().getInt(MY_STRING_CONSTANT);
    }
}

我的问题是，这之间有什么区别吗:

// Inside MyFragment.java
public MyFragment() {
    // No-argument constructor required by the FragmentManager.
}
public static MyFragment newInstance(int param) {
    // Factory method
    MyFragment fragment = new MyFragment();
    Bundle args = new Bundle();
    args.putInt(MY_STRING_CONSTANT, param);
    fragment.setArguments(args);
    return fragment;
}

// Somewhere else
FragmentTransaction transaction = getFragmentManager().beginTransaction();
transaction.add(R.id.frame_layout, MyFragment.newInstance(123)).commit();

还有这个:

// Inside MyFragment.java
public MyFragment() {
    // No-argument constructor required by the FragmentManager.
}
public MyFragment(int param) {
    // Parameterized constructor
    Bundle args = new Bundle();
    args.putInt(MY_STRING_CONSTANT, param);
    setArguments(args);
}

// Somewhere else
FragmentTransaction transaction = getFragmentManager().beginTransaction();
transaction.add(R.id.frame_layout, new MyFragment(123)).commit();

我看不到任何阻止 FragmentManager 调用无参数构造函数的东西。而我保存在参数化构造函数(在 Bundle 对象中)的数据将在 onCreate() 期间被保留和恢复，就像我使用工厂方法时一样。

Answer 1

Android 从不直接调用非默认构造函数(也不是工厂方法)- 从技术上讲，您使用哪个并不重要。在添加 Fragment 之前，您可以随时调用 setArguments(以任意方法，甚至在构造函数中)，如果重新创建 Fragment，将为您保存/恢复该包。 View 也有由 Android 调用的特殊构造函数，但如果您愿意，您可以使用任意参数创建自己的构造函数(Android 不会调用它们)。

Fragment.setArguments 的代码:

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

Fragment.instantiate 的代码:

    /**
     * Create a new instance of a Fragment with the given class name.  This is
     * the same as calling its empty constructor.
     *
     * @param context The calling context being used to instantiate the fragment.
     * This is currently just used to get its ClassLoader.
     * @param fname The class name of the fragment to instantiate.
     * @param args Bundle of arguments to supply to the fragment, which it
     * can retrieve with {@link #getArguments()}.  May be null.
     * @return Returns a new fragment instance.
     * @throws InstantiationException If there is a failure in instantiating
     * the given fragment class.  This is a runtime exception; it is not
     * normally expected to happen.
     */
    public static Fragment instantiate(Context context, String fname, Bundle args) {
        try {
            Class<?> clazz = sClassMap.get(fname);
            if (clazz == null) {
                // Class not found in the cache, see if it's real, and try to add it
                clazz = context.getClassLoader().loadClass(fname);
                sClassMap.put(fname, clazz);
            }
            Fragment f = (Fragment)clazz.newInstance();
            if (args != null) {
                args.setClassLoader(f.getClass().getClassLoader());
                f.mArguments = args;
            }
            return f;
        } catch (ClassNotFoundException e) {
            throw new InstantiationException("Unable to instantiate fragment " + fname
                    + ": make sure class name exists, is public, and has an"
                    + " empty constructor that is public", e);
        } catch (java.lang.InstantiationException e) {
            throw new InstantiationException("Unable to instantiate fragment " + fname
                    + ": make sure class name exists, is public, and has an"
                    + " empty constructor that is public", e);
        } catch (IllegalAccessException e) {
            throw new InstantiationException("Unable to instantiate fragment " + fname
                    + ": make sure class name exists, is public, and has an"
                    + " empty constructor that is public", e);
        }
    }

Fragment.instantiate 在 Android 想要创建您的 Fragment 实例时调用。它简单地调用 Class.newInstance，这是一种使用默认的零参数构造函数创建类的 Java 方法。看看这段代码，创建额外的构造函数并在其中调用 setArguments 似乎没有问题。

作为惯例，在使用 Fragment 时通常使用工厂方法。大多数official sample Fragment code也使用工厂方法。以下是一些可能的原因:

1. 如果您正在编写一个自定义构造函数(带参数)，您还必须指定一个零参数构造函数。一个常见的错误是创建自定义构造函数但忘记定义零参数构造函数 - 当 Android 在重新创建 fragment 时尝试调用零参数构造函数时，这将导致崩溃。

2. 创建自定义构造函数时，您可能会想直接将构造函数参数分配给字段。这几乎是任何其他 Java 类的编写方式(因此您自然会希望这样编写类)。由于 Android 只会在 Fragment 上调用零参数构造函数，因此该数据将不可用于任何重新创建的实例。如您所知，使用 setArguments 是解决此问题的方法。尽管您可以在构造函数中执行此操作，但使用工厂方法会更明显地表明无法以正常方式构造此类，从而减少犯上述错误(或类似错误)的可能性。