java与android的接口回调

一、java接口回调

       定义：把 实现某一接口的类 创建的对象的引用  赋给 该接口声明的 接口变量中， 那么该接口变量 就可以调用被类重写的接口方法

       下面通过一个具体的例子来解析该定义

       1.  创建一个接口

       Test.java

       public interface Test{

          int getSum(int x);

       }

       2.  实现该接口的类

       Tom.java

       public class Tom implements Test{

           @Override

           public int getSum(int x){

              int sum = 0;

              for (int i=1; i <=x; ++i) {sum = sum + i;}

             return sum;

           }

       }

       3. 主类

       public class Demo{

             public static void main(String[]  args){

                  Test test; // 接口变量

                  Tom tom = new Tom();// 实现某一接口的类 创建的对象

                  test = tom; //对象的引用赋给接口变量

                  System.out.println("计算结果：" + test.getSum(20)); //该接口变量 就可以调用被类重写的接口方法

            }

       }

二、java接口回调引申：接口回调的多态性

       在上述例子的基础上，再定义一个实现该接口的类

       Jack.java

       public class Jack implements Test{

           @Override

           public int getSum(int x){

              int sum = 0;

              for (int i=1; i <=x; ++i) {sum = sum +2* i;}

             return sum;

           }

       }

      在主类中填加代码：

      Jack jack = new Jack();

      test = jack; 

      System.out.println("计算结果：" + test.getSum(20));

      则test会调用jack对象的test.getSum方法！！

      总结： 不同的类（Tom、Jack）在实现同一个接口（Test）时可能具有不同的实现方式，那么接口变量在回调接口方法时就可能具有多种形态。

 三、Android中Activuty方法回调

       原理与java接口回调方法类似，通过例子来模拟Activity的方法回调思想

      1.  Activity   接口

      public interface  Activity{

              //创建时调用的方法

              public void onCreate();

             //启动时调用的方法

             public void onStart();

              //销毁时调用的方法

               public void onDestory();

      }

      2.  实现该接口的类（就是平常写Android程序的主Acticity）

         public void MyActivity implements Activity{

             @Override

             public void onCreate(){

                   System.out.println("onCreate....");

             }

             @Override

             public void onStart(){

                   System.out.println("onStart....");

             }

             @Override

             public void onDestory(){

                   System.out.println("onDestoryt....");

             }

         }

    3. 系统运行环境类
         public class AndroidSystem{  
        / /定义创建常量  
         public static final int CREATE=1;  
         //定义启动常量  
        public static final int START=2;  
        //定义销毁常量  
        public static final int DESTORY=3;  
         //运行方法  
        public void run(Activity a,int state){  
           switch(state){  
               //创建  
               case CREATE:  
                    a.onCreate();  
                    break;  
               //启动  
                case START:  
                    a.onStart();  
                    break;  
                //销毁  
                 case DESTORY:  
                    a.onDestory();  
                    break;  
          }  
       }  
   }

   4.  测试类

     public class Test{  
     //主方法  
     public static void main(String[] args){  
         //实例化AndroidSystem  
         AndroidSystem system = new AndroidSystem();  
   
         //实例化MyActivity    直接将实现该类的对象的引用 赋给 接口变量
         Activity a = new MyActivity();  
   
         //创建  
         system.run(a,AndroidSystem.CREATE);  
         //启动  
         system.run(a,AndroidSystem.START);  
         //销毁  
         system.run(a,AndroidSystem.DESTORY);  
     }  
 } 

总结： 接口（Activity）以及大的框架（main函数中的流程）是系统提供的，Activity的具体实现是由用户决定的。这样可以达到接口统一，实现不同。系统通过在不同的状态“回调”我们的实现类，来达到接口和实现的分离。

四：参考文献

http://www.maiziedu.com/wiki/java/interface1/

https://www.ctolib.com/topics-70224.html