疯狂JAVA讲义学习——基础代码练习——Interface——接口

我就是我 2023-09-30 10:03 15阅读 0赞

## Java 接口 ##

接口(英文：Interface)，在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。

一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

####  ####

#### 接口与类相似点： ####

*  一个接口可以有多个方法。
 *  接口文件保存在 .java 结尾的文件中，文件名使用接口名。
 *  接口的字节码文件保存在 .class 结尾的文件中。
 *  接口相应的字节码文件必须在与包名称相匹配的目录结构中。

####  ####

#### 接口与类的区别： ####

*  接口不能用于实例化对象。
 *  接口没有构造方法。
 *  接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
 *  接口不能包含成员变量，除了 static 和 final 变量。
 *  接口不是被类继承了，而是要被类实现。
 *  接口支持多继承。

####  ####

#### 接口特性 ####

*  接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 **public abstract**(只能是 public abstract，其他修饰符都会报错)。
 *  接口中可以含有变量，但是接口中的变量会被隐式的指定为 **public static final** 变量(并且只能是 public，用 private 修饰会报编译错误)。
 *  接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

####  ####

#### 抽象类和接口的区别 ####

*  1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
 *  2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 **public static final** 类型的。
 *  3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
 *  4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

**注**：JDK 1.8 以后，接口里可以有静态方法和方法体了。

**注**：JDK 1.8 以后，接口允许包含具体实现的方法，该方法称为"默认方法"，默认方法使用 default 关键字修饰。更多内容可参考 [Java 8 默认方法][Java 8]。

**注**：JDK 1.9 以后，允许将方法定义为 private，使得某些复用的代码不会把方法暴露出去。更多内容可参考 [Java 9 私有接口方法][Java 9]。

### 接口的声明 ###

![c64d452fb4b8ebb044ecddc32dceffd1.png][]

接口有以下特性：

*  接口是隐式抽象的，当声明一个接口的时候，不必使用**abstract**关键字。
 *  接口中每一个方法也是隐式抽象的，声明时同样不需要**abstract**关键字。
 *  接口中的方法都是公有的。

![26cc787d9aa8c0096d8c3f9c92814f48.png][]

### 接口的实现 ###

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

实现一个接口的语法，可以使用这个公式：

![6791c2c845ab8e8726f817e0f9ec47dc.png][]

![a4b7b9807e9feb193a8427ba538ab5d9.png][]

重写接口中声明的方法时，需要注意以下规则：

*  类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
 *  类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
 *  如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

在实现接口的时候，也要注意一些规则：

*  一个类可以同时实现多个接口。
 *  一个类只能继承一个类，但是能实现多个接口。
 *  一个接口能继承另一个接口，这和类之间的继承比较相似。

![db11185480ac51d84ef1e6260531c3ba.png][]

![a87b7d863ba9f58f1f32211155fd0488.png][]

没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：

*  **建立一个公共的父接口：**
    
    正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
 *  **向一个类添加数据类型：**
    
    这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

======================================================================

=======================================================================

Java 8 新增了接口的默认方法。

简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。

我们只需在方法名前面加个 default 关键字即可实现默认方法。

> **为什么要有这个特性？**
> 
> 首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

#### 语法 ####

默认方法语法格式如下：

public interface Vehicle {
       default void print(){
          System.out.println("我是一辆车!");
       }
    }

#### 多个默认方法 ####

一个接口有默认方法，考虑这样的情况，一个类实现了多个接口，且这些接口有相同的默认方法，以下实例说明了这种情况的解决方法：

![f1590958639b221c46188e67257eb73f.png][]

![0035fa1534757697eb710ba9056e7034.png][]

![5aa5bde03fefbb51c2da66c50b5112fc.png][]

![84bf6d495efc5bedae81d0130f62582a.png][]

=======================================================================

========================================================================

在 Java 8之前，接口可以有常量变量和抽象方法。

我们不能在接口中提供方法实现。如果我们要提供抽象方法和非抽象方法(方法与实现)的组合，那么我们就得使用抽象类。

public class Tester {
       public static void main(String []args) {
          LogOracle log = new LogOracle();
          log.logInfo("");
          log.logWarn("");
          log.logError("");
          log.logFatal("");
          LogMySql log1 = new LogMySql();
          log1.logInfo("");
          log1.logWarn("");
          log1.logError("");
          log1.logFatal("");
       }
    }
    final class LogOracle implements Logging {
       @Override
       public void logInfo(String message) {
          getConnection();
          System.out.println("Log Message : " + "INFO");
          closeConnection();
       }
       @Override
       public void logWarn(String message) {
          getConnection();
          System.out.println("Log Message : " + "WARN");
          closeConnection();
       }
       @Override
       public void logError(String message) {
          getConnection();
          System.out.println("Log Message : " + "ERROR");
          closeConnection();
       }
       @Override
       public void logFatal(String message) {
          getConnection();
          System.out.println("Log Message : " + "FATAL");
          closeConnection();
       }
       @Override
       public void getConnection() {
          System.out.println("Open Database connection");
       }
       @Override
       public void closeConnection() {
          System.out.println("Close Database connection");
       }
    }
    final class LogMySql implements Logging {
       @Override
       public void logInfo(String message) {
          getConnection();
          System.out.println("Log Message : " + "INFO");
          closeConnection();
       }
       @Override
       public void logWarn(String message) {
          getConnection();
          System.out.println("Log Message : " + "WARN");
          closeConnection();
       }
       @Override
       public void logError(String message) {
          getConnection();
          System.out.println("Log Message : " + "ERROR");
          closeConnection();
       }
       @Override
       public void logFatal(String message) {
          getConnection();
          System.out.println("Log Message : " + "FATAL");
          closeConnection();
       }
       @Override
       public void getConnection() {
          System.out.println("Open Database connection");
       }
       @Override
       public void closeConnection() {
          System.out.println("Close Database connection");
       }
    }
    interface Logging {
       String ORACLE = "Oracle_Database";
       String MYSQL = "MySql_Database";
     
       void logInfo(String message);
       void logWarn(String message);
       void logError(String message);
       void logFatal(String message);
     
       void getConnection();
       void closeConnection();

以上实例执行输出结果为：

Open Database connection
    Log Message : INFO Close Database connection Open Database connection Log Message : WARN Close Database connection Open Database connection Log Message : ERROR Close Database connection Open Database connection Log Message : FATAL Close Database connection

在上面的例子中，每个日志方法都有自己的实现。

在 Java 8 接口引入了一些新功能——默认方法和静态方法。我们可以在Java SE 8的接口中编写方法实现，仅仅需要使用 default 关键字来定义它们。

在 Java 8 中，一个接口中能定义如下几种变量/方法：

*  **常量**
 *  **抽象方法**
 *  **默认方法**
 *  **静态方法**

以上实例执行输出结果为：

Java 9 不仅像 Java 8 一样支持接口默认方法，同时还支持私有方法。

在 Java 9 中，一个接口中能定义如下几种变量/方法：

*  **常量**
 *  **抽象方法**
 *  **默认方法**
 *  **静态方法**
 *  **私有方法**
 *  **私有静态方法**

以下实例提取了冗余到通用方法，看起来明显更简洁：

以上实例执行输出结果为：

OpenDatabase connection
    LogMessage: INFO
    CloseDatabase connection
    OpenDatabase connection
    LogMessage: WARN
    CloseDatabase connection
    OpenDatabase connection
    LogMessage: ERROR
    CloseDatabase connection
    OpenDatabase connection
    LogMessage: FATAL
    CloseDatabase connection

=========================================================================

==========================================================================

**接口(interface)**

*接口*是*抽象方法*和*常量值*的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类只包含常量和方法的定义，而没有变量和方法的实现。

格式：*interface 接口名\{\}*

接口的出现将"多继承"通过另一种形式体现出来，即"多实现"。

**实现(implements)**

格式：*class 类名 implements 接口名 \{\}*

**特点**：

*  接口不能被实例化。
 *  一个类如果实现了接口，要么是抽象类，要么实现接口中的所有方法。

**接口的成员特点**：

*接口中的成员修饰符是固定的！*

*  成员常量：public static final，接口里定义的变量是全局常量，而且修饰符只能是这三个关键字，都可以省略，常量名要大写。
 *  成员方法：public abstract，接口里定义的方法都是抽象的，两个修饰符关键字可省略。
 *  推荐：永远手动给出修饰符。

**继承与实现的区别**：

*  类与类之间称为继承关系：因为该类无论是抽象的还是非抽象的，它的内部都可以定义非抽象方法，这个方法可以直接被子类使用，子类继承即可。只能单继承，可以多层继承。(**(class)**)
 *  类与接口之间是实现关系：因为接口中的方法都是抽象的，必须由子类实现才可以实例化。可以单实现，也可以多实现；还可以在继承一个类的同时实现多个接口。(**(class) extends (class) implements (interface1,interface2…)**)
 *  接口与接口之间是继承关系：一个接口可以继承另一个接口，并添加新的属性和抽象方法，并且接口可以多继承。(**(interface) extends (interface1,interface2…)**)

**抽象类和接口的区别**：

*成员变量*

*  抽象类能有变量也可以有常量
 *  接口只能有常量

*成员方法*

*  抽象类可以有非抽象的方法,也可以有抽象的方法
 *  接口只能有抽象的方法

*构造方法*

\-抽象类有构造方法  
\-接口没有构造方法

*类与抽象类和接口的关系*

*  类与抽象类的关系是继承 extends
 *  类与接口的关系是实现 implements

**接口的思想特点**：

1.  1.  接口是*对外暴露*的规则；
    2.  接口是程序的*功能扩展*；
    3.  接口的出现*降低耦合性*；(实现了模块化开发,定义好规则,每个人实现自己的模块,大大提高了开发效率)
    4.  接口可以用来*多实现*；
    5.  *多个*无关的类可以实现同一个接口；
    6.  一个类可以实现*多个*相互直接没有关系的接口；
    7.  与继承关系类似，接口与实现类之间存在*多态性*。

//运动员和教练的案例(下图是思路分析)
    
    /*
        篮球运动员和教练
        乒乓球运动员和教练
        现在篮球运动员和教练要出国访问,需要学习英语
        请根据你所学的知识,分析出来哪些是类,哪些是抽象类,哪些是接口
    */
    interface SpeakEnglish {
        public abstract void speak();
    }
    
    interface GoAboard{
        public abstract void aboard();
    }
    
    abstract class Person {
        private String name;
        private int age;
    
        public Person(){}
    
        public Person(String name,int age){
            this.name = name;
            this.age = age;
        }
    
        public void setName(String name){
            this.name = name;
        }
        public String getName(){
            return name;
        }
    
        public void setAge(int age){
            this.age = age;
        }
        public int getAge(){
            return age;
        }
    
        //吃饭
        public abstract void eat();
        //睡觉
        public void sleep(){
            System.out.println("Zzz...");
        }
    }
    //运动员
    abstract class Player extends Person {
        public abstract void study();
    }
    //教练
    abstract class Coach extends Person {
        public abstract void teach();
    }
    
    //篮球运动员
    class BasketballPlayer extends Player implements SpeakEnglish,GoAboard{
        public void eat(){
            System.out.println(getAge() + "岁的" + getName() + "吃鸡腿");
        }
    
        public void study(){
            System.out.println(getAge() + "岁的" + getName() + "学扣篮");
        }
    
        public void speak(){
            System.out.println(getAge() + "岁的" + getName() + " Say Hello World");
        }
    
        public void aboard(){
            System.out.println(getAge() + "岁的" + getName() + " Go Aboard");
        }
    }
    //乒乓运动员
    class PingPangPlayer extends Player{
        public void eat(){
            System.out.println(getAge() + "岁的" + getName() + "吃鸡蛋");
        }
    
        public void study(){
            System.out.println(getAge() + "岁的" + getName() + "学扣球");
        }
    }
    //篮球教练
    class BasketballCoach extends Coach implements SpeakEnglish {
        public void eat(){
            System.out.println(getAge() + "岁的" + getName() + "啃鸡爪");
        }
    
        public void teach(){
            System.out.println(getAge() + "岁的" + getName() + "教扣篮");
        }
    
        public void speak(){
            System.out.println(getAge() + "岁的" + getName() + " Say Hello Java");
        }
    
        public void aboard(){
            System.out.println(getAge() + "岁的" + getName() + " Go Aboard");
        }
    }
    //乒乓球教练
    class PingPangCoach extends Coach{
        public void eat(){
            System.out.println(getAge() + "岁的" + getName() + "吃鸡蛋皮");
        }
    
        public void teach(){
            System.out.println(getAge() + "岁的" + getName() + "教扣球");
        }
    }
    class PlayerAndCoach {
        public static void main(String[] args) {
            //篮球运动员
            BasketballPlayer bp = new BasketballPlayer();
            bp.setName("郭艾伦");
            bp.setAge(33);
            bp.eat();
            bp.sleep();
            bp.study();
            bp.speak();
            bp.aboard();
            System.out.println("***********************");
            //篮球教练
            BasketballCoach bc = new BasketballCoach();
            bc.setName("波波维奇");
            bc.setAge(65);
            bc.eat();
            bc.sleep();
            bc.teach();
            bc.speak();
            bc.aboard();
            System.out.println("***********************");
            //多态
            Person p = new BasketballPlayer();
            p.setName("Kobe Bryant");
            p.setAge(33);
            p.eat();
            p.sleep();
            //p.study();
            //p.speak();
    
            BasketballPlayer bp2 = (BasketballPlayer)p;
            bp2.study();
            bp2.speak();
            bp2.aboard();
            System.out.println("***********************");
        }
    }

=========================================================================

### Java 9改进的接口 ###

抽象类是从多个类中抽象出来的模板，如果将这种抽象进行得更彻底，则可以提炼出一种更加特殊的“抽象类”—接口(interface)。

Java 8对接口进行了改进，允许在接口中定义默认方法和类方法，默认方法和类方法都可以提供方法实现，Java 9为接口增加了一种私有方法，私有方法也可提供方法实现。

接口定义使用interface关键字，接口定义的基本语法如下：

![97edb8b83d82a1cf1c5bd7724d552dd0.png][]

➢ 修饰符可以是public或者省略，如果省略了public访问控制符，则默认采用包权限访问控制符。

➢ 接口名应与类名采用相同的命名规则

➢ 一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。

由于接口定义的是一种规范，因此接口里不能包含构造器和初始化块定义。

接口里可以包含成员变量(只能是静态常量)、方法(只能是抽象实例方法、类方法、默认方法或私有方法)、内部类(包括内部接口、枚举)定义。

接口的继承和类继承不一样，接口完全支持多继承，即一个接口可以有多个直接父接口。和类继承相似，子接口扩展某个父接口，将会获得父接口里定义的所有抽象方法、常量。

一个接口继承多个父接口时，多个父接口排在extends关键字之后，多个父接口之间以英文逗号(,)隔开。

接口主要有如下用途：➢ 定义变量，也可用于进行强制类型转换。➢ 调用接口中定义的常量。➢ 被其他类实现。

一个类可以实现一个或多个接口，继承使用extends关键字，实现则使用implements关键字。因为一个类可以实现多个接口，这也是Java为单继承灵活性不足所做的补充。

类实现接口的语法格式如下：![cb2c944d3f21f94e9a27400d4aec1e55.png][]

接口与抽象类异同点：

接口和抽象类很像，它们都具有如下特征(同)：

➢ 接口和抽象类都不能被实例化，它们都位于继承树的顶端，用于被其他类实现和继承。

➢ 接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。

接口和抽象类在用法上也存在如下差别：

➢ 接口里只能包含抽象方法、静态方法、默认方法和私有方法，不能为普通方法提供方法实现；抽象类则可以包含普通方法。

➢ 接口里只能定义静态常量，不能定义普通成员变量；抽象类里则既可以定义普通成员变量，也可以定义静态常量。

➢ 接口里不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。

➢ 接口里不能包含初始化块；但抽象类则完全可以包含初始化块。

➢ 一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口。

➢ 接口是一种规范，抽象类是模板模式。

===========================================================================

=============================================================================

![8f29f3b0ff1ac2a472c8926dc1a6a45f.png][]

![054680fa788c990131d854c1676498d2.png][]

![a98129f199d076fb5d3d3756a03f65af.png][]

![94901dfdbfc2655724f57a3988205f29.png][]

![430ceec011a3e9422bed6a9d1f529a10.png][]

![a9759557d412619d9ab225ef8a2884dd.png][]

![76ab5831744b25baee14d4183c0d5541.png][]

![baee6e0435b1dc2f9e9b9c13ede995cf.png][]

![3f978053db0205d932a92f4e57322f58.png][]

![731f768b84bf8378f9c3d161dc9a527b.png][]

![0f0a7c630c086685465a1ea24aea13a7.png][]

[Java 8]: https://www.runoob.com/java/java8-default-methods.html
[Java 9]: https://www.runoob.com/java/java9-private-interface-methods.html
[c64d452fb4b8ebb044ecddc32dceffd1.png]: https://img-blog.csdnimg.cn/img_convert/c64d452fb4b8ebb044ecddc32dceffd1.png
[26cc787d9aa8c0096d8c3f9c92814f48.png]: https://img-blog.csdnimg.cn/img_convert/26cc787d9aa8c0096d8c3f9c92814f48.png
[6791c2c845ab8e8726f817e0f9ec47dc.png]: https://img-blog.csdnimg.cn/img_convert/6791c2c845ab8e8726f817e0f9ec47dc.png
[a4b7b9807e9feb193a8427ba538ab5d9.png]: https://img-blog.csdnimg.cn/img_convert/a4b7b9807e9feb193a8427ba538ab5d9.png
[db11185480ac51d84ef1e6260531c3ba.png]: https://img-blog.csdnimg.cn/img_convert/db11185480ac51d84ef1e6260531c3ba.png
[a87b7d863ba9f58f1f32211155fd0488.png]: https://img-blog.csdnimg.cn/img_convert/a87b7d863ba9f58f1f32211155fd0488.png
[f1590958639b221c46188e67257eb73f.png]: https://img-blog.csdnimg.cn/img_convert/f1590958639b221c46188e67257eb73f.png
[0035fa1534757697eb710ba9056e7034.png]: https://img-blog.csdnimg.cn/img_convert/0035fa1534757697eb710ba9056e7034.png
[5aa5bde03fefbb51c2da66c50b5112fc.png]: https://img-blog.csdnimg.cn/img_convert/5aa5bde03fefbb51c2da66c50b5112fc.png
[84bf6d495efc5bedae81d0130f62582a.png]: https://img-blog.csdnimg.cn/img_convert/84bf6d495efc5bedae81d0130f62582a.png
[97edb8b83d82a1cf1c5bd7724d552dd0.png]: https://img-blog.csdnimg.cn/img_convert/97edb8b83d82a1cf1c5bd7724d552dd0.png
[cb2c944d3f21f94e9a27400d4aec1e55.png]: https://img-blog.csdnimg.cn/img_convert/cb2c944d3f21f94e9a27400d4aec1e55.png
[8f29f3b0ff1ac2a472c8926dc1a6a45f.png]: https://img-blog.csdnimg.cn/img_convert/8f29f3b0ff1ac2a472c8926dc1a6a45f.png
[054680fa788c990131d854c1676498d2.png]: https://img-blog.csdnimg.cn/img_convert/054680fa788c990131d854c1676498d2.png
[a98129f199d076fb5d3d3756a03f65af.png]: https://img-blog.csdnimg.cn/img_convert/a98129f199d076fb5d3d3756a03f65af.png
[94901dfdbfc2655724f57a3988205f29.png]: https://img-blog.csdnimg.cn/img_convert/94901dfdbfc2655724f57a3988205f29.png
[430ceec011a3e9422bed6a9d1f529a10.png]: https://img-blog.csdnimg.cn/img_convert/430ceec011a3e9422bed6a9d1f529a10.png
[a9759557d412619d9ab225ef8a2884dd.png]: https://img-blog.csdnimg.cn/img_convert/a9759557d412619d9ab225ef8a2884dd.png
[76ab5831744b25baee14d4183c0d5541.png]: https://img-blog.csdnimg.cn/img_convert/76ab5831744b25baee14d4183c0d5541.png
[baee6e0435b1dc2f9e9b9c13ede995cf.png]: https://img-blog.csdnimg.cn/img_convert/baee6e0435b1dc2f9e9b9c13ede995cf.png
[3f978053db0205d932a92f4e57322f58.png]: https://img-blog.csdnimg.cn/img_convert/3f978053db0205d932a92f4e57322f58.png
[731f768b84bf8378f9c3d161dc9a527b.png]: https://img-blog.csdnimg.cn/img_convert/731f768b84bf8378f9c3d161dc9a527b.png
[0f0a7c630c086685465a1ea24aea13a7.png]: https://img-blog.csdnimg.cn/img_convert/0f0a7c630c086685465a1ea24aea13a7.png