我最近在这里。但我知道的一些事也许能帮到你。

如果您正在使用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")

你可以在子fragment类中扩展父init操作:

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

快乐的编码。

而@yydl给出了一个令人信服的理由，为什么newInstance方法更好:

如果Android决定稍后重新创建Fragment，它会调用 片段的无参数构造函数。重载 构造函数不是解决方案。

仍然可以使用构造函数。要了解原因，首先我们需要了解为什么Android使用上述解决方案。

在使用片段之前，需要一个实例。Android调用YourFragment()(无参数构造函数)来构造一个片段的实例。这里你写的任何重载构造函数都将被忽略，因为Android不知道该使用哪个构造函数。

在一个Activity的生命周期中，fragment会像上面那样被创建，并被Android多次销毁。这意味着如果您将数据放在片段对象本身中，一旦片段被销毁，这些数据就会丢失。

为了解决问题，android要求你使用一个Bundle存储数据(调用setArguments())，然后可以从YourFragment访问。参数包受到Android的保护，因此保证是持久化的。

设置这个bundle的一种方法是使用静态的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要求参数只在构造时设置，并保证这些参数将被保留。

编辑:正如@JHH在评论中指出的，如果你提供了一个需要一些参数的自定义构造函数，那么Java不会为你的片段提供一个无参数的默认构造函数。所以这需要你定义一个无参数构造函数，这是你可以用newInstance工厂方法避免的代码。

编辑:Android不再允许对片段使用重载构造函数。您必须使用newInstance方法。

使用newInstance()的唯一好处是:

You will have a single place where all the arguments used by the fragment could be bundled up and you don't have to write the code below everytime you instantiate a fragment. Bundle args = new Bundle(); args.putInt("someInt", someInt); args.putString("someString", someString); // Put any other arguments myFragment.setArguments(args); Its a good way to tell other classes what arguments it expects to work faithfully(though you should be able to handle cases if no arguments are bundled in the fragment instance).

因此，我认为使用静态newInstance()来实例化一个片段是一个很好的实践。

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

还有另一种方法:

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

由于关于最佳实践的问题，我想补充一点，在使用一些REST web服务时，使用混合方法来创建片段通常是一个好主意

我们不能传递复杂的对象，例如一些用户模型，以防显示用户片段

但我们能做的是，签入onCreate那个用户!=null，如果不是-那么把他从数据层，否则-使用现有。

通过这种方式，我们获得了在Android和snappiness的情况下通过userId重新创建片段的能力，以及通过持有对象本身或仅它的id来创建片段的能力

是这样的:

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