您可以在Object类中实现Serializable，然后使用bundle简单地传递它。我假设你从你的first_fragment启动second_fragment。

• 在您的第一个片段中：*

FragmentTransaction ft =  getActivity().getSupportFragmentManager().beginTransaction();
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
Fragment2 fragment2 = new Fragment2();

Bundle bundle = new Bundle();
YourObj obj = SET_YOUR_OBJECT_HERE;
bundle.putSerializable("your_obj", obj);
fragment2.setArguments(bundle);
ft.replace(android.R.id.content, fragment2);
ft.addToBackStack(null);
ft.commit();

• 片段二 *

Bundle bundle = getArguments();
YourObj obj= (YourObj) bundle.getSerializable("your_obj");

要序列化对象，只需在Object类中实现Serializable。
如果Object类是YourObj.class

public class YourObj implements Serializable {
    int id;
    String name;

    // GETTERS AND SETTERS
}

通过使模型类Serializable或Parcelable，可以在片段和Activity之间传递对象。
Parcelable是一个Android类，可以支持更复杂的类序列化。在这里检查Parceble类的实现：http://shri.blog.kraya.co.uk/2010/04/26/android-parcel-data-to-pass-between-activities-using-parcelable-classes/
Serializable是一个Java类，适用于小对象。对于可序列化访问，请单击此处：https://developer.android.com/reference/java/io/Serializable.html
假设你的模型类是NewObject，那么在你的fragment类中使用以下命令：

Fragment fragment = new Fragment();
NewObject newObject = new NewObject();

Bundle bundle = new Bundle();
bundle.putParcelable("Object", newObject);
fragment.setArguments(bundle);

要从另一个fragment中的bundle中获取它，请在onCreate函数中使用：

NewObject newObject = (NewObject) bundle.getParcelable("Object");

数据保持器类别：

public class DataHolder implements Serializable{

        private String name,id;

        public DataHolder(String id, String name) {
            this.id = id;
            this.name = name;

        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

片段A：

DataHolder dataholder=new DataHolder("1","TestName");
    Bundle bundle=new Bundle();
    bundle.putSerializable("obj",dataholder);

    Fragment fragment=new FragmentB();
    fragment.setArguments(bundle);
    fragmentManager = getActivity(). getSupportFragmentManager();
    fragmentTransaction = fragmentManager .beginTransaction();
    fragmentTransaction.add(R.id.container, fragment);
    fragmentTransaction.commit();

片段B：

DataHolder dataholder = (DataHolder)getArguments().getSerializable(obj);

在承载这些片段的Activity中，定义一个变量，

public class HomeActivity{

    public User mUser;
    ...
}

现在，在你的片段中，当你从你的API得到响应时，在Activity中初始化变量User如下：

@Override
public void onClick(View view) {
    JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(Request.Method.GET, getString(R.string.RESTAPI_URL), null, new Response.Listener<JSONObject>() {

        @Override
        public void onResponse(JSONObject response) {
            Log.d("Response: ",response.toString());
            Gson gson = new Gson();
            User user = gson.fromJson(String.valueOf(response),User.class);

            // initialise User variable in Home Activity
            ((HomeActivity)getActivity()).mUser = user;
        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            Log.d("ErrorResponse: ",error.toString());
        }
    });
      RequestQueue requestQueue = Volley.newRequestQueue(getActivity());
      requestQueue.add(jsonObjectRequest);

}
假设你的User类实现了Parcelable接口，如果没有，那么就把这个类变成Parcelable。这与Java中的Serializable工作原理相同，但Parcelable针对Android进行了优化。
最后，当你加载第二个片段时，简单地将User对象传递给第二个片段，如下所示：

SecondFragment secondFragment = new SecondFragment();
Bundle bundle = new Bundle();
bundle.putParcelable("ARG_USER", user);
secondFragment.setArguments(bundle);
//...code for loading second fragment

当你需要在片段之间传递有限的数据时，你可以使用Bundle示例。如果你有复杂的对象要传递，你更喜欢接口而不是其他方式。你也可以检查参考的链接

• https://developer.android.com/training/basics/fragments/communicating.html
• Communicating between a fragment and an activity - best practices.

你可以试试这样。在你的第一个片段里

Outlet outlet=New Outlet;
Bundle bundle = new Bundle();
bundle.putSerializable("outlet",outlet);
Fragment frag=null;
frag=new Outlet_Edit();
if(frag!=null){
   frag.setArguments(bundle);
   FragmentManager fragmentManager=getActivity().getSupportFragmentManager();
   FragmentTransaction ft=fragmentManager.beginTransaction();
   ft.replace(R.id.sacreenarea,frag);
   ft.commit();
}

在你的第二个碎片里

//second Fragmnet
Outlet editing_outlet=(Outlet) getArguments().getSerializable("outlet");
Log.d("Editing Outlet",editing_outlet.toString());

对象应该是这样的。

public class Outlet implements Serializable {
String id;
String shopname;
String shopowner;
String address;
String contact;
String marketid;

public String getId() {
    return id;
}

public void setId(String id) {
    this.id = id;
}

public String getShopname() {
    return shopname;
}

public void setShopname(String shopname) {
    this.shopname = shopname;
}

public String getShopowner() {
    return shopowner;
}

public void setShopowner(String shopowner) {
    this.shopowner = shopowner;
}

public String getAddress() {
    return address;
}

public void setAddress(String address) {
    this.address = address;
}

public String getContact() {
    return contact;
}

public void setContact(String contact) {
    this.contact = contact;
}

public String getMarketid() {
    return marketid;
}

public void setMarketid(String marketid) {
    this.marketid = marketid;
}

@Override
public String toString() {
    return "Outlet{" +
            "id='" + id + '\'' +
            ", shopname='" + shopname + '\'' +
            ", shopowner='" + shopowner + '\'' +
            ", address='" + address + '\'' +
            ", contact='" + contact + '\'' +
            ", marketid='" + marketid + '\'' +
            '}';
}

}