使用自定义对象创建片段

好的，所以你的问题是，是的，

1.) 需要将数据作为参数传入Fragment，否则进程死亡会吃掉它

但是

2.) FragmentPagerAdapter/FragmentStatePagerAdapter 仅在 getItem() 尚未添加时实例化 Fragment，因此使用诸如 pagerAdapter.addFragment(fragment) 之类的东西是一种反模式，会杀死您的代码。如果您想动态创建对象，您需要将 SlideData 传递给适配器，并在 SlideFragment 中为提供的位置创建一个 pagerAdapter.getItem()，使用 SlideData 作为来自正确的参数位置。即使在进程终止后，此 SlideData 也必须正确构造才能使其正常工作。

或者，你可以用0初始化一个ViewPager，然后动态添加片段，只要使用如下代码：

public class DynamicFragmentPagerAdapter extends PagerAdapter {
    private static final String TAG = "DynamicFragmentPagerAdapter";
  
    private final FragmentManager fragmentManager;
  
    public static abstract class FragmentIdentifier implements Parcelable {
        private final String fragmentTag;
        private final Bundle args;
      
        public FragmentIdentifier(@NonNull String fragmentTag,@Nullable Bundle args) {
            this.fragmentTag = fragmentTag;
            this.args = args;
        }
      
        protected FragmentIdentifier(Parcel in) {
            fragmentTag = in.readString();
            args = in.readBundle(getClass().getClassLoader());
        }

        @Override
        public void writeToParcel(Parcel dest,int flags) {
            dest.writeString(fragmentTag);
            dest.writeBundle(args);
        }
      
        protected final Fragment newFragment() {
            Fragment fragment = createFragment();
            Bundle oldArgs = fragment.getArguments();
            Bundle newArgs = new Bundle();
            if(oldArgs != null) {
                newArgs.putAll(oldArgs);
            }
            if(args != null) {
                newArgs.putAll(args);
            }
            fragment.setArguments(newArgs);
            return fragment;
        }

        protected abstract Fragment createFragment();
    }
  
    private ArrayList<FragmentIdentifier> fragmentIdentifiers = new ArrayList<>();

    private Fragmenttransaction currenttransaction = null;

    private Fragment currentPriMaryItem = null;

    public DynamicFragmentPagerAdapter(FragmentManager fragmentManager) {
        this.fragmentManager = fragmentManager;
    }

    privatE int findIndexIfAdded(FragmentIdentifier fragmentIdentifier) {
        for (int i = 0,size = fragmentIdentifiers.size(); i < size; i++) {
            FragmentIdentifier identifier = fragmentIdentifiers.get(i);
            if (identifier.fragmentTag.equals(fragmentIdentifier.fragmentTag)) {
                return i;
            }
        }
        return -1;
    }

    public void addFragment(FragmentIdentifier fragmentIdentifier) {
        if (findIndexIfAdded(fragmentIdentifier) < 0) {
            fragmentIdentifiers.add(fragmentIdentifier);
            notifyDataSetChanged();
        }
    }

    public void removeFragment(FragmentIdentifier fragmentIdentifier) {
        int index = findIndexIfAdded(fragmentIdentifier);
        if (index >= 0) {
            fragmentIdentifiers.remove(indeX);
            notifyDataSetChanged();
        }
    }

    @Override
    public int getCount() {
        return fragmentIdentifiers.size();
    }

    @Override
    public void startupdate(@NonNull ViewGroup container) {
        if (container.getId() == View.NO_ID) {
            throw new IllegalStateException("ViewPager with adapter " + this
                    + " requires a view id");
        }
    }

    @SuppressWarnings("ReferenceEquality")
    @NonNull
    @Override
    public Object instantiateItem(@NonNull ViewGroup container,int position) {
        if (currenttransaction == null) {
            currenttransaction = fragmentManager.begintransaction();
        }
        final FragmentIdentifier fragmentIdentifier = fragmentIdentifiers.get(position);
        // Do we already have this fragment?
        final String name = fragmentIdentifier.fragmentTag;
        Fragment fragment = fragmentManager.findFragmentByTag(Name);
        if (fragment != null) {
            currenttransaction.attach(fragment);
        } else {
            fragment = fragmentIdentifier.newFragment();
            currenttransaction.add(container.getId(),fragment,fragmentIdentifier.fragmentTag);
        }
        if (fragment != currentPriMaryItem) {
            fragment.setMenuVisibility(false);
            fragment.setUservisibleHint(false);
        }
        return fragment;
    }

    @Override
    public void destroyItem(@NonNull ViewGroup container,int position,@NonNull Object object) {
        if (currenttransaction == null) {
            currenttransaction = fragmentManager.begintransaction();
        }
        currenttransaction.detach((Fragment) object);
    }

    @SuppressWarnings("ReferenceEquality")
    @Override
    public void setPriMaryItem(@NonNull ViewGroup container,@NonNull Object object) {
        Fragment fragment = (Fragment) object;
        if (fragment != currentPriMaryItem) {
            if (currentPriMaryItem != null) {
                currentPriMaryItem.setMenuVisibility(false);
                currentPriMaryItem.setUservisibleHint(false);
            }
            fragment.setMenuVisibility(true);
            fragment.setUservisibleHint(true);
            currentPriMaryItem = fragment;
        }
    }

    @Override
    public void finishupdate(@NonNull ViewGroup container) {
        if (currenttransaction != null) {
            currenttransaction.commitNowAllowingStateLoss();
            currenttransaction = null;
        }
    }

    @Override
    public Boolean isViewFromObject(@NonNull View view,@NonNull Object object) {
        return ((Fragment) object).getView() == view;
    }

    @Override
    public Parcelable saveState() {
        Bundle bundle = new Bundle();
        bundle.putParcelableArrayList("fragmentIdentifiers",fragmentIdentifiers);
        return bundle;
    }

    @Override
    public void restoreState(Parcelable state,ClassLoader loader) {
        Bundle bundle = ((BundlE)statE);
        bundle.setClassLoader(loader);
        fragmentIdentifiers = bundle.getParcelableArrayList("fragmentIdentifiers");
    }
}

3.) 您不能将侦听器传递给 Fragment。有 3 种从片段进行通信的方式：

• a.) 通过 fragment.setTargetFragment()，但前几天已弃用。

• b.) 通过 FragmentResultListener，但不能保证您的 Fragment 将由 Fragment 创建，而不是由 Activity 创建。此外，适配器永远不会终止“为了结果”，因此在这种情况下这不起作用。

• c.) SlideFragment 应公开由父片段或主机活动实现的接口 SlideFragment.SlideButtonInterface。

为此，您需要进行分层查找：

private SlideButtonInterface slideButtonInterface = null;

@Override
protected void onCreate(Bundle savedInstanceStatE) {
    super.onCreate(savedInstanceStatE);

    Fragment parentFragment = null;
    while((parentFragment = getParentFragment()) != null) {
        if(parentFragment instanceof SlideButtonInterfacE) {
            this.slideButtonInterface = (SlideButtonInterfacE) parentFragment;
            break;
        }
    }

    if(slideButtonInterface == null) {
        slideButtonInterface = (SlideButtonInterfacE)getActivity();
    }
}

这样，父片段或活动都可以处理此片段的事件，而无需从外部显式传入。