菜鸟话Java---Java接口

发表于 | 分类于

接口概述

接口不是类，而是对类的一组需求描述。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口的声明

1
2
3
4
5
6
//接口的声明语法格式如下：[]括起来的表示可有可无

访问修饰符 interface 接口名称 [extends 其他的接口名名] {
        // 声明变量
        // 抽象方法
}

接口的实现

接口的实现要使用Implements关键字，并且要实现接口中所有定义的方法

接口的特点

  • 不能使用new实例化一个接口
  • 接口变量必须引用实现了接口的变量
  • 接口中不能包含成员变量和静态方法(java 8允许)，但可以包含常量
  • 接口中所有的方法都自动设置为public,所有的域都自动设置为public static final
  • 接口可以多继承

接口和抽象类的区别

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

默认方法

Java 8 新增了接口的默认方法。简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。
我们只需在方法名前面加个 default 关键字即可实现默认方法。

为什么要有这个特性？

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

1
2
3
4
5
6
默认方法语法格式如下：
public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
}

多个默认方法

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

1
2
3
4
5
6
7
8
9
10
11
public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
}
 
public interface FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮车!");
   }
}

第一个解决方案是创建自己的默认方法，来覆盖重写接口的默认方法：

1
2
3
4
5
public class Car implements Vehicle, FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮汽车!");
   }
}

第二种解决方案可以使用 super 来调用指定接口的默认方法：

1
2
3
4
5
public class Car implements Vehicle, FourWheeler {
   public void print(){
      Vehicle.super.print();
   }
}

静态默认方法

Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法。例如：

1
2
3
4
5
6
7
8
9
public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
    // 静态方法
   static void blowHorn(){
      System.out.println("按喇叭!!!");
   }
}

默认方法实例

我们可以通过以下代码来了解关于默认方法的使用，可以将代码放入 Java8Tester.java 文件中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Java8Tester.java 文件
public class Java8Tester {
   public static void main(String args[]){
      Vehicle vehicle = new Car();
      vehicle.print();
   }
}
 
interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }

   static void blowHorn(){
      System.out.println("按喇叭!!!");
   }
}
 
interface FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮车!");
   }
}
 
class Car implements Vehicle, FourWheeler {
   public void print(){
      Vehicle.super.print();
      FourWheeler.super.print();
      Vehicle.blowHorn();
      System.out.println("我是一辆汽车!");
   }
}

类优先

情景1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class People {

    private String name;

    public String getName() {
        System.out.println("people的getName调用");
        return name;
    }
}

public interface Named {
    String getName();
}

public class Test extends People implements Named {//当超类和接口有重名的方法时，不需要子类实现接口方法

}

情景2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class People {

    private String name;

    public String getName() {
        System.out.println("people的getName调用");
        return name;
    }
}


public interface Named {
   default String getName(){
       System.out.println("默认方法的getName调用");
       return "";
   }
}

public class Test extends People implements Named {//当超类和接口的默认方法重名时，忽略接口的默认方法，即类优先

}

 public static void main(String[] args) {
        Test t = new Test();
        t.getName();//输出为：people的getName调用
    }

注意：千万不能让一个默认方法重新定义Object类中的某个方法，例如，toString。由于类优先原则，这样的
方法绝对无法超越Object.toString.