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

话虽如此，传递东西到你的碎片，使他们可用后，一个碎片被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;
}

稍后在Fragment onCreate()中，你可以使用:

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

即使Fragment被Android以某种方式重新创建，这个Bundle也将可用。

还要注意:setArguments只能在Fragment被附加到Activity之前被调用。

这种方法也记录在android开发者参考:https://developer.android.com/reference/android/app/Fragment.html

使用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()来实例化一个片段是一个很好的实践。

还有另一种方法:

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

我不同意yydi的回答:

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

我认为这是一个很好的解决方案，这正是它被Java核心语言开发的原因。

确实，Android系统可以破坏和重建你的碎片。所以你可以这样做:

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

它将允许您稍后从getArguments()中提取someInt，即使该Fragment已被系统重新创建。这是比静态构造函数更优雅的解决方案。

在我看来，静态构造函数是无用的，不应该使用。此外，如果将来你想扩展这个Fragment并向构造函数添加更多功能，它们也会限制你。使用静态构造函数你不能这样做。

更新:

Android增加了标记所有非默认构造函数错误的检查。 由于上面提到的原因，我建议禁用它。

我相信我有一个更简单的解决方案。

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

由于关于最佳实践的问题，我想补充一点，在使用一些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);
    }
}

而@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方法。

实例化片段的最好方法是使用默认的片段。实例化方法或创建工厂方法来实例化片段 注意:总是在片段中创建一个空构造函数，而在恢复片段内存时会抛出运行时异常。

在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系统重新创建fragment时，如果它觉得系统需要更多内存，它就会使用不带参数的构造函数重新创建fragment。

你可以在这里找到更多关于用参数实例化片段的最佳实践的信息。

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

一些kotlin代码:

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

使用此代码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");

必须值在第一个片段是静态的

快乐的代码

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

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

快乐的编码。

你可以这样使用smth:

val fragment = supportFragmentManager.fragmentFactory.instantiate(classLoader, YourFragment::class.java.name)

因为这个答案现在已经被弃用了

理想情况下，我们不应该在片段构造函数中传递任何东西，片段构造函数应该是空的或默认的。 现在第二个问题是，如果我们想传递接口变量或参数 我们应该使用Bundle来传递数据。 对于Interface，我们可以在bundle中putParceble，并使该接口实现parceble 如果可能的话，我们可以在活动和片段中实现该接口，我们可以在OnAttach中初始化监听器，在那里我们有上下文[(上下文)监听器]。

因此，在配置更改期间(例如字体更改)，Activity重新创建侦听器不会去非初始化，我们可以避免空指针异常。

使用kotlin代码创建片段的实例。

在活动中写入

val fragment = YourFragment.newInstance(str = "Hello",list = yourList)

分段写作

fun newInstance(str: String, list: ArrayList<String>): Fragment {
        val fragment = YourFragment()
        fragment.arguments = Bundle().apply {
            putSerializable("KEY_STR", str)
            putSerializable("KEY_LIST", list)
        }
        return fragment
    }

使用相同的片段从bundle中检索数据

val str = arguments?.getString("KEY_STR") as? String
val list = arguments?.getSerializable("KEY_LIST") as? ArrayList<String>