大红鹰葡京娱乐中心设计师也要学物经济学

本文小编: 伯乐在线
牛犇
。未经小编许可,禁止转发!
迎接参加伯乐在线 专辑小编

原文出处: @養老虎的小怪獸_   

前言

大家会把从小到大对那么些世界的认识映射到显示器世界中。所以从东西规律的角度出发,斟酌一下平移曲线。

不久前一贯在想着能或不能够有一种更好的方案来消除:Android中Activity与Fragment之间通讯的题材,什么叫更好啊,便是能让Fragment的复用性高,质量还有好(不用反射),代码还要好维护,不要求为每对Activity和Fragment之间定义接口而犯愁。

正文并不深切物理定律的自家,只讲述活动曲线的应用,曾经上课睡觉的同班也不用担心。

先不难说下Javascript那门语言吧,恐怕有人就会问:大家不是聊Android的java难题呢?怎么话题转到JavaScript了。因为自个儿的消除方案的诱导是从它来的,没兴趣的心上人能够略过。近日在攻读javascript那门语言,同时协调搞Android(java)开发也有5年多日子了,所以在学习js的进程中,就会惯性的把那二者实行比较。

先引用下百科神马是物理:物教育学是研讨物质运动最相似规律和物质基本结构的科目。作为自然科学的领头学科,物经济学研商大至宇宙,小至基本粒子等方方面面物质最基本的位移格局和规律,因而成为其他各自然科学学科的钻研功底。它的论战结构充足地动用数学作为团结的行事语言,以实验作为检验理论正确性的唯一标准,它是今日最精美的一门自然科学学科。(猜你们也没仔细看,同理可得便是大体是一门13分牛逼的课程。)

与java语言的 严谨 相比
Javascript是一门“放荡不羁”、”放浪形骸”(宽泛)的语言。

自笔者一向觉得动作效果设计的自身是人机交互中那二个重要的环节,并且大家会把从小到大对这些世界的认识映射到显示器世界中。比如最广大的抓、扔、移动等操作,都是婴儿幼儿儿时代就习获得的基本本能,那么这个动作频繁会被大家本能的行使到长大后接触到的显示器操作中。

为啥要用“落拓不羁”那几个词呢,下边是它的一个诠释:

上一篇中早就涉嫌了一些动作效果设计的尺码(传送门),以及简单的写到了动效设计怎么着的表述让用户尤其酣畅。恩,今天要深切这几个话题,动作效果设计师怎样运用物理理论来让动画片曲线特别靠近现实世界,如何让你的动画效果更为的如烟花般炫丽。

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

让大家初叶进入物理世界~~

因为本身认为这一个词更能丰裕的反映js弱类型的特色。

大红鹰葡京娱乐中心 1

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

Isaac Newton(小伙年轻时候还挺帅,可惜后来就。。)

var a = 1;

**

1
var a = 1;

一.Newton率先定律 又称惯性定律 由Newton在1687年建议**

仍是能够那样写:

此外物体都要保险匀速直线运动或静止状态,直到外力迫使它改变运动状态结束。

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

怎么着是涵养匀速直线运动:

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

大红鹰葡京娱乐中心 2

竟然还足以那样写:

能够感到到,它的位移就好像有点俗气,因为我们生存的这么些世界存在引力、空气阻力、摩擦力等等。那就看一下最常见的外力因素——摩擦力,现实世界中的大多数活动都有它的身形。

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

 

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

1.摩擦力 F=μ×FN 

能够把此外类型的值赋给二个变量,也足以不加var关键字来声称3个变量,是否很随意,很不束缚啊。

截留物体相对运动(或相对运动趋势)的力叫做摩擦力。

“不拘小节”第③反映了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

A
静摩擦力:
多少个互相接触的物体,当其接触表面之间有相对滑动的趋向,但尚保持相对平稳时,互相成效着阻碍相对滑动的拦Ferrari,这种阻碍称为静滑动摩擦力,简称静摩擦力。

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

大红鹰葡京娱乐中心 3

地方的代码表达了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以前解决手提式无线话机、华为平板的适配问题是很脑瓜疼的,对ActivityGroup有印象的恋人,应该能深深的认知到ActivityGroup包裹的七个Activity之间切换等一密密麻麻的性质难题。因而Fragment诞生了。个人总括的Fragment的重任:

  • 消除手机、平板总结机等种种设备的适配难点
  • 杀鸡取卵八个Activity之间切换品质难题
  • 模块化,因为模块化导致复用的补益

B
动摩擦力:
两接触物体之间存在相对滑动时,其接触面上产生阻止对方滑动的拦法拉利称为动滑动摩擦力。

Fragment的使用

Fragment是能够被卷入在多个不等Activity内的,同时1个Activity内得以打包几个Fragment,Activity就如二个大的器皿,它能够管理八个Fragment。全体Activity与Fragment之间存在依靠关系。


大红鹰葡京娱乐中心 4

Activity与Fragment通讯方案

上文提到Activity与Fragment之间是存在依靠关系的,由此它们之间自然会提到到通讯难点,消除通讯难点必然会涉及到对象时期的引用。因为Fragment的出现有多少个首要的任务正是:模块化,从而压实复用性。若达到此意义,Fragment必须做到高内聚,低耦合。

现行反革命大家动动脚趾都能体悟的缓解它们之间通讯的方案有:handler,广播,EvnetBus,接口等(只怕还有其他方案,请大家多多分享),那大家就聊下这一个方案。

能够看出由于材质的不等,或许又助长制动等成分,只要记住物体表面粗糙及压力越大,摩擦力越大,结合下边包车型地铁Newton第2定律
就能够模拟出一些不比感觉的运动曲线了。

handler方案:

先上代码

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; } } …相应的处理代码 }

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方案:

切切实实的伊夫ntBus的行使可以团结搜索下,个人对该方案的观点:

  • EventBus是用反射机制落到实处的,品质上会不正常(不要和作者说品质不是题材,对于手机来说品质是大题材)
  • 伊芙ntBus难于维护代码
  • 不得已获取Activity的回来数据

二.Newton其次定律  F=ma 由Newton在1687年提议

接口方案

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

//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交互定义交互接口正是2个很头痛的标题(总结为接口的命名,新定义的接口相应的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); }
            }
     }
}

总结的说正是——物体越轻大概受到的力越大加速度越大:

统一筹划思路:

大红鹰葡京娱乐中心 5

1. 用一个类来效仿Javascript中的2个Function

Function哪怕此类,它是三个基类,每一种Functioon实例都有一个mFuncName
既然是格局(可能函数)它就有有参数和无参数之分
FunctionWithParam是Function的子类,代表有参数的方法类,方法参数通过泛型化解
FunctionNoParamAndResult是Function的子类,代表无参无再次来到值的法门类

 

2. 二个方可存放两个艺术(恐怕函数)的类

Functions类正是此类,上边不难介绍下Functions有五个非常重要措施:

  • addFunction(FunctionNoParamAndResult function)
    添加1个无参无重临值的措施类
  • 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(奥德赛.id.click1); mBut3 = (Button)
getView().findViewById(奇骏.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(); }
                     }
               });
  }

见状那你是或不是觉得已经完工了,当然是没有了,因为还有3个难题没化解。方法再次回到值和措施接收三个参数的标题。

三.Newton第3运动定律 F=-F’ 由Newton在1687年建议 

艺术再次回到值的难题

上代码:代码地址

/** * 有再次回到值,没有参数的不二法门 * @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中塞入数据时得有1个相应的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()方法创制1个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的方案。希望大家能多提宝贵意见,多调换。代码地址

打赏支持作者写出越多好小说,多谢!


打赏作者

大红鹰葡京娱乐中心 6

打赏支持作者写出越多好文章,谢谢!

任选一种支付办法

大红鹰葡京娱乐中心 7
大红鹰葡京娱乐中心 8

2 赞 3 收藏 1
评论

既然如此涉及牛三那就肯定要涉及四个它最重视的衍生定律了:

关于作者:牛犇

大红鹰葡京娱乐中心 9

作者从毕业到明天径直致力android开发工作,现就职于滴滴骑行。自个儿喜爱编程,兴趣爱好打斯诺克,游泳。联系方式:微信/qq:
704451290自己的微信公众账号:Android-IOS-devper
个人主页
·
笔者的稿子
·
13
·
     

 

1.动量守恒定律 m1v1+m2v2=m1v1′+m2v2′

三个系统不受外力或所受外力之和为零,那么那一个系统的总动量保持不变。

动量守恒定律最初是Newton第3定律的推测,
但后来察觉它们的适用范围远远广于Newton定律。简单的叙述就是,七个速度分化的实体碰撞之后会时有产生速度上的『传递』,打台球的同窗应该有更深的感触。

大红鹰葡京娱乐中心 10

 

 

四.阿基米德定律 F=γV

浸泡静止流体(气体或液体)中的物体受到一个浮力,其大小约等于该物体所排开的流体重量,方向垂直向上并通过所排开流体的形心。

于是水中物体弹出速度与实体的体量、质量成正比~而且会越接近水面越快。看下曲线图:

大红鹰葡京娱乐中心 11

 

能够发现浮起来的长河因为外力的主旋律持续变更造成多少看似弹性曲线,继而联想到了胡克(弹性)定律:

**

五.胡克定律  F=-k·x 又称弹性定律 由胡克在1678年提议**

弹簧在发生弹性形变时,弹簧的弹力F和弹簧的伸长量(或压缩量)x成正比,即F=
k·x
。k是物质的弹性周详,它只由材质的脾性所主宰,与其它因素非亲非故。负号表示弹簧所产生的弹力与其伸长(或裁减)的主旋律相反。

那么由胡可定律结合Newton第一定律F=ma,大家就足以得出弹性曲线来,这里的关键因素就是实体品质、弹性周详、伸长量来控制。

大红鹰葡京娱乐中心 12

*『制作』:描述弹性曲线日常的多个第3参数分别是:频率、过量、持续时间。

 

 

六.外表张笑飞

液体表面任意二相邻部分之间垂直于它们的单位长度分界线互相功能的拉力。表面刘宇的多变同处在液体表面薄层内的分子的特有受力状态密切相关。

表面王金良是动作效果设计中和阿基米德定律一样不难遭受的流体力学里的文化。算式相比较复杂,不再追究。吴亚轲的施用很广泛,那么大家做动效最常遇到的日常是融同盟用:

大红鹰葡京娱乐中心 13

 

总结

物理的利用基本上在我们生存的社会风气中并从未优异状态,所以领悟原理的同时,设计狮们请一定要心花怒放的观测大家身边的世界,真实世界才是最好的读书案例。

最后的结尾只要文中对科学道理的阐发有怎么着错误的地点,希望学霸同学们方可建议~

 

附一:压箱底的缓动函数曲线 http://easings.net/zh-cn(如打不开,请使用科学上网法)

附二:写的历程中也看出AliU有个别的篇章——动作效果设计的物理法则,重点的写了Newton第③次之定律,感兴趣的的同桌们能够点过去拜读下~

2 赞 收藏
评论