Java接口的几种常见用法

野性酷女 2023-09-30 09:55 25阅读 0赞

接口（interface）对于面向对象编程来说是一个非常重要的概念。它是一系列方法的声明，却没有具体实现。有些编程语言，比如swift，把接口解释成“协议（protocol）”，我觉得也是非常的恰当的，接口就是对方法制定的一套规范。

总结了以下几点接口的常见用法

##### 1. 作为对类内执行流程的具体描述 #####

这是接口的最根本的作用。有时候类内部流程的某一个环节，并不是由此类自己决定的。类并不知道在这一步时具体会执行什么内容。所以需要在此处设置一枚接口，提供对外界的扩展。

对于这个功能有一个非常好的范例。

一个秒表类：用于测量执行某一段代码执行所需的时间。

初步的代码类似于下面这样：

public class Stopwatch {
        
      
        private long deltaTime;
     
        public void clear() {
        
            deltaTime = 0L;
        }
     
        public long getDeltaTime() {
        
            return deltaTime;
        }
     
        public void start() {
        
            long startTime = System.currentTimeMillis();
            // do something
            deltaTime = System.currentTimeMillis() - startTime;
        }
    }

而使用Stopwatch的代码类似于这样：

public static void main(String[] args) {
        
      Stopwatch stopwatch = new Stopwatch();
      stopwatch.clear();	//时间清零
      stopwatch.start();	//开始运行
      System.out.printf("time: %dms\n",stopwatch.getDeltaTime());
    }

那么我们知道对于秒表这个类本身，它并不能决定自己在do something那个位置将会测量什么内容的代码。

也就是说此处代码将会由`Stopwatch`的外部决定。所以此处可以商定一个协议，也就是接口。`Stopwatch`决定自己开放出一个接口叫`NeedMonitoringProgram`需要监控的程序，其中doProgram()方法就是执行需要被监控的代码。外部在使用`Stopwatch`时只需要去实现`NeedMonitoringProgram`接口也就定义好了需要监测的代码。

public interface NeedMonitoringProgram {
        
      void doProgram();
    }

给`Stopwatch`赋予`NeedMonitoringProgram`对象

public class Stopwatch {
        
     
        private long deltaTime;
        private NeedMonitoringProgram program;
     
        public void setProgram(NeedMonitoringProgram program) {
        
            this.program = program;
        }
     
        public void start() {
        
            long startTime = System.currentTimeMillis();
            program.doProgram();
            deltaTime = System.currentTimeMillis() - startTime;
        }
     
        public interface NeedMonitoringProgram {
        
            void doProgram();
        }
      
      //省略clear()和getDeltaTime()方法
    }

模拟测量1到1000000叠加求和所需时间

Stopwatch stopwatch = new Stopwatch();
    Stopwatch.NeedMonitoringProgram program = new Stopwatch.NeedMonitoringProgram() {
        
     
      @Override
      public void doProgram() {
        
        int sum = 0;
        int number = 1_000_000;
        for (int i = 0; i <= number; i++) {
        
          sum += i;
        }
        System.out.printf("sum: %d\n", sum);
      }
    };
    stopwatch.setProgram(program);
    stopwatch.clear();
    stopwatch.start();
    System.out.printf("time: %dms\n",stopwatch.getDeltaTime());

假如说待测代码是需要外部参数的，并且也需要返回给外部执行结果的。也可以把接口方法改进一下。

添加一个`Param`类来存储参数。

private Param params = new Param();
     
    public void addParam(String key, Object value) {
        
      	params.put(key, value);
    }
     
    public interface NeedMonitoringProgram<RETURN_OBJECT> {
        
      RETURN_OBJECT doProgram(Param params);
    }
     
    public class Param extends HashMap<String, Object> {
        
     
    }

start方法也可以直接加入`NeedMonitoringProgram`对象，减少使用时的步骤。 并且`NeedMonitoringProgram`类的泛型指定了返回类型。

public <T> T start(NeedMonitoringProgram<T> program) {
        
      long startTime = System.currentTimeMillis();
      T returnObject = program.doProgram(params);
      deltaTime = System.currentTimeMillis() - startTime;
      return returnObject;
    }

在执行start()之前使用addParam()给代码赋值。而start()也会返回代码执行的结果。

Stopwatch stopwatch = new Stopwatch();
    stopwatch.clear();
    stopwatch.addParam("number", 1_000_000);
    int sum = stopwatch.start(new Stopwatch.NeedMonitoringProgram<Integer>() {
        
     
        @Override
        public Integer doProgram(Stopwatch.Param params) {
        
          int sum = 0;
          int number = (Integer)params.get("number");
          for (int i = 0; i <= number; i++) {
        
          	sum += i;
          }
          return sum;
      }
    });
    System.out.printf("sum: %d\n", sum);
    System.out.printf("time: %dms\n",stopwatch.getDeltaTime());

运用JDK8的lambda表达式甚至可以缩写为

int sum = stopwatch.start(params -> {
        
      int s = 0;
      int number = (Integer)params.get("number");
      for (int i = 0; i <= number; i++) {
        
        s += i;
      }
      return s;
    });

虽然java没有函数对象这一概念，但是使用lambda可以充分表达一种函数式编程的思想，在这里接口即等同于代表了一个函数对象。

以上是接口最最根本的功能，广泛运用在AWT、Swing、Android这类图形化程序中。像XXXListener这些处理控件事件的接口都是运用了此功能。

##### 2. 多态 #####

可以把具体子类对象都当作父类来看，屏蔽不同子类对象之间的差异。

public interface Animal {
        
        void sayHello();
    }

public class Cat implements Animal{
        
        @Override
        public void sayHello() {
        
            System.out.println("I'm a cat.");
        }
    }

public class Dog implements Animal{
        
        @Override
        public void sayHello() {
        
            System.out.println("I'm a dog.");
        }
    }

public static void main(String[] args) {
        
      Animal[] animals = new Animal[]{
        new Cat(), new Dog()};
      for (Animal animal : animals) {
        
        animal.sayHello();
      }
    }

在这里把Cat和Dog都一视同仁的放入了Animal的数组内，并且批量处理。多态的功能其实和抽象类（abstract class）相同。

##### 3. 用于隐藏方法的具体实现过程 #####

一个简单的Dao

public interface UserDao {
        
      
      	User findUser(int id);
      
        void addUser(User user);
        
        void updateUser(User user);
        
        void deleteUser(int id);
    }

这个`DaoFactory`工厂类代表某一框架内部生成Dao的逻辑（超简化）

public class DaoFactory {
        
      
      	public <T> T getDaoInstance(Class<T> clazz) {
        
         	if(clazz == UserDao.class) {
        
              	return new UserDaoImpl();
         	} else if(……) {
        
              
         	}
      	}
    }

那么我们在使用该框架时，只需要从`DaoFactory`中通过Dao的类型获得该Dao的具体实现对象。

我们只关心该Dao接口有哪些我们可以用的方法，而不会去关心这个Dao内部是怎么实现增删改查的。拿着这个Dao对象我们就可以去完成数据库的操作。也就是说接口为我们屏蔽了方法的具体实现，屏蔽了具体的实现类中一些杂乱无章的，对于使用者来说无用的中间方法。

##### 4. 暴露分布式服务 #####

public interface XXXService {
        
      
    }

在大型网站项目中，底层的服务都是基于分布式部署的。比如说Dubbo框架，在分布式项目中，接口和实现是分离于两个子项目中的。分布式的优势在于，通过架设多台服务提供者（provider）维持了服务提供的稳定性。只要不是所有服务提供者挂机，服务消费者（consumer）依然可以得到稳定的服务。对于服务消费者来说它并不关心服务是由谁提供的，只关心有哪些服务可以用，所以接口既屏蔽了方法的具体实现，甚至还可以接来自不同服务提供者的服务。在这里，接口起到了一个协议的作用，消费者需要哪些服务，由接口描述，同时提供者根据接口实现了自己的处理服务逻辑。

##### 5. 赋予类某种能力 #####

我们常常会遇到一些诸如XXXable，以able结尾的类

比如说`java.io.Serializable`这是赋予了类可序列化的能力

我们自己也可以写给类赋予能力的接口以及实现。

做过微信支付的应该都知道，对接微信支付需要发送包含xml字符串的HTTP请求。

那么就可以对微信支付功能封装一个客户端（Client）

那么大致步骤如下：

public class WechatClient{
        
     
        /**
         * 统一下单
         */
        public void unifiedOrder() {
        
            //1. 生成xml
          	//2. 发送HTTP请求
          	//3. 处理请求结果
        }
    }

接下来给客户端类赋予可发送HTTP请求的能力，声明一个接口：

public interface HttpSendable {
        
    	//发送GET请求
        HttpResponse getHttps(String url);
    	//发送包含raw富文本的POST请求
        HttpResponse postHttps(String url, String raw);
    }

`HttpSendable`顾名思义就是可发送HTTP请求的能力

那么给客户端加上这个能力

public class WechatClient implements HttpSendable

这个能力的实现可以使用抽象父类实现，不会造成次要代码污染主要类的逻辑

public abstract class HttpSender implements HttpSendable{
        
        @Override
        public HttpResponse getHttps(String url) {
        
            return null;
        }
     
        @Override
        public HttpResponse postHttps(String url, String raw) {
        
            return null;
        }
    }

`HttpSender`就是HTTP的发送者，当然它也有发送HTTP的能力`HttpSendable`然后客户端继承了它

public class WechatClient extends HttpSender implements HttpSendable{
        
     
        /**
         * 统一下单
         */
        public void unifiedOrder() {
        
          	//1. 生成xml
          	String xml = "";//代码略
          	//2. 发送HTTP请求
            HttpResponse response = super.postHttps("https://", xml);
          	//3. 处理请求结果
          	//代码略
        }
    }

像这样写代码，是不是会增加代码的可理解性了呢？

##### 6. 作为常量接口 #####

一般老java程序员都喜欢这么用，包括JDK内部也有这么用的。把一些常量扔在接口里面。

//申请状态常量
    public interface ApplyStatusContants {
        
      	public static final String STATIC_UNTREATED = "STATIC_UNTREATED";//未处理
      	public static final String STATIC_ACCEPT = "STATIC_ACCEPT"; //通过
      	public static final String STATIC_REJECT = "STATIC_REJECT"; //拒绝
    }

不过自从JDK1.5以后新增了enum枚举类型。我们就不需要常量接口了，可以如下方式：

public enum ApplyStatus {
        
      	UNTREATED, ACCEPT, REJECT
    }

简单粗暴。

接口的用法还是特别灵活多变的，也许还有没有列举的用法，欢迎大家补充。