Activity 与 Fragment 通讯(99%)完美施工方案

发布时间:2019-09-10  栏目:Python  评论:0 Comments

前不久间接在想着能不可能有一种更加好的方案来消除:Android中Activity与Fragment之间通讯的难点,什么叫更好呢,便是能让Fragment的复用性高,品质还会有好,代码还要好保卫安全,无需为每对Activity和Fragment之间定义接口而发愁。

正文作者: 伯乐在线
牛犇
。未经我许可,禁止转载!
接待参预伯乐在线 专栏小编

先轻巧说下Javascript那门语言吧,可能有人就能够问:我们不是聊Android的java难题呢?怎么话题转到JavaScript了。因为本身的实施方案的启迪是从它来的,没兴趣的爱人可以略过。这段日子在上学javascript那门语言,同一时候和谐搞Android开发也许有5年多岁月了,所以在求学js的历程中,就能够惯性的把那二者实行相比。

前言

与java语言的 严谨 相比
Javascript是一门“才高气傲”、”游手好闲”的言语。为何要用“目空一切”那个词呢,上面是它的三个疏解:

近年来径直在想着能不可能有一种更加好的方案来缓和:Android中Activity与Fragment之间通讯的主题素材,什么叫更好啊,便是能让Fragment的复用性高,质量还会有好(不用反射),代码还要好维护,没有供给为每对Activity和Fragment之间定义接口而发愁。

放荡不羁 [fàng dàng bù jī][解释]
羁:约束。放纵任意,不加检点,不受约束。

先轻巧说下Javascript那门语言吧,或然有人就可以问:大家不是聊Android的java难点呢?怎么话题转到JavaScript了。因为自个儿的缓和方案的启迪是从它来的,没兴趣的情人能够略过。前段时间在念书javascript那门语言,同有的时候间和睦搞Android(java)开采也会有5年多时日了,所以在上学js的历程中,就能惯性的把那二者实行相比较。

因为作者觉着那些词更能尽量的体现js弱类型的特色。在给变量赋值时 能够这么写:

与java语言的 严谨 相比
Javascript是一门“忘乎所以”、”作风散漫”(宽泛)的语言。

var a = 1; 

缘何要用“忘其所以”其一词呢,上边是它的二个讲授:

还能那样写:

落拓不羁 [fàng dàng bù jī][解释]
羁:约束。放纵任性,不加检点,不受约束。

 var b = '123'; var o = new Object(); 

因为自己觉着那么些词更能充分的展现js弱类型的本性。

乃至还能够这么写:

在给变量赋值时 能够这么写:

var fun = new function(){}; fun1 = new function(){}; 

var a = 1;

能够把别的类型的值赋给两个变量,也足以不加var关键字来声称一个变量,是还是不是很随意,很不自律啊。

1
var a = 1;

“仪容不整”第一反映了JavaScript的语法更加宽泛、更不难的表征: 譬如:

还足以那样写:

 js代码: //函数声明不需要定义返回值,参数前面不需要有类型出现, //函数体里面就可以有返回值 function max{ return a > b? a:b; } /* *可以传递任意多个参数,在java里面根本不可以 */ function print(){ var len = arguments.length; for(var i = 0; i < len; i++){ console.log(arguments[i]); } } 相应java代码: int max(int a, int b){ return a> b? a:b; } /* *传递任意多个Object类型的参数 */ void print(Object... args){ for (int i = 0; i < args.length; i++){ System.out.println; } } 

var b = ‘123’; var o = new Object();

上面包车型客车代码表达了JavaScript在注解函数时,不会有像java那么严峻的规定,语法不修边幅,语法更简短(这里未有说java不佳的意趣)。

1
2
var b = ‘123’;
var o = new Object();

启发点

JavaScript中有七个第一的点,函数也不列外,何况函数可以看作别的贰个函数的参数,如:

 js代码: //遍历一个数组如果是它是数组,就把它乘以10再输出 var array = [1,2, '你好' , '不' ,31,15]; //数组的each方法接收一个函数 testArray.each( function{ typeof value == 'number' ? alert( value *10 ):null; }) ;

当小编看看上边JavaScript中等学校函授数的用法时作者眼睛一亮,为什么作者不得以借鉴之来解决android中activity与fragment通讯的标题吧?

先让大家聊聊Fragment为何现身,这对于咱们化解Activity与Fragment的通信有救助。贰个新东西的产生总是为了减轻遗闻物存在的难点,Fragment是android3.0的产物,在android3.0事先解决手提式有线电话机、平板计算机的适配难题是很胃痛的,对ActivityGroup有回忆的相恋的人,应该能深切的体味到ActivityGroup包裹的四个Activity之间切换等一层层的性情难题。由此Fragment诞生了。个人总括的Fragment的沉重:

  • 化解手提式有线电话机、苹果平板等各个器材的适配难点
  • 化解多个Activity之间切换品质难题
  • 模块化,因为模块化导致复用的补益

依旧还足以那样写:

Fragment的使用

Fragment是足以棉被服装进在两个不等Activity内的,同一时间叁个Activity内足以打包多少个Fragment,Activity就如叁个大的容器,它能够管理多个Fragment。全数Activity与Fragment之间存在依附关系。

上文提到Activity与Fragment之间是存在依据关系的,由此它们中间必然会涉嫌到通讯难点,消除通讯难题自然会提到到指标之间的援引。因为Fragment的面世有一个重要的重任就是:模块化,进而巩固复用性。若到达此效能,Fragment必需形成高内聚,低耦合。

于今大家动动脚趾都能想到的消除它们中间通讯的方案有:handler,广播,EvnetBus,接口等(恐怕还只怕有其他方案,请大家多多分享),这我们就聊下那一个方案。

先上代码

 public class MainActivity extends FragmentActivity{ //声明一个Handler public Handler mHandler = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage; ...相应的处理代码 } } ...相应的处理代码 } public class MainFragment extends Fragment{ //保存Activity传递的handler private Handler mHandler; @Override public void onAttach(Activity activity) { super.onAttach; //这个地方已经产生了耦合,若还有其他的activity,这个地方就得修改 if(activity instance MainActivity){ mHandler = ((MainActivity)activity).mHandler; } } ...相应的处理代码 }

该方案存在的先天不足:

  • Fragment对切实的Activity存在耦合,不方便人民群众Fragment复用
  • 不实惠维护,若想删除相应的Activity,Fragment也得改造
  • 迫不得已获取Activity的归来数据
  • handler的选择个人以为就很不适(不知我们是还是不是有共鸣)

切切实实的代码就不写了,说下该方案的欠缺:

  • 用广播化解此难题不怎么材大难用了,个人以为广播的企图是用在一对多,接收广播者是雾里看花的气象
  • 广播品质料定会差(不要和自家说品质小难题,对于手提式有线电话机来讲品质是大难点)
  • 流传数据有限制(必得得实现体系化接口才足以)权且就想开那个瑕玷,别的的缺点请大家切磋商讨下啊。

切切实实的伊芙ntBus的采取能够和谐搜索下,个人对该方案的意见:

  • 伊芙ntBus是用反射机制完毕的,品质上会十分(不要和本人说质量不是主题材料,对于手提式有线电话机来讲质量是大标题)
  • 伊芙ntBus难于维护代码
  • 迫于获取Activity的回到数据

自己想这种方案是大家最易想到,使用最多的一种方案吧,具体上代码:

 //MainActivity实现MainFragment开放的接口 public class MainActivity extends FragmentActivity implements FragmentListener{ @override public void toH5Page(){ } ...其他处理代码省略 } public class MainFragment extends Fragment{ public FragmentListener mListener; //MainFragment开放的接口 public static interface FragmentListener{ //跳到h5页面 void toH5Page(); } @Override public void onAttach(Activity activity) { super.onAttach; //对传递进来的Activity进行接口转换 if(activity instance FragmentListener){ mListener = ((FragmentListener)activity); } } ...其他处理代码省略 } 

这种方案应该是不仅可以达到复用,又能达成很好的可维护性,何况质量也是杠杠的。可是独一的一个可惜是只重要项目目不小了,Activity与Fragment的数目也会增添,那时候为每对Activity与Fragment交互定义交互接口正是一个很头痛的难题(总结为接口的命名,新定义的接口相应的Activity还得落到实处,相应的Fragment还得进行强制调换)。
想看更加好的缓慢解决方案请看下边章节。

设计格局里不时提到的二个概念正是包装变化,同期受javascript中的函数的参数能够是函数对象的诱导下,笔者有了上边包车型客车主张,先上代码:代码地址

 /** * + Created by niuxiaowei on 2016/1/20. * 各种方法集合的类,可以把一个方法类以key-value的形式放入本类, * 可以通过key值来调用相应的方法 */ public class Functions { //带参数方法的集合,key值为方法的名字 private HashMap<String,FunctionWithParam> mFunctionWithParam ; //无参数无返回值的方法集合,同理key值为方法名字 private HashMap<String,FunctionNoParamAndResult> mFunctionNoParamAndResult ; /** * 基础方法类 */ public static abstract class Function{ //方法的名字,用来做调用,也可以理解为方法的指针 public String mFunctionName; public Function(String functionName){ this.mFunctionName = functionName; } } /** * 带有参数没有返回值的方法 * @param <Param> 参数 */ public static abstract class FunctionWithParam<Param> extends Function{ public FunctionWithParam(String functionName) { super(functionName); } public abstract void function(Param param); } /** * 没有参数和返回值的方法 */ public static abstract class FunctionNoParamAndResult extends Function{ public FunctionNoParamAndResult(String functionName) { super(functionName); } public abstract void function(); } /** * 添加带参数的函数 * @param function {@link com.niu.myapp.myapp.view.util.Functions.FunctionWithParam} * @return */ public Functions addFunction(FunctionWithParam function){ if(function == null){ return this; } if(mFunctionWithParam == null){ mFunctionWithParam = new HashMap<>; } mFunctionWithParam.put(function.mFunctionName,function); return this; } /** * 添加带返回值的函数 * @param function {@link com.niu.myapp.myapp.view.util.Functions.FunctionWithResult} * @return */ public Functions addFunction(FunctionNoParamAndResult function){ if(function == null){ return this; } if(mFunctionNoParamAndResult == null){ mFunctionNoParamAndResult = new HashMap<>; } mFunctionNoParamAndResult.put(function.mFunctionName,function); return this; } /** * 根据函数名,回调无参无返回值的函数 * @param funcName */ public void invokeFunc(String funcName) throws FunctionException { FunctionNoParamAndResult f = null; if(mFunctionNoParamAndResult != null){ f = mFunctionNoParamAndResult.get; if(f != null){ f.function(); } } if(f == null){ throw new FunctionException; } } /** * 调用具有参数的函数 * @param funcName * @param param * @param <Param> */ public <Param> void invokeFunc(String funcName,Param param)throws FunctionException{ FunctionWithParam f = null; if(mFunctionWithParam != null){ f = mFunctionWithParam.get; if(f != null){ f.function; } } } }

var fun = new function(){}; fun1 = new function(){};

1. 用三个类来模拟Javascript中的三个Function

Function纵使此类,它是贰个基类,各类Functioon实例皆有八个mFuncName
既然是办法它就有有参数和无参数之分FunctionWithParam<Param>是Function的子类,代表有参数的方法类,方法参数通过泛型消除FunctionNoParamAndResult是Function的子类,代表无参无重临值的艺术类

1
2
var fun = new function(){};
fun1 = new function(){};
2. 多少个能够贮存两个法子的类

Functions类正是此类,上面简要介绍下Functions有4个入眼措施:

  • addFunction(FunctionNoParamAndResult function)
    加多贰个无参无重回值的章程类
  • addFunction(FunctionWithParam function) 增多贰个有参无再次回到值的格局类
  • invokeFunc(String funcName) 依照funcName调用三个主意
  • invokeFunc(String funcName,Param param)
    依据funcName调用有参无重返值的章程类

种种app皆有些基础activity(BaseActivity)

 public abstract class BaseActivity extends FragmentActivity { /** * 为fragment设置functions,具体实现子类来做 * @param fragmentId */ public void setFunctionsForFragment( int fragmentId){ } } 

里头的三个activity:

 public class MainActivity extends BaseActivity { @Override public void setFunctionsForFragment(int fragmentId) { super.setFunctionsForFragment(fragmentId); switch (fragmentId) { case R.id.fragment_main: FragmentManager fm = getSupportFragmentManager(); BaseFragment fragment = (BaseFragment) fm.findFragmentById(fragmentId); //开始添加functions fragment.setFunctions(new Functions() .addFunction(new Functions.FunctionNoParamAndResult(MainFragment.FUNCTION_NO_PARAM_NO_RESULT) { @Override public void function() { Toast.makeText(MainActivity.this, "成功调用无参无返回值方法", Toast.LENGTH_LONG).show. addFunction(new Functions.FunctionWithParam<Integer>(MainFragment.FUNCTION_HAS_PARAM_NO_RESULT) { @Override public void function(Integer o) { Toast.makeText(MainActivity.this, "成功调用有参无返回值方法 参数值=" + o, Toast.LENGTH_LONG).show; } } }

每一个app都会有的基础fragment(BaseFragment)

 public abstract class BaseFragment extends Fragment { protected BaseActivity mBaseActivity; /** * 函数的集合 */ protected Functions mFunctions; /** * activity调用此方法进行设置Functions * @param functions */ public void setFunctions(Functions functions){ this.mFunctions = functions; } @Override public void onAttach(Activity activity) { super.onAttach; //呼叫activity进行回调方法的设置 if(activity instanceof BaseActivity){ mBaseActivity = (BaseActivity)activity; mBaseActivity.setFunctionsForFragment; } } } 

MainActivity对应的MainFragment

 public class MainFragment extends BaseFragment { /** * 没有参数没有返回值的函数 */ public static final String FUNCTION_NO_PARAM_NO_RESULT = "FUNCTION_NO_PARAM_NO_RESULT"; /** * 有参数没有返回值的函数 */ public static final String FUNCTION_HAS_PARAM_NO_RESULT = "FUNCTION_HAS_PARAM_NO_RESULT"; @Override public void onViewCreated(View view, @Nullable Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); mBut1 =  getView().findViewById(R.id.click1); mBut3 =  getView().findViewById(R.id.click3); mBut1.setOnClickListener(new View.OnClickListener() { @Override public void onClick { try { //调用无参无返回值的方法 mFunctions.invokeFunc( FUNCTION_NO_PARAM_NO_RESULT); } catch (FunctionException e) { e.printStackTrace; mBut3.setOnClickListener(new View.OnClickListener() { @Override public void onClick { try { //调用有参无返回值的方法 mFunctions.invokeFunc( FUNCTION_HAS_PARAM_NO_RESULT, 100); } catch (FunctionException e) { e.printStackTrace; } 

来看这你是否感到已经竣工了,当然是平素不了,因为还应该有2个难题没解决。方法重回值和办法接收四个参数的难题。

上代码:代码地址

 /** * 有返回值,没有参数的方法 * @param <Result> */ public static abstract class FunctionWithResult<Result> extends Function{ public FunctionWithResult(String functionName) { super(functionName); } public abstract Result function(); } /** * 带有参数和返回值的 方法 * @param <Result> * @param <Param> */ public static abstract class FunctionWithParamAndResult<Result,Param> extends Function{ public FunctionWithParamAndResult(String functionName) { super(functionName); } public abstract Result function(Param data); } 

FunctionWithResult<Result>无参数有再次来到值的点子类FunctionWithParamAndResult<Result,Param>
有参数也会有重临值的章程类在Functions类中定义增添和调用那2种办法类的
相应措施。

在消除此主题材料时本人想了成都百货上千办法(比如怎样引进多个泛型,但最终以失利告终,希望有看了那篇文章的恋人能够多提下宝贵意见)。然后自个儿就想开了用Bundle来化解多参数的难点,把多个参数放到Bundle中,但是在往Bundle中塞入数据时得有三个对应的key值,生成key值以及记住key值(记住key值是为了从Bundle中取多少)是三个繁琐的事。同不经常间Bundle无法传递非类别化对象。所以就封装了三个FunctionParams类化解以上难点,请看类的落实:
代码地址

 /** * 函数的参数,当函数的参数涉及到多个值时,可以用此类, * 此类使用规则:存参数与取参数的顺序必须一致, * 比如存参数顺序是new *FunctionParamsBuilder().putString.putString.putInt; *取的顺序也是: functionParams.getString(), *functionParams.getString(), functionParams.getInt(); */ public static class FunctionParams { private Bundle mParams = new Bundle; private int mIndex = -1; private Map mObjectParams = new HashMap; FunctionParams(Bundle mParams,Map mObjectParams){ this.mParams = mParams; this.mObjectParams = mObjectParams; } public <Param> Param getObject(Class<Param> p){ if(mObjectParams == null){ return null; } return p.cast(mObjectParams.get( + "")); } /** * 获取int值 * @return */ public int getInt(){ if(mParams != null){ return mParams.getInt( + ""); } return 0; } /** * 获取int值 * @param defalut * @return */ public int getInt(int defalut){ if(mParams != null){ return mParams.getInt( + ""); } return defalut; } /** * 获取字符串 * @param defalut * @return */ public String getString(String defalut){ if(mParams != null){ return mParams.getString( + ""); } return defalut; } /** * 获取字符串 * @return */ public String getString(){ if(mParams != null){ return mParams.getString( + ""); } return null; } /** * 获取Boolean值 * @return 默认返回false */ public boolean getBoolean(){ if(mParams != null){ return mParams.getBoolean( + ""); } return false; } /** * 该类用来创建函数参数 */ public static class FunctionParamsBuilder{ private Bundle mParams ; private int mIndex = -1; private Map mObjectParams = new HashMap; public FunctionParamsBuilder(){ } public FunctionParamsBuilder putInt(int value){ if(mParams == null){ mParams = new Bundle; } mParams.putInt( + "", value); return this; } public FunctionParamsBuilder putString(String value){ if(mParams == null){ mParams = new Bundle; } mParams.putString( + "", value); return this; } public FunctionParamsBuilder putBoolean(boolean value){ if(mParams == null){ mParams = new Bundle; } mParams.putBoolean( + "", value); return this; } public FunctionParamsBuilder putObject(Object value){ if(mObjectParams == null){ mObjectParams = new HashMap; } mObjectParams.put( + "", value); return this; } public FunctionParams create(){ FunctionParams instance = new FunctionParams(mParams,mObjectParams); return instance; } } }

FunctionParams卷入了取参数的作用,比方:

 public <Param> Param getObject(Class<Param> p){ if(mObjectParams == null){ return null; } return p.cast(mObjectParams.get( + "")); }

取对象参数的成效,无需后人key值,只须求后人必要将在抽取来的类的Class实例就可以

FunctionParamsBuilder类,看它的名字就精通是用了设计方式里的Builder形式。该类是用来存放在参数的,当有着的参数都存放达成后调用create()方法创立三个FunctionParams对象事物都以有两面性的,有劣点就有优点,只可是是在好几场馆下优点大于弱点,依然恰恰相反。FunctionParams消除了上述提到的Bundle传递多参数各类困难的主题素材,但同一时间FunctionParams也可以有三个败笔正是存参数的逐个与取参数的依次必须要一律,比如:

 //存的顺序 new FunctionParamsBuilder().putString.putInt .putBoolean.create(); //取的顺序 functionParams.getString(); functionParams.getInt(); functionParams.getBoolean();

但是这种破绽函数的概念来看亦不是毛病。

Activity与Fragment之间的通讯是因此Functions的,即把变化的部分封装在Functions是类中,Functions起叁个大桥功用。

此方案优点:

  • Fragment与Activity的耦合性大约从未
  • 属性也好
  • 能够从Activity获取再次来到数据
  • 扩展性好(新扩大的成对的Activity与Fragment之间的通信只需做以下几步:1.新增Activity只要求覆盖BaseActivity中的
    setFunctionsForFragment(int fragmentId)
    方法,把相应的回调函数插足。2.应和的Fragment定义函数key值就可以)

简轻易单总括为以下几点:

  • Fragment的使命
  • Activity与Fragment之间通讯的缓和方案(handler,广播,EventBus,接口)的利弊。
  • 小编本身关于Activity与Fragment之间通讯的消除方案(Functions),其实消除的要害是Fragment调用Activity的方案。

企望我们能多提宝贵意见,多调换。代码地址

本身微信:704451290

图片 1自己大伙儿账号

能够把别的类型的值赋给一个变量,也足以不加var关键字来声称二个变量,是或不是比较轻便,很不自律啊。

“游手好闲”重大反映了JavaScript的语法更常见、更简单的性状: 比如:

js代码: //函数注解无需定义重临值,参数前面不必要有档案的次序出现,
//函数体里面就可以有重返值 function max(a,b){ return a > b? a:b; }
/* *可以传递大肆三个参数,在java里边根本不能 */ function print(){
var len = arguments.length; for(var i = 0; i b? a:b; } /*
*传递大肆多少个Object类型的参数 */ void print(Object… args){ for (int
i = 0; i

1
2
3
4
5
6
7
8
9
10
11
12
13
  js代码:  
  //函数声明不需要定义返回值,参数前面不需要有类型出现,
  //函数体里面就可以有返回值
  function max(a,b){ return a > b? a:b; }
  /* *可以传递任意多个参数,在java里面根本不可以 */
  function print(){
      var len = arguments.length;
      for(var i = 0; i  b? a:b;
  }
 
  /* *传递任意多个Object类型的参数 */
  void print(Object… args){
       for (int i = 0; i

地点的代码说明了JavaScript在宣称函数时,不会有像java那么严酷的分明,语法游手好闲,语法更简短(这里未有说java倒霉的意趣)。

启发点

JavaScript中有贰个重要的点(万事万物皆对象),函数也不列外,何况函数能够看成别的叁个函数的参数,如:

js代码: //遍历一个数组假使是它是数组,就把它乘以10再出口 var array =
[1,2, ‘你好’ , ‘不’ ,31,15]; //数组的each方法接收多个函数
testArray.each( function( value ){ typeof value == ‘number’ ? alert(
value *10 ):null; }) ;

1
2
3
4
5
6
7
     js代码:
    //遍历一个数组如果是它是数组,就把它乘以10再输出
     var array = [1,2, ‘你好’ , ‘不’ ,31,15];  
    //数组的each方法接收一个函数
     testArray.each( function( value ){
           typeof value == ‘number’ ? alert( value *10 ):null;
    })  ;

当自家见状地方JavaScript中等高校函授数的用法时自个儿美观,为何笔者不可能借鉴之来消除android中activity与fragment通讯的标题吗?


Fragment的使命


先让大家聊聊Fragment为什么出现,那对于我们缓和Activity与Fragment的通讯有帮带。贰个新东西的爆发总是为了缓和有趣的事物存在的难点,Fragment是android3.0的产物,在android3.0事先解决手提式有线电话机、三星GALAXY Tab的适配难题是很胸闷的,对ActivityGroup有影像的相恋的人,应该能浓厚的体味到ActivityGroup包裹的四个Activity之间切换等一名目许多的天性难点。由此Fragment诞生了。个人总括的Fragment的重任:

  • 缓和手提式有线话机、平板Computer等各个器具的适配难题
  • 缓慢解决多少个Activity之间切换品质难题
  • 模块化,因为模块化导致复用的功利

Fragment的使用

Fragment是足以被卷入在多少个例外Activity内的,同偶尔间一个Activity内能够打包三个Fragment,Activity仿佛一个大的器皿,它能够管理多少个Fragment。全体Activity与Fragment之间存在依赖关系。


Activity与Fragment通讯方案

上文提到Activity与Fragment之间是存在凭借关系的,因而它们中间自然会提到到通信难题,消除通讯难题必将会涉及到对象时期的援用。因为Fragment的面世有八个最首要的重任正是:模块化,进而加强复用性。若达到此意义,Fragment必需产生高内聚,低耦合。

明日大家动动脚趾都能想到的化解它们之间通讯的方案有:handler,广播,EvnetBus,接口等(或然还会有其余方案,请大家多多分享),那大家就聊下那么些方案。

handler方案:

先上代码

public class MainActivity extends FragmentActivity{ //声圣元(Synutra)个Handler
public Handler mHandler = new Handler(){ @Override public void
handleMessage(Message msg) { super.handleMessage(msg); …相应的管理代码
} } …相应的管理代码 } public class MainFragment extends Fragment{
//保存Activity传递的handler private Handler mHandler; @Override public
void onAttach(Activity activity) { super.onAttach(activity);
//这些位置一度产生了耦合,若还应该有别的的activity,那些地方就得修改
if(activity instance MainActivity){ mHandler =
((MainActivity)activity).mHandler; } } …相应的拍卖代码 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
   public class MainActivity extends FragmentActivity{
      //声明一个Handler
      public Handler mHandler = new Handler(){      
          @Override
           public void handleMessage(Message msg) {
                super.handleMessage(msg);
                 …相应的处理代码
           }
     }
     …相应的处理代码
   }
 
    public class MainFragment extends Fragment{
          //保存Activity传递的handler
           private Handler mHandler;
           @Override
           public void onAttach(Activity activity) {
                super.onAttach(activity);
               //这个地方已经产生了耦合,若还有其他的activity,这个地方就得修改
                if(activity instance MainActivity){
                      mHandler =  ((MainActivity)activity).mHandler;
                }
           }
           …相应的处理代码
     }

该方案存在的毛病:

  • Fragment对实际的Activity存在耦合,不低价Fragment复用
  • 不便于爱抚,若想删除相应的Activity,Fragment也得退换
  • 不得已获取Activity的回来数据
  • handler的利用个人认为就很优伤(不知大家是否有共鸣)

播音方案:

切切实实的代码就不写了,说下该方案的先天不足:

  • 用广播消除此难题不怎么白璧三献了,个人以为广播的打算是用在一对多,接收广播者是雾里看花的情况
  • 广播品质料定会差(不要和本人说品质不荒谬,对于手提式有线电话机来讲品质是大难题)
  • 流传数据有限制(必得得落实种类化接口才足以)
    一时就想到那几个老毛病,别的的欠缺请大家集中民众智慧下呢。

EventBus方案:

实际的EventBus的施用能够友善寻找下,个人对该方案的意见:

  • 伊芙ntBus是用反射机制落到实处的,品质上会有失水准(不要和自身说品质不是主题素材,对于手提式有线电话机来说质量是大标题)
  • 伊夫ntBus难于维护代码
  • 无可奈何获取Activity的归来数据

接口方案

自己想这种方案是豪门最易想到,使用最多的一种方案吗,具体上代码:

//MainActivity完成MainFragment开放的接口 public class MainActivity
extends FragmentActivity implements FragmentListener{ @override public
void toH5Page(){ } …别的管理代码省略 } public class MainFragment
extends Fragment{ public FragmentListener mListener;
//MainFragment开放的接口 public static interface FragmentListener{
//跳到h5页面 void toH5Page(); } @Override public void onAttach(Activity
activity) { super.onAttach(activity); //对传递步入的Activity举行接口调换if(activity instance FragmentListener){ mListener =
((FragmentListener)activity); } } …其他管理代码省略 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
  //MainActivity实现MainFragment开放的接口
  public class MainActivity extends FragmentActivity implements FragmentListener{
        @override
         public void toH5Page(){ }
       …其他处理代码省略
   }
 
    public class MainFragment extends Fragment{
 
         public FragmentListener mListener;  
        //MainFragment开放的接口
        public static interface FragmentListener{
            //跳到h5页面
           void toH5Page();
         }
 
         @Override
        public void onAttach(Activity activity) {
              super.onAttach(activity);
              //对传递进来的Activity进行接口转换
               if(activity instance FragmentListener){
                   mListener = ((FragmentListener)activity);
              }
         }
         …其他处理代码省略
  }

这种方案应该是不仅可以达到复用,又能达到规定的规范很好的可维护性,而且品质也是杠杠的。不过独一的贰个缺憾是若是项目相当大了,Activity与Fragment的多少也会追加,那时候为每对Activity与Fragment交互定义交互接口便是三个很咳嗽的标题(席卷为接口的命名,新定义的接口相应的Activity还得落实,相应的Fragment还得进行强制转变)。
想看更加好的应用方案请看下边章节。


大招来也

设计形式里时有的时候提到的多个概念正是包装变化,同期受javascript中的函数的参数能够是函数对象的启发下,笔者有了下边包车型客车主张,先上代码:代码地址

/** * + Created by niuxiaowei on 2016/1/20. *
种种办法群集的类,能够把贰个措施类以key-value的款型放入本类, *
能够透过key值来调用相应的点子 */ public class Functions {
//带参数方法的集合,key值为格局的名字 private HashMap mFunctionWithParam
; //无参数无再次回到值的措施集合,同理key值为艺术名字 private HashMap
mFunctionNoParamAndResult ; /** * 基础艺术类 */ public static
abstract class Function{
//方法的名字,用来做调用,也得以领略为形式的指针 public String
mFunctionName; public Function(String functionName){ this.mFunctionName
= functionName; } } /** * 带有参数未有重临值的不二秘诀 * @param 参数 */
public static abstract class FunctionWithParam extends Function{ public
FunctionWithParam(String functionName) { super(functionName); } public
abstract void function(Param param); } /** * 未有参数和重回值的方法
*/ public static abstract class FunctionNoParamAndResult extends
Function{ public FunctionNoParamAndResult(String functionName) {
super(functionName); } public abstract void function(); } /** *
加多带参数的函数 * @param function {<a
href=”http://www.jobbole.com/members/57845349"&gt;@link&lt;/a&gt;
com.niu.myapp.myapp.view.util.Functions.FunctionWithParam} * @return
*/ public Functions addFunction(FunctionWithParam function){
if(function == null){ return this; } if(mFunctionWithParam == null){
mFunctionWithParam = new HashMap(1); }
mFunctionWithParam.put(function.mFunctionName,function); return this; }
/** * 增加带再次来到值的函数 * @param function {<a
href=”http://www.jobbole.com/members/57845349"&gt;@link&lt;/a&gt;
com.niu.myapp.myapp.view.util.Functions.FunctionWithResult} * @return
*/ public Functions addFunction(FunctionNoParamAndResult function){
if(function == null){ return this; } if(mFunctionNoParamAndResult ==
null){ mFunctionNoParamAndResult = new HashMap(1); }
mFunctionNoParamAndResult.put(function.mFunctionName,function); return
this; } /** * 依照函数名,回调无参无重返值的函数 * @param funcName
*/ public void invokeFunc(String funcName) throws FunctionException {
FunctionNoParamAndResult f = null; if(mFunctionNoParamAndResult !=
null){ f = mFunctionNoParamAndResult.get(funcName); if(f != null){
f.function(); } } if(f == null){ throw new
FunctionException(“未有此函数”); } } /** * 调用装有参数的函数 *
@param funcName * @param param * @param */ public void
invokeFunc(String funcName,Param param)throws FunctionException{
FunctionWithParam f = null; if(mFunctionWithParam != null){ f =
mFunctionWithParam.get(funcName); if(f != null){ f.function(param); } }
} }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
  /** * + Created by niuxiaowei on 2016/1/20.
  * 各种方法集合的类,可以把一个方法类以key-value的形式放入本类,  
  * 可以通过key值来调用相应的方法 */
   public class Functions {
 
      //带参数方法的集合,key值为方法的名字
      private  HashMap mFunctionWithParam ;
      //无参数无返回值的方法集合,同理key值为方法名字
     private HashMap mFunctionNoParamAndResult ;
 
      /** * 基础方法类 */
     public static abstract class Function{
         //方法的名字,用来做调用,也可以理解为方法的指针
          public String mFunctionName;
          public Function(String functionName){
                this.mFunctionName = functionName;
         }
      }
 
      /** * 带有参数没有返回值的方法
     * @param  参数 */
     public static abstract class FunctionWithParam extends Function{
 
          public FunctionWithParam(String functionName) {
              super(functionName);
         }
 
        public abstract void function(Param param);
    }
 
    /** * 没有参数和返回值的方法 */
   public static abstract class FunctionNoParamAndResult extends Function{
          public FunctionNoParamAndResult(String functionName) {
                super(functionName);
          }
 
          public abstract void function();
    }
 
    /** * 添加带参数的函数
     * @param function {<a href="http://www.jobbole.com/members/57845349">@link</a> com.niu.myapp.myapp.view.util.Functions.FunctionWithParam}
    * @return */
     public Functions addFunction(FunctionWithParam function){
             if(function == null){
                  return this;
             }
            if(mFunctionWithParam == null){
                  mFunctionWithParam = new HashMap(1);
            }  
 
        mFunctionWithParam.put(function.mFunctionName,function);
        return this;
      }
 
      /** * 添加带返回值的函数
      * @param function {<a href="http://www.jobbole.com/members/57845349">@link</a> com.niu.myapp.myapp.view.util.Functions.FunctionWithResult}
     * @return */
     public Functions addFunction(FunctionNoParamAndResult function){
          if(function == null){ return this; }
          if(mFunctionNoParamAndResult == null){
                mFunctionNoParamAndResult = new HashMap(1);
         }
         mFunctionNoParamAndResult.put(function.mFunctionName,function);
      return this;
    }
 
     /** * 根据函数名,回调无参无返回值的函数
   * @param funcName */
    public void invokeFunc(String funcName) throws FunctionException {
         FunctionNoParamAndResult f = null;
        if(mFunctionNoParamAndResult != null){
              f = mFunctionNoParamAndResult.get(funcName);
              if(f != null){ f.function(); }
        }
         if(f == null){ throw new FunctionException("没有此函数"); }
     }
 
    /** * 调用具有参数的函数
     * @param funcName
    * @param param
    * @param  */
      public  void invokeFunc(String funcName,Param param)throws FunctionException{
            FunctionWithParam f = null;
            if(mFunctionWithParam != null){
                  f = mFunctionWithParam.get(funcName);
                   if(f != null){ f.function(param); }
            }
     }
}

规划思路:

1. 用一个类来模拟Javascript中的二个Function

Function不怕此类,它是一个基类,每一个Functioon实例都有三个mFuncName
既然是格局(也许函数)它就有有参数和无参数之分
FunctionWithParam是Function的子类,代表有参数的方法类,方法参数通过泛型消除
FunctionNoParamAndResult是Function的子类,代表无参无再次来到值的不二诀要类

2. 一个方可存放多少个措施(恐怕函数)的类

Functions类正是此类,下边简介下Functions有4个注重措施:

  • addFunction(FunctionNoParamAndResult function)
    增多贰个无参无重回值的艺术类
  • addFunction(FunctionWithParam function) 增加三个有参无重回值的方法类
  • invokeFunc(String funcName) 依据funcName调用三个办法
  • invokeFunc(String funcName,Param param)
    依据funcName调用有参无重临值的章程类

动用例如:代码地址

种种app都有个别基础activity(BaseActivity)

public abstract class BaseActivity extends FragmentActivity { /** *
为fragment设置functions,具体贯彻子类来做 * @param fragmentId */
public void setFunctionsForFragment( int fragmentId){ } }

1
2
3
4
5
6
7
8
     public abstract class BaseActivity extends FragmentActivity {
          /**
          * 为fragment设置functions,具体实现子类来做
         * @param fragmentId */
        public void setFunctionsForFragment(
              int fragmentId){
        }
   }

中间的三个activity:

public class MainActivity extends BaseActivity { @Override public void
setFunctionsForFragment(int fragmentId) {
super.setFunctionsForFragment(fragmentId); switch (fragmentId) { case
R.id.fragment_main: FragmentManager fm = getSupportFragmentManager();
BaseFragment fragment = (BaseFragment) fm.findFragmentById(fragmentId);
//开头增多functions fragment.setFunctions(new Functions()
.addFunction(new
Functions.FunctionNoParamAndResult(MainFragment.FUNCTION_NO_PARAM_NO_RESULT)
{ @Override public void function() { Toast.makeText(MainActivity.this,
“成功调用无参无再次来到值方法”, Toast.LENGTH_LONG).show(); } }).
addFunction(new
Functions.FunctionWithParam(MainFragment.FUNCTION_HAS_PARAM_NO_RESULT)
{ @Override public void function(Integer o) {
Toast.makeText(MainActivity.this, “成功调用有参无再次来到值方法 参数值=” +
o, Toast.LENGTH_LONG).show(); } })); } } }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
     public class MainActivity extends BaseActivity {
 
          @Override public void setFunctionsForFragment(int fragmentId) {
               super.setFunctionsForFragment(fragmentId);
               switch (fragmentId) {
                   case R.id.fragment_main:
                     FragmentManager fm = getSupportFragmentManager();
                    BaseFragment fragment = (BaseFragment) fm.findFragmentById(fragmentId);
                   //开始添加functions
               fragment.setFunctions(new Functions()
                   .addFunction(new Functions.FunctionNoParamAndResult(MainFragment.FUNCTION_NO_PARAM_NO_RESULT) {
 
                       @Override
                      public void function() {
                           Toast.makeText(MainActivity.this, "成功调用无参无返回值方法", Toast.LENGTH_LONG).show();
                      }
               }).
                  addFunction(new Functions.FunctionWithParam(MainFragment.FUNCTION_HAS_PARAM_NO_RESULT) {
                        @Override
                        public void function(Integer o) {
                            Toast.makeText(MainActivity.this, "成功调用有参无返回值方法 参数值=" + o, Toast.LENGTH_LONG).show(); } }));
                       }
               }
}

各样app都会有些基础fragment(BaseFragment)

public abstract class BaseFragment extends Fragment { protected
BaseActivity mBaseActivity; /** * 函数的会集 */ protected Functions
mFunctions; /** * activity调用此方法开展设置Functions * @param
functions */ public void setFunctions(Functions functions){
this.mFunctions = functions; } @Override public void onAttach(Activity
activity) { super.onAttach(activity); //呼叫activity举行回调方法的安装
if(activity instanceof BaseActivity){ mBaseActivity =
(BaseActivity)activity; mBaseActivity.setFunctionsForFragment(getId());
} } }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
     public abstract class BaseFragment extends Fragment {
            protected BaseActivity mBaseActivity;
            /** * 函数的集合 */
            protected Functions mFunctions;
 
            /** * activity调用此方法进行设置Functions
           * @param functions */
           public void setFunctions(Functions functions){
                this.mFunctions = functions;
           }
 
          @Override
          public void onAttach(Activity activity) {
                super.onAttach(activity);
               //呼叫activity进行回调方法的设置
              if(activity instanceof BaseActivity){
                    mBaseActivity = (BaseActivity)activity;
                     mBaseActivity.setFunctionsForFragment(getId());
               }
          }
  }

MainActivity对应的MainFragment

public class MainFragment extends BaseFragment { /** *
未有参数未有再次来到值的函数 */ public static final String
FUNCTION_NO_PARAM_NO_RESULT = “FUNCTION_NO_PARAM_NO_RESULT”;
/** * 有参数未有重临值的函数 */ public static final String
FUNCTION_HAS_PARAM_NO_RESULT = “FUNCTION_HAS_PARAM_NO_RESULT”;
@Override public void onViewCreated(View view, @Nullable Bundle
savedInstanceState) { super.onViewCreated(view, savedInstanceState);
mBut1 = (Button) getView().findViewById(Kuga.id.click1); mBut3 = (Button)
getView().findViewById(CR-V.id.click3); mBut1.setOnClickListener(new
View.OnClickListener() { @Override public void onClick(View v) { try {
//调用无参无重回值的点子 mFunctions.invokeFunc(
FUNCTION_NO_PARAM_NO_RESULT); } catch (FunctionException e) {
e.printStackTrace(); } } }); mBut3.setOnClickListener(new
View.OnClickListener() { @Override public void onClick(View v) { try {
//调用有参无再次来到值的方法 mFunctions.invokeFunc(
FUNCTION_HAS_PARAM_NO_RESULT, 100); } catch (FunctionException e) {
e.printStackTrace(); } } }); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
    public class MainFragment extends BaseFragment {
 
           /** * 没有参数没有返回值的函数 */
          public static final String FUNCTION_NO_PARAM_NO_RESULT = "FUNCTION_NO_PARAM_NO_RESULT";
          /** * 有参数没有返回值的函数 */
         public static final String FUNCTION_HAS_PARAM_NO_RESULT = "FUNCTION_HAS_PARAM_NO_RESULT";
 
          @Override
           public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
               super.onViewCreated(view, savedInstanceState);
               mBut1 = (Button) getView().findViewById(R.id.click1);
                mBut3 = (Button) getView().findViewById(R.id.click3);
 
               mBut1.setOnClickListener(new View.OnClickListener() {
                    @Override
                     public void onClick(View v) {
                          try {
                               //调用无参无返回值的方法
                               mFunctions.invokeFunc(
                                FUNCTION_NO_PARAM_NO_RESULT);      
                        } catch (FunctionException e) {
                               e.printStackTrace();
                        }
 
                    }
              });
 
              mBut3.setOnClickListener(new View.OnClickListener() {
                  @Override
                   public void onClick(View v) {
                         try {
                                //调用有参无返回值的方法
                                mFunctions.invokeFunc(
                                 FUNCTION_HAS_PARAM_NO_RESULT, 100);
                        } catch (FunctionException e) {
                               e.printStackTrace(); }
                     }
               });
  }

见状那你是否认为已经结束了,当然是尚未了,因为还恐怕有2个难题没消除。方法重返值和方式接收八个参数的难点。

主意重回值的难题

上代码:代码地址

/** * 有重临值,未有参数的点子 * @param */ public static abstract
class FunctionWithResult extends Function{ public
FunctionWithResult(String functionName) { super(functionName); } public
abstract Result function(); } /** * 带有参数和重临值的 方法 * @param
* @param */ public static abstract class FunctionWithParamAndResult
extends Function{ public FunctionWithParamAndResult(String functionName)
{ super(functionName); } public abstract Result function(Param data); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    /** * 有返回值,没有参数的方法
     * @param  */
    public static abstract class FunctionWithResult extends Function{
 
         public FunctionWithResult(String functionName) {
              super(functionName);
         }
 
          public abstract Result function();
    }
 
    /** * 带有参数和返回值的 方法
    * @param  
    * @param  */
   public static abstract class FunctionWithParamAndResult extends Function{
        public FunctionWithParamAndResult(String functionName) {
              super(functionName);
        }
 
        public abstract Result function(Param data);
}

FunctionWithResult无参数有重临值的措施类
FunctionWithParamAndResult 有参数也是有重临值的方式类
在Functions类中定义增加和调用那2种方法类的 相应措施。

说不上是艺术包涵多个参数的标题

在缓慢解决此主题素材时作者想了繁多措施(比如如何引进多少个泛型,但结尾以战败告终,希望有看了那篇小说的对象能够多提下宝贵意见)。然后自个儿就悟出了用Bundle来化解多参数的题目,把四个参数放到Bundle中,不过在往Bundle中塞入数据时得有一个相应的key值,生成key值以及记住key值(记住key值是为了从Bundle中取多少)是三个累赘的事。同时Bundle无法传递非种类化对象。所以就封装了三个FunctionParams类化解以上难题,请看类的兑现:
代码地址

/** * 函数的参数,当函数的参数涉及到七个值时,可以用此类, *
此类使用法则:存参数与取参数的逐一必得一致, * 举个例子存参数顺序是new
*FunctionParamsBuilder().putString(“a”).putString(“b”).putInt(100);
*取的逐个也是: functionParams.getString(),
*functionParams.getString(), functionParams.getInt(); */ public static
class FunctionParams { private Bundle mParams = new Bundle(1); private
int mIndex = -1; private Map mObjectParams = new HashMap(1);
FunctionParams(Bundle mParams,Map mObjectParams){ this.mParams =
mParams; this.mObjectParams = mObjectParams; } public Param
getObject(Class p){ if(mObjectParams == null){ return null; } return
p.cast(mObjectParams.get((mIndex++) + “”)); } /** * 获取int值 *
@return */ public int getInt(){ if(mParams != null){ return
mParams.getInt((mIndex++) + “”); } return 0; } /** * 获取int值 *
@param defalut * @return */ public int getInt(int defalut){ if(mParams
!= null){ return mParams.getInt((mIndex++) + “”); } return defalut; }
/** * 获取字符串 * @param defalut * @return */ public String
getString(String defalut){ if(mParams != null){ return
mParams.getString((mIndex++) + “”); } return defalut; } /** *
获取字符串 * @return */ public String getString(){ if(mParams !=
null){ return mParams.getString((mIndex++) + “”); } return null; } /**
* 获取Boolean值 * @return 暗许重回false */ public boolean
getBoolean(){ if(mParams != null){ return mParams.getBoolean((mIndex++)

  • “”); } return false; } /** * 该类用来成立函数参数 */ public static
    class FunctionParamsBuilder{ private Bundle mParams ; private int mIndex
    = -1; private Map mObjectParams = new HashMap(1); public
    FunctionParamsBuilder(){ } public FunctionParamsBuilder putInt(int
    value){ if(mParams == null){ mParams = new Bundle(2); }
    mParams.putInt((mIndex++) + “”, value); return this; } public
    FunctionParamsBuilder putString(String value){ if(mParams == null){
    mParams = new Bundle(2); } mParams.putString((mIndex++) + “”, value);
    return this; } public FunctionParamsBuilder putBoolean(boolean value){
    if(mParams == null){ mParams = new Bundle(2); }
    mParams.putBoolean((mIndex++) + “”, value); return this; } public
    FunctionParamsBuilder putObject(Object value){ if(mObjectParams ==
    null){ mObjectParams = new HashMap(1); } mObjectParams.put((mIndex++) +
    “”, value); return this; } public FunctionParams create(){
    FunctionParams instance = new FunctionParams(mParams,mObjectParams);
    return instance; } } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
  /** * 函数的参数,当函数的参数涉及到多个值时,可以用此类,
   * 此类使用规则:存参数与取参数的顺序必须一致,
   * 比如存参数顺序是new
*FunctionParamsBuilder().putString("a").putString("b").putInt(100);
    *取的顺序也是: functionParams.getString(),  
    *functionParams.getString(), functionParams.getInt(); */
public static class FunctionParams {
 
      private Bundle mParams = new Bundle(1);
      private int mIndex = -1;
      private Map mObjectParams = new HashMap(1);
 
      FunctionParams(Bundle mParams,Map mObjectParams){
          this.mParams = mParams;
          this.mObjectParams = mObjectParams;
     }
 
    public  Param getObject(Class p){
        if(mObjectParams == null){ return null; }
        return p.cast(mObjectParams.get((mIndex++) + "")); }
 
    /** * 获取int值
    * @return */
    public int getInt(){
         if(mParams != null){
              return mParams.getInt((mIndex++) + ""); } return 0;
    }
 
    /** * 获取int值
    * @param defalut
    * @return */
    public int getInt(int defalut){
        if(mParams != null){
          return mParams.getInt((mIndex++) + "");
        }
       return defalut;
     }
 
    /** * 获取字符串
    * @param defalut * @return */
     public String getString(String defalut){
        if(mParams != null){
          return mParams.getString((mIndex++) + "");
        }
        return defalut;
    }
 
    /** * 获取字符串 * @return */
    public String getString(){
        if(mParams != null){
             return mParams.getString((mIndex++) + "");
      } return null;
    }
 
      /** * 获取Boolean值
    * @return 默认返回false */
     public boolean getBoolean(){
        if(mParams != null){
            return mParams.getBoolean((mIndex++) + "");
        } return false;
     }
 
     /** * 该类用来创建函数参数 */
     public static class FunctionParamsBuilder{
 
         private Bundle mParams ;
         private int mIndex = -1;
         private Map mObjectParams = new HashMap(1);
 
        public FunctionParamsBuilder(){ }
 
        public FunctionParamsBuilder putInt(int value){
             if(mParams == null){
                  mParams = new Bundle(2);
             }
              mParams.putInt((mIndex++) + "", value);
              return this;
      }
 
      public FunctionParamsBuilder putString(String value){
            if(mParams == null){
                mParams = new Bundle(2);
           }
            mParams.putString((mIndex++) + "", value);
            return this;
    }
 
     public FunctionParamsBuilder putBoolean(boolean value){
          if(mParams == null){ mParams = new Bundle(2); }
          mParams.putBoolean((mIndex++) + "", value);
          return this;
     }
 
      public FunctionParamsBuilder putObject(Object value){
          if(mObjectParams == null){
              mObjectParams = new HashMap(1);
          }
          mObjectParams.put((mIndex++) + "", value);
           return this;
     }
 
     public FunctionParams create(){
         FunctionParams instance = new FunctionParams(mParams,mObjectParams); return instance;
    }
  }
}

FunctionParams包裹了取参数的成效,比如:

public Param getObject(Class p){ if(mObjectParams == null){ return null;
} return p.cast(mObjectParams.get((mIndex++) + “”)); }

1
2
3
4
   public  Param getObject(Class p){
        if(mObjectParams == null){ return null; }
         return p.cast(mObjectParams.get((mIndex++) + ""));
   }

取对象参数的效果,无需后人key值,只需求后人供给将在抽出来的类的Class实例就能够

FunctionParamsBuilder类,看它的名字就领会是用了设计方式里的Builder(营造)形式。该类是用来存放在参数的,当全数的参数都寄存实现后调用create()方法成立二个FunctionParams对象事物都以有两面性的,有顽固的病痛就有亮点,只然则是在一些场所下优点大于瑕疵,依旧恰恰相反。
FunctionParams竭泽而渔了上述提到的Bundle传递多参数各类不便的标题,但还要FunctionParams也会有二个久治不愈的病魔正是存参数的各样与取参数的种种必须要一直以来,比方:

//存的顺序 new FunctionParamsBuilder().putString(“1”).putInt(2)
.putBoolean(true).create(); //取的逐条 functionParams.getString();
functionParams.getInt(); functionParams.getBoolean();

1
2
3
4
5
6
7
8
    //存的顺序 new      
    FunctionParamsBuilder().putString("1").putInt(2)
    .putBoolean(true).create();
 
    //取的顺序
    functionParams.getString();
    functionParams.getInt();
    functionParams.getBoolean();

而是这种缺欠函数的定义来看亦非短处。

Activity与Fragment之间的通信是通过Functions的,即把变化的片段封装在Functions是类中,Functions起一个大桥成效。

此方案优点:

  • Fragment与Activity的耦合性差不离从未
  • 个性也好(没用反射)
  • 能够从Activity获取重临数据
  • 扩张性好(新添的成对的Activity与Fragment之间的通讯只需做以下几步:
    1.新添Activity只供给覆盖BaseActivity中的
    setFunctionsForFragment(int fragmentId)
    方法,把相应的回调函数参与。
    2.应和的Fragment定义函数key值就能够)

问题:大家关于传递多参数是还是不是有更加好的见解?有的话加小编qq:704451290,大概发我邮箱704451290@qq.com

总结

归纳总括为以下几点:

  • Fragment的使命
  • Activity与Fragment之间通讯的消除方案(handler,广播,伊芙ntBus,接口)的得失。
  • 笔者要好关于Activity与Fragment之间通讯的应用方案(Functions),其实化解的严重性是Fragment调用Activity的方案。希望大家能多提宝贵意见,多交流。代码地址

打赏扶助俺写出越来越多好小说,多谢!


打赏小编

打赏援助本身写出越来越多好文章,多谢!

任选一种支付格局

图片 2
图片 3

2 赞 3 收藏 1
评论

至于作者:牛犇

图片 4

笔者从结束学业到今天一贯致力android开辟工作,现就职于滴滴出游。本人心爱编制程序,兴趣爱好打台球,游泳。联系格局:微信/qq:
704451290自个儿的微信徒人账号:Android-IOS-devper
个人主页
·
笔者的篇章
·
13
·
     

留下评论

网站地图xml地图