Android中接口(Interface)的简单使用

今天药忘吃喽~ 2022-03-18 04:08 436阅读 0赞

#  #

> Java中的接口可以被看作是 `只包含常量和抽象方法的抽象类` 。

可以使用如下方式定义一个接口：

public interface InterfaceDemo {
        int i = 10;
        void method1();
        int method2();
    }

## 使用1： 解决“多重继承”的问题 ##

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

*  MyInterface1.java

public interface MyInterface1 {
        void fly();
    }

*  MyInterface2.java

public interface MyInterface2 {
        void walk();
    }

*  Bird.java

![复制代码][copycode.gif]

public class Bird implements MyInterface1, MyInterface2 {
        private static final String TAG = "Bird";
        @Override
        public void fly() {
            Log.i(TAG, "I can fly");
        }
    
        @Override
        public void walk() {
            Log.i(TAG, "I can walk");
        }
    }

![复制代码][copycode.gif]

## 使用2： 定义一个规范（协议） ##

同一个接口可以有多个不同的实现类，但每一个实现类都必须重写接口中所有的抽象方法。即接口不考虑这些实现类各自采用什么方式实现这些功能，但它要求所有的实现类都必须有这些功能。  
例如：  
首先定义一个计算器的接口：Calculator.java,所有实现该接口的类，都必须具有计算两个数相加、相减、相乘、相除的功能。

![复制代码][copycode.gif]

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);
    }

![复制代码][copycode.gif]

再定义一个实现该接口的类ACalculator.java

![复制代码][copycode.gif]

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;
        }
    }

![复制代码][copycode.gif]

在其他类中使用ACalculator进行两数之和的计算。其他类并不需要了解ACalculator是通过什么方式计算的，只需要了解Calculator接口中的相关方法定义即可。  
Test.java

![复制代码][copycode.gif]

public class Test {
        public static void main(String[] args) {
            Calculator calculator = new ACalculator();
            int sum = calculator.add(12, 14);
            System.out.println("sum = " + sum);
        }
    }

![复制代码][copycode.gif]

## 使用3： 用于回调 ##

我们知道，一般情况下主线程是不执行耗时任务的，如果遇到一些耗时任务（如网络请求，文件读写，数据库读写等等），我们会将其放入子线程中去执行，当执行完毕后，子线程再将执行结果返回给主线程。这个过程就是回调。

看一个例子。  
首先定义一个回调接口。  
OnInfoFetchCallback.java

![复制代码][copycode.gif]

public interface OnInfoFetchCallback {
        /** 获取信息成功 */
        void onSuccess(String info);
        /** 获取信息失败 */
        void failure();
    }

![复制代码][copycode.gif]

再定义一个用于获取信息的任务类，在这个类中我们执行一些耗时操作。  
InfoService.java

![复制代码][copycode.gif]

public class InfoService {
        private OnInfoFetchCallback callback;
        public InfoService(OnInfoFetchCallback callback) {
            this.callback = callback;
        }
    
        public void getInfo() {
            // 模拟一个耗时操作
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(3000);
                        // 信息获取成功，传递结果
                        callback.onSuccess("结果是：" + new Date());
                    } catch (InterruptedException e) {
                        // 信息获取失败
                        callback.failure();
                    }
                }
            });
            thread.start();
        }
    }

![复制代码][copycode.gif]

在MainActivity中调用InfoService中的getInfo()方法执行耗时操作。

![复制代码][copycode.gif]

public class MainActivity extends AppCompatActivity implements OnInfoFetchCallback {
        private static final String TAG = "MainActivity";
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
    
        /**
         * 获取信息
         * @param view
         */
        public void fetchInfo(View view) {
            InfoService service = new InfoService(this);
            service.getInfo();
        }
    
        @Override
        public void onSuccess(String info) {
            Log.i(TAG, info);
        }
    
        @Override
        public void failure() {
            Log.i(TAG, "获取信息失败");
        }
    }

![复制代码][copycode.gif]

由于MainActivity已经实现了OnInfoFetchCallback 接口，所以在实例化InfoService对象时，直接将`this`传入即可。当任务执行结束后，调用MainActivity中的`onSuccess(String info)`或`failure()`方法将结果返回。

MainActivity也可以不用实现OnInfoFetchCallback 接口，此时可以采用匿名内部类的写法。

*如下所示：*

![复制代码][copycode.gif]

/**
         * 获取信息
         * @param view
         */
        public void fetchInfo(View view) {
            InfoService service = new InfoService(new OnInfoFetchCallback() {
                @Override
                public void onSuccess(String info) {
                    Log.i(TAG, info);
                }
    
                @Override
                public void failure() {
                    Log.i(TAG, "获取信息失败");
                }
            });
            service.getInfo();
        }

![复制代码][copycode.gif]

布局文件非常简单，只有一个按钮。

activity\_main.xml

![复制代码][copycode.gif]

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context="cc.duduhuo.interfacedemo.MainActivity">
    
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="获取信息"
            android:onClick="fetchInfo"/>
    </RelativeLayout>

![复制代码][copycode.gif]

Android中接口的三种基本使用方式已经介绍完了，该博文相关代码可通过下方地址下载：

[相关源码点击此处下载][Link 1]

**回调**就是把方法的定义和功能导入实现分开的一种机制，目的是为了解耦，本质是基于观察者设计模式，是观察者模式的简版化，回调的目的主要有两个：一是传递数据，二是保持数据的同步更新。常用的两种形式：一种是使用内部类的形式，得到接口的子对象 如：

# 匿名内部类实现接口回调的总结以及demo #

一、Android中为什么使用匿名内部类的方式？

使用一次之后会自动被填充到垃圾回收机制被销毁，节省手机的内存，所以在Android中使用普遍。

二、如何使用

1.定义一个接口

![70][]

2.需要传递数据的地方写一个方法，然后把接口作为实际参数传递进去，并且在方法体里面调用接口的方法

![70 1][]

3、在获取数据的地方使用匿名内部类的方式

3.1、 获取传递数据类的实例

![70 2][]

3.2、对象.方法（new 接口名）

![70 3][]

demo地址：[https://download.csdn.net/upload][https_download.csdn.net_upload]

并感谢：[https://blog.csdn.net/jonsnoww/article/details/68932292][https_blog.csdn.net_jonsnoww_article_details_68932292]

第二种是直接实现定义的接口

1.先定义接口

public interface InfoInter {
    
    
        void  add(int a);
        void  delete();
    
    }

2.定义业务处理层 接口作为成员变量，调用接口的方法 将需要传递的参数传给接口的方法

public class num {
    
    InfoInter infoInter;
        public num(InfoInter infoInter){
            this.infoInter=infoInter;
        }
    
    
    
        public void getnum(){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    int a=4;
                    int b=5;
                    infoInter.add(a+b);
                }
            }).start();
    
        }
    }

3.定义实现接口的Activity 或者是Framgent 实现接口的方法 去的获取得到数据做处理。

public class test extends Activity implements InfoInter {
    
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            num n=new num(this);
            n.getnum();
        }
    
    
        @Override
        public void add(int a) {
    
            int bb=a;
        }
    
        @Override
        public void delete() {
    
        }
    }

[copycode.gif]: /images/20220318/db69f15bde044773833631bcbef5ba03.png
[Link 1]: http://download.csdn.net/detail/u012939909/9608555
[70]: /images/20220318/eee15e9b9428470986779e077801f6c7.png
[70 1]: /images/20220318/870a203822ac4b5fb95c19a7acd88f07.png
[70 2]: /images/20220318/ec9ef51b05984e739d8493dcef0e4c8b.png
[70 3]: /images/20220318/5a43fe9e365d4cbf8ad629444e3ab5bc.png
[https_download.csdn.net_upload]: https://download.csdn.net/upload
[https_blog.csdn.net_jonsnoww_article_details_68932292]: https://blog.csdn.net/jonsnoww/article/details/68932292