什么是interface

1、介绍

在Java编程语言中，interface是一个核心概念。interface提供了一种定义接口的方式，是一种规范、契约的体现。使用interface可以抽象出类的公共行为。在Java的继承机制中，class可以实现一个或多个interface，从而实现类似多继承的效果。

2、正文

1、接口的定义与基本语法

interface是Java中定义接口的关键字，用于定义一种规则或者契约，描述公共的行为、协定等。在interface内部可以定义一些方法，但是这些方法必须是抽象方法或者默认方法（JDK8开始支持）。

下面是interface的基本语法：

    public interface MyInterface {
        // 常量定义
        public static final int ID = 1;

        // 抽象方法定义
        public void doSomething();

        // 默认方法定义
        public default void doDefaultSomething() {
            // 实现代码
        }
    }

2、接口的作用

interface的主要作用是描述类的公共行为，即一组方法的集合。通过interface可以定义一些通用的规范，比如Java中的集合框架就是通过interface实现的。此外，interface还可以用来解决类的多继承问题，一个类可以实现多个interface，从而获得更多的行为和能力。

下面是一个示例，展示了如何通过interface描述一组类的公共行为：

    public interface Animal {
        public void eat();
        public void sleep();
    }

    public class Dog implements Animal {
        public void eat() {
            System.out.println("Dog eat.");
        }

        public void sleep() {
            System.out.println("Dog sleep.");
        }
    }

    public class Cat implements Animal {
        public void eat() {
            System.out.println("Cat eat.");
        }

        public void sleep() {
            System.out.println("Cat sleep.");
        }
    }

在上面的示例中，定义了一个Animal interface，然后定义了Dog和Cat两个类实现了Animal interface，并实现了其中的方法。这种设计方式可以帮助我们更好地管理和组织代码。

3、接口的继承

和class类似，interface也支持继承。一个interface可以继承一个或多个interface。继承的语法如下：

    public interface MyInterface2 extends MyInterface1 {
        // 新增抽象方法或者默认方法
    }

下面是一个示例，展示了如何通过继承来组织interface：

    public interface Student {
        public void study();
    }

    public interface Teacher {
        public void teach();
    }

    public interface Staff {
        public void work();
    }

    public interface Person extends Student, Teacher, Staff {
        public void eat();
        public void sleep();
    }

    public class StudentImpl implements Person {
        public void eat() {
            System.out.println("Student eat.");
        }

        public void sleep() {
            System.out.println("Student sleep.");
        }

        public void study() {
            System.out.println("Student study.");
        }

        public void teach() {
            // 空实现
        }

        public void work() {
            // 空实现
        }
    }

在上面的示例中，定义了Person interface继承了三个接口，然后定义了一个StudentImpl类实现了Person，并实现了其中的方法。这种设计方式可以让我们更好地组织和复用代码。

3、小标题

1、常量接口的使用

在Java中，可以使用interface来定义一组常量，称为常量接口。常量接口中的所有变量都是静态、final的，通常没有方法定义。常量接口的典型应用是在若干个类中定义一些公共常量变量，以避免每个类都要定义一遍。

下面是一个示例，展示了如何定义和使用常量接口：

    public interface Constants {
        public static final int MAX_VALUE = 100;
        public static final int MIN_VALUE = 0;
    }

    public class MyClass1 {
        private int value;

        public MyClass1(int value) {
            if (value >= Constants.MIN_VALUE && value <= Constants.MAX_VALUE) {
                this.value = value;
            } else {
                throw new IllegalArgumentException("invalid value: " + value);
            }
        }
    }

在上面的示例中，定义了一个Constants interface，其中定义了MAX_VALUE和MIN_VALUE两个常量，然后在MyClass1中使用了这些常量。

2、函数式接口的使用

Java 8中引入了函数式接口的概念，它是一个只有一个抽象方法的接口，用于支持lambda表达式。函数式接口可以用来定义行为，使得程序更加模块化和可组合。

下面是一个示例，展示了如何定义和使用函数式接口：

    @FunctionalInterface
    public interface MyFunc {
        public int apply(int x, int y);
    }

    public class MyClass2 {
        public int calc(MyFunc func, int x, int y) {
            return func.apply(x, y);
        }
    }

    public class Main {
        public static void main(String[] args) {
            MyClass2 myClass2 = new MyClass2();

            // 使用lambda表达式定义函数式接口
            MyFunc add = (x, y) -> x + y;

            // 调用calc方法，并传递函数式接口
            System.out.println(myClass2.calc(add, 1, 2)); // 输出3
        }
    }

在上面的示例中，定义了一个MyFunc接口，然后在MyClass2的calc方法中使用了MyFunc接口作为参数，接收一个函数式接口参数。使用lambda表达式定义了MyFunc接口的实现，然后调用calc方法，传递了一个函数式接口。

3、接口的默认方法

JDK8中引入了默认方法的概念，可以在接口中定义默认实现，避免了在实现类中重复实现相同的方法。同时，在接口升级时，也可以向接口中添加新的方法实现，而不会影响现有的实现类。但是，需要注意的一点是，使用默认方法会增加接口的复杂性，设计者需要谨慎考虑。

下面是一个示例，展示了如何定义和使用默认方法：

    public interface MyInterface3 {
        public void doSomething();

        // 定义默认方法
        public default void doDefaultSomething() {
            System.out.println("MyInterface3 default method.");
        }
    }

    public class MyClass3 implements MyInterface3 {
        public void doSomething() {
            System.out.println("MyClass3 doSomething.");
        }
    }

    public class Main {
        public static void main(String[] args) {
            MyClass3 myClass3 = new MyClass3();
            myClass3.doSomething(); // 输出MyClass3 doSomething.
            myClass3.doDefaultSomething(); // 输出MyInterface3 default method.
        }
    }

在上面的示例中，定义了一个MyInterface3接口，其中定义了doDefaultSomething默认方法。然后定义了一个MyClass3实现了MyInterface3，并实现了doSomething方法。在Main中使用myClass3分别调用了doSomething和doDefaultSomething方法。