Android interface(接口)详解

什么是接口

可以理解成一种特殊的类,由常量和抽象方法组成的特殊类; 接口不可以实例化；接口中的方法没有方法体；继承接口的类一定要实现接口中定义的方法。
例：

public interface InterfaceDemo {
    int i = 10;            //常量
    void method1();        //方法（没有方法体）
    int method2();         //方法（没有方法体）
}

接口的使用场景

1. 多重继承
   Java本身是不支持类的多重继承(多重继承是指一个类从多个类继承而来，即一个类拥有多个超类)
   但一个类却可以实现多个接口，我们可以将一些抽象方法定义在接口中，使用继承多个接口的方法间接地达到多重继承的目的
   例：

//第一个接口
public interface MyInterface1 {
    void fly();
}

//第二个接口
public interface MyInterface2 {
    void walk();
}

public class Bird implements MyInterface1, MyInterface2 {   //通过implements关键字继承上述两个接口，多个接口用“，”分隔
    private static final String TAG = "Bird";
    @Override                     // 实现接口MyInterface1中的fly()方法
    public void fly() {
        Log.i(TAG, "I can fly");  // 可根据需求完成自己的方法体
    }

    @Override
    public void walk() {          // 实现接口MyInterface2中的walk()方法
        Log.i(TAG, "I can walk"); // 可根据需求完成自己的方法体
    }
}

2. 定义一个规范
   同一个接口可以有多个不同的实现类，但每一个实现类都必须重写接口中所有的抽象方法。
   即接口不考虑这些实现类各自采用什么方式实现这些功能，但它要求所有的实现类都必须有这些功能。
   例：

//定义一个计算器接口
public interface Calculator {
    /** 计算器可以计算两个数的和 */
    int add(int a, int b);
    /** 计算器可以计算两个数的差 */
    int sub(int a, int b);
    /** 计算器可以计算两个数的积 */
    long mul(int a, int b);
    /** 计算器可以计算两个数的商 */
    float div(int a, int b);
}

//该类实现了计算器接口，并填充了具体实现方法
public class ACalculator implements Calculator {
    @Override
    public int add(int a, int b) {         //实现接口
        return a + b;                      //具体实现方法
    }

    @Override
    public int sub(int a, int b) {         //实现接口
        return a - b;                      //具体实现方法
    }

    @Override
    public long mul(int a, int b) {        //实现接口
        return a * b;                      //具体实现方法
    }

    @Override
    public float div(int a, int b) {       //实现接口
        return (float) a / (float) b;      //具体实现方法
    }
}

//这个类中使用ACalculator中的方法。这里并不需要了解ACalculator是通过什么方式计算的，只需要了解Calculator接口中的相关方法定义即可。 
Test.java
Test.java
public class Test {
    public static void main(String[] args) {
        Calculator calculator = new ACalcuAlator();  //接口赋值（ACalcuAlator类中已经实现了Calculator接口）
        int sum = calculator.add(12, 14);            //相当于调用ACalcuAlator中的add（）方法
        System.out.println("sum = " + sum);
    }
}

3. 回调
   回调就是把方法的定义和功能实现分开的一种机制
   例：

//定义一个接口
public interface OnListener {
         public void onClick(String msg);
  }

class Test {
    private OnListener onListener ;       //定义一个的接口类型的变量存储数据
    
    //在合适的位置调用接口里面的方法，传递数据
    public void callBack(string msg) {
        if (onListener != null) {
            onListener .onClick(msg);
        }
    }
    //创建一个公共的方法，让外部调用，并且传递接口类型的参数，给其定义的接口类型的数据初始化
    public void setOnListener(OnListener onListener) {
        this.onListener= onListener;
    }
}

public  class  Activity {
    Test test;
test.setOnListener(new Test.OnListener () {
               @Override
               public void onClick(msg) {
                     //使用传回的值
               }
        });
}

接口的实现写法

//定义接口
public interface OnKeyValueListener {

    void  getKeyValueClick(String value);
}

public class MyButton {
    public MyButton(Context context) {
    }
    private OnKeyValueListener mOnkeyValueListener; //声明OnKeyValueListener接口对象

    //接口中的方法赋值（传递需要的数据）
    public void doClick() {
       if (mOnkeyValueListener!= null) {
        mOnkeyValueListener.getKeyValueClick("点击了A");
        }
    }

    public void setmOnkeyValueListener(OnKeyValueListener mOnkeyValueListener) {
        this.mOnkeyValueListener = mOnkeyValueListener; //MainActivity 类中调用该方法，传入监听对象
    }
}

1. implements形式

public class MainActivity extends Activity implements OnKeyValueListener{

    MyButton myButton ;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        myButton = new MyButton(MainActivity.this);
        myButton.setmOnkeyValueListener(this); //传递监听对象到A类
        myButton.doClick(); //这里是调用A类中的方法，接受到A类传入的内容
    }

    @Override
    public void getKeyValueClick(String value) {
        Log.d("MyLog","######## value = "+value); //打印获取到的内容
    }
}

3. 内部类形式

public class MainActivity extends Activity{

    MyButton myButton ;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        myButton.setmOnkeyValueListener(new MyButton.OnKeyValueListener () {
               @Override
               public void getKeyValueClick(String value) {
                     Log.d("MyLog","######## value = "+value); //打印获取到的内容
               }
        });
}