Java 面向接口编程

接口 (interface) ，用来描述一个类应该做什么，而不指定它们的具体逻辑。

举一个生活中的例子，比如说一部手机。我们可以定义一个"手机"接口标准，例如充电器要使用TYPE-C，安卓系统以及大小尺寸等，然后各大手机厂商就按照这个标准来生产手机，有一天手机坏掉了，但是充电器还是好的，那么我们把换个手机就可以还使用原来的充电器充电了。

在Java中的接口也是一样，接口不是类，而是对希望符合这个接口的类的一组需求。在代码设计中，我们事先约定好项目的各个功能的接口（接口的签名和方法），实际开发时就可以直接实现这个接口就可以继续完成实际逻辑了，并且如果项目在后续进行升级，我们只需要按照接口约定重新实现一下，就可以达到项目升级和扩展的目的。这也别称为面向接口编程。

1. 接口之间可以多继承
2. 接口中的方法都是抽象方法，不能有方法体
3. 接口不能够实例化
4. 接口中的常量默认省略 public static final
5. 接口中的方法默认是public并且是抽象方法
6. 接口和抽象类不同，抽象类是部分模板，部分规范；接口是完全规范

一个类可以实现(使用implements关键字) 实现一个或多个接口。

创建一个Car接口，Car接口用于规范汽车。

public interface Car {
     void drive();
}

在来一个Car接口的实现类：

public class BYD implements Car {
    // 重写了Car的方法
    @Override
    public void drive() {
        System.out.println("BYD... 启动");
    }
}

测试类

public class Main {
    public static void main(String[] args) {
        BYD byd = new BYD();
        byd.drive();
    }
}

输出：

BYD... 启动

在一个项目中，我们需要对用户信息进行管理或者CRUD操作。那么可以封装一个User类用于封装用户信息。

之后我们定义一个UserService接口，用于规范对User的操作。

接口的一大作用就是解耦

如下图UserService的实现都放到impl中，如果要升级代码，就将原来的直接替换掉即可。

package com.jc.bean;

public class User {
    private long userId; // 用户ID

    private String username; // 用户名

    private String password; // 密码

    public User() {
    }

    public User(long userId, String username, String password) {
        this.userId = userId;
        this.username = username;
        this.password = password;
    }

    public long getUserId() {
        return userId;
    }

    public void setUserId(long userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", username='" + username + ''' +
                ", password='" + password + ''' +
                '}';
    }
}

package com.jc.service;

import com.jc.bean.User;

public interface UserService {
    
    String login(String username, String password);

    
    User register(User user);
}

package com.jc.service.impl;

import com.jc.bean.User;
import com.jc.service.UserService;

public class UserServiceImpl implements UserService {
    @Override
    public String login(String username, String password) {
        // TODO
        return "success";
    }

    @Override
    public User register(User user) {
        // TODO
        return user;
    }
}

package com.jc;

import com.jc.bean.User;
import com.jc.service.UserService;
import com.jc.service.impl.UserServiceImpl;
import org.junit.Test;

public class UserTest {
    // 使用Spring就是从容器里自动注入的
    UserService userService = new UserServiceImpl();

    @Test
    public void testLogin() {
        String username = "abcde";
        String password = "123456";
        String r = userService.login(username, password);
        System.out.println(r);
    }

    @Test
    public void testRegister(){
        User user = new User(1, "abced", "123456");
        User r = userService.register(user);
        System.out.println(r);
    }
}

输出：

success

User{userId=1, username='abced', password='123456'}

Java8新增特性，接口中可以定义defalt方法，此方法可以拥有方法体。

public interface Test {
    default void test() {
        System.out.println("Hello, World!");
    }
}