什麼是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方法。