我已经看到了在应用程序中实例化一个新Fragment的两个通用实践:
Fragment newFragment = new MyFragment();
and
Fragment newFragment = MyFragment.newInstance();
第二个选项使用静态方法newInstance()，通常包含以下方法。
public static Fragment newInstance()
{
MyFragment myFragment = new MyFragment();
return myFragment;
}
起初，我认为主要的好处是，我可以重载newInstance()方法，以便在创建新的Fragment实例时提供灵活性——但我也可以通过为Fragment创建重载构造函数来实现这一点。
我错过什么了吗?
一种方法相对于另一种方法有什么好处?还是说这只是一个很好的练习?
当前回答
我最近在这里。但我知道的一些事也许能帮到你。
如果您正在使用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
}
快乐的编码。
其他回答
我相信我有一个更简单的解决方案。
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;
}
一些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"}
你可以这样使用smth:
val fragment = supportFragmentManager.fragmentFactory.instantiate(classLoader, YourFragment::class.java.name)
因为这个答案现在已经被弃用了
由于关于最佳实践的问题，我想补充一点，在使用一些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);
}
}
我不同意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增加了标记所有非默认构造函数错误的检查。 由于上面提到的原因，我建议禁用它。
