我看到在应用程序中实例化新 Fragment 有两种常见的做法：
Fragment newFragment = new MyFragment();
并且
Fragment newFragment = MyFragment.newInstance();
第二种选项使用静态方法 newInstance()，通常 包含以下方法。
public static Fragment newInstance()
{
MyFragment myFragment = new MyFragment();
return myFragment;
}
一开始，我认为最主要的好处是可以重载newInstance()方法，在创建Fragment的新实例时提供灵活性 - 但是我也可以通过为Fragment创建重载构造函数来实现这一点。
我有什么遗漏吗？
一种方法的优势在于另一种方法吗？还是说只是好的实践？
如果Android决定稍后重新创建您的Fragment，它将调用您的fragment的无参构造函数。因此，重载构造函数不是解决方案。
话虽如此，将东西传递给Fragment的方法，以便在Android重新创建Fragment后它们仍然可用，是将Bundle传递给setArguments方法。
因此，例如，如果我们想将整数传递给Fragment，我们可以使用以下内容：
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()的唯一好处如下：
你可以将所有用于片段的参数捆绑到一个单独的位置，这样每次实例化片段时就不必再写下面的代码了。
Bundle args = new Bundle();
args.putInt("someInt", someInt);
args.putString("someString", someString);
// Put any other arguments
myFragment.setArguments(args);
这是告诉其他类它期望哪些参数能够正常工作的好方法（虽然如果在片段实例中没有绑定任何参数，你应该能够处理这种情况）。
因此，我认为使用静态的newInstance()来实例化一个片段是一种好的做法。
还有另一种方法：
Fragment.instantiate(context, MyFragment.class.getName(), myBundle)
instantiate(...)方法已被弃用。此外，我认为创建片段的方法并不好。 - Yekta Sarıoğlu虽然@yydl提供了关于newInstance方法更好的原因：
如果Android决定稍后重新创建您的Fragment，则会调用您的fragment的无参构造函数。因此，重载构造函数并不是一个解决方案。
但仍然可以使用构造函数。为了理解这一点，首先需要了解Android使用上述解决方法的原因。
在使用片段之前，需要一个实例。Android调用YourFragment()（即无参数构造函数）来构造片段的实例。在这里，您编写的任何重载构造函数都将被忽略，因为Android无法知道要使用哪个构造函数。
在Activity的生命周期中，Android多次创建并销毁片段。这意味着，如果将数据放入片段对象本身中，则一旦销毁片段，该数据将丢失。
为了解决这个问题，Android要求您使用Bundle存储数据（调用setArguments()），然后可以从YourFragment访问该数据。参数bundle由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
}
/**
* 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;
}
一些 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"}
@JvmStatic注解是最佳实践吗？ @JvmStatic fun newInstance(bundle: Bundle) = SomeFragment().apply { arguments = bundle } - AdamHurwitz我不赞同yydi在回答中所说的：
如果Android决定以后重新创建你的Fragment，它会调用你的fragment的无参构造函数。因此，重载构造函数并不是一个解决方案。
我认为这是一种解决方案，而且是一个好的解决方案，这正是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);
}
它将使您能够在稍后从getArguments()中提取someInt，即使系统重建了Fragment。这比使用static构造函数更为优雅。
在我看来，static构造函数是无用的，不应该被使用。此外，如果将来想要扩展此Fragment并向构造函数添加更多功能，它们会对您造成限制。使用static构造函数就不能实现这一点。
更新：
Android添加了一个检查，用于标记所有非默认构造函数的错误。
出于上述原因，我建议禁用它。
我最近来到这里。但是有些东西我刚刚知道，可能会对您有所帮助。
如果您正在使用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")
fun newInstance(): ChildSampleFragment {
val child = UserProfileFragment.newInstance<ChildSampleFragment>("XYZ")
// Do anything with the current initialized args bundle here
// with child.arguments = ....
return child
}
愉快的编码。
在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;
}
针对最佳实践的问题，我想补充一下，在使用某些 REST web 服务时，通常使用混合方法来创建片段是一个很好的主意。
我们无法传递复杂对象，例如某个用户模型，以便显示用户片段。
但是我们可以在 onCreate 中检查 user!=null，如果不是，则从数据层获取它，否则使用现有的。
这样，我们既能够通过 userId 在 Android 中重新创建片段，又能够让用户操作更加迅速，并且还能够通过保存对象本身或仅其 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);
}
}
User user = /*...*/;
//将用户放入Bundle：
Bundle bundle = new Bundle();
bundle.putParcelable("some_user", user);
//从参数中获取用户：
User user = getArguments().getParcelable("some_user");对象必须实现Parcelable接口。链接 - Adam VarhegyiputParceble并使该接口实现parcebleOnAttach中初始化监听器，在那里我们有上下文[(上下文) Listener]。这样，在配置更改（例如字体更改）期间，Activity重建侦听器将不会未初始化，并且我们可以避免空指针异常。