Java接口-天翼云

1. 概念

Java 接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现。

在 Java 中，被关键字 interface 修饰的 class 就是一个接口。接口定义了一个行为协议，可以由类层次结构中任何位置的任何类实现。接口中定义了一组抽象方法，都没有具体实现，实现该接口的类（实现类）必须实现该接口中定义的所有抽象方法。

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

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

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类

2. 为什么需要接口

我们知道 Java 仅支持单继承，也就是说一个类只允许有一个直接父类，这样保证了数据的安全。Java 不支持下图所示的多继承：

强哥说Java--Java接口

接口就是为了解决 Java 单继承这个弊端而产生的，虽然一个类只能有一个直接父类，但是它可以实现多个接口，没有继承关系的类也可以实现相同的接口。继承和接口的双重设计既保持了类的数据安全也变相实现了多继承。

2.1 接口与类的区别

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

2.2 接口特性

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jypuAqLN-1629772518841)(E:\Typora\Image\image-20210823103037781.png)]

再IDEA里可以看到这些关键字是灰色的，意思是被隐藏了写不写都行

2.3 抽象类和接口的区别

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

3. 接口的定义和实现

3.1 定义接口

3.1.1 接口声明

使用 interface 关键字声明一个接口：

public interface Personal {
    ...
}

接口声明需要两个元素：interface 关键字和接口名称，public 修饰符表示该接口可以在任何包的任何类中使用，如果为显示指定访问修饰符，则该接口只能被在同包中的类使用。

3.1.2 接口主体

接口主体中，可以定义常量和方法声明：

public interface Personal {
    final String NAME = "我是Personal接口中的常量";
  void walk();
    void run();
}

上面的 Personal 就是一个接口，这个接口定义了一个常量 NAME 和两个抽象方法 walk()、run()。

接口比抽象类更加 “抽象”，它下面不能拥有具体实现的方法，必须全部都是抽象方法，所有的方法默认都是 public abstract 的，所以在接口主体中的方法，这两个修饰符无需显示指定。

接口除了方法声明外，还可以包含常量声明。在接口中定义的所有的常量默认都是 public，static，和 final 的。

接口中的成员声明不允许使用 private 和 protected 修饰符。

3.2 实现接口

接口定义了一些行为协议，而实现接口的类要遵循这些协议。implements 关键字用于实现接口，一个类可以实现一个或多个接口，当要实现多个接口时，implements 关键字后面是该类要实现的以逗号分割的接口名列表。其语法为：

public class Test implements Interface1,Interface2

下面是实现了 Interface1接口的 Test 类的示例代码：

package com.caq.oop.demo11;

//多继承，解决了Java中单继承问题（父类只能有一个子类继承）
public class Test implements Interface1,Interface2 {
    @Override
    public void eat() {
        System.out.println("通过Test类实现Interface1中的eat方法");
    }

    @Override
    public void eat2() {
        System.out.println("通过Test类实现Interface1中的eat2方法");
    }

    @Override
    public void run() {
        System.out.println("通过Test类实现Interface1中的run方法");
    }

    @Override
    public void run2() {
        System.out.println("通过Test类实现Interface1中的run2方法");
    }

    public static void main(String[] args) {
        String name =  Interface1.NAME;
        System.out.println(name);
        Test test = new Test();
        test.eat();
        test.run();
    }
}

我是Interface1中的常量
通过Test类实现Interface1中的eat方法
通过Test类实现Interface1中的run方法

上述代码中，Test 类实现了 Interface1,Interface2 接口。值得注意的是，可以使用接口名.常量名的方式调用接口中所声明的常量：

String name = Test.NAME;

4. 接口继承

接口也是存在继承关系的。接口继承使用 extends 关键字

public interface Interface2 {
    String NAME = "我是Interface2中的常量";

    void eat2();

    void run2();
}

当一个类实现 Interface2 接口，将会实现该接口所继承的所有抽象方法：

public interface Interface1 extends Interface2 {
    String NAME = "我是Interface1中的常量";

    void eat();

    void run();

    @Override
    void eat2();

    @Override
    void run2();
}

值得注意的是，一个接口可以继承多个父接口，接口名放在 extends 后面，以逗号分割，例如：

// Interface1.java
public interface Interface1 {
    void abstractMethod1();
}

// Interface2.java
public interface Interface2 {
    void abstractMethod2();
}

// Interface3.java
public interface Interface3 extends Interface1, Interface2 {
    void abstractMethod3();
}

补充一点，当一个实现类存在 extends 关键字，那么 implements 关键字应该放在其后：

public class MyClass extends SuperClass implements Interface {
   ...
}

5. 默认方法和静态方法

从 JDK 1.8 开始，接口中可以定义默认方法和静态方法。与抽象方法不同，实现类可以不实现默认方法和类方法。

5.1 默认方法

5.1.1 声明

我们可以使用 default 关键字，在接口主题中实现带方法体的方法，例如：

public interface Personal {
    void run();
  
    default void eat() {
        System.out.println("我是默认的吃方法");
    }
}

5.1.2 调用和重写

在实现类中，可以不实现默认方法：

public class Pet implements Personal {    @Override    public void run() {        System.out.println("动物可以跑步");    }}

我们也可以在实现类中重写默认方法，重写不需要 default 关键字：

public class Pet implements Personal {    @Override    public void run() {        System.out.println("动物可以跑步");    }      // 重写默认方法   @Override   public void eat() {       // 使用 接口名.super.方法名() 的方式调用接口中默认方法        Personal.super.eat();       System.out.println("动物吃东西");    }}

如果想要在实现类中调用接口的默认方法，可以使用接口名.super. 方法名 () 的方式调用。这里的 接口名.super 就是接口的引用。

5.1.3 使用场景

当一个方法不需要所有实现类都进行实现，可以在接口中声明该方法为默认方法；使用默认方法还有一个好处，当接口新增方法时，将方法设定为默认方法，只在需要实现该方法的类中重写它，而不需要在所有实现类中实现。

5.2 静态方法

5.2.1 声明

使用 static 关键字在接口中声明静态方法，例如：

public interface Personal {
    void walk();
    // 声明静态方法
    static void sayHello() {
        System.out.println("Hello imooc!");
    }
}

5.2.2 调用

类中的静态方法只

能被子类继承而不能被重写，同样在实现类中，静态方法不能被重写。如果想要调用接口中的静态方法，只需使用 接口名.类方法名 的方式即可调用：

public class Pet implements Personal {
    @Override
    public void walk() {
        // 调用接口中的类方法
        Personal.sayHello();
        System.out.println("动物会走路");
    }
}

6. 接口和抽象类的区别

接口的方法默认是 public ，所有方法在接口中不能有实现（Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法；
接口中除了 static 、final 变量，不能有其他变量，而抽象类可以；
一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过 extends 关键字扩展多个接口；
接口方法默认修饰符是 public ，抽象方法可以有 public 、protected 和 default 这些修饰符（抽象方法就是为了被重写所以不能使用 private 关键字修饰！）；
抽象类主要解决的是子类每次都会重写父类的方法，父类的不需要写方法体，因为每次子类都会重写父类的方法，所以再类前面加上abstract有个提示作用，证明这个方法将要被重写
接口主要解决Java中单继承的缺陷，从设计层面来讲，接口是对行为的抽象，是一种行为规范，抽象类是对类的抽象，是一种模板设计

7. 多个接口中的重名成员解决方法

7.1 多个接口存在重名默认方法

例如有两个接口 MyInteface1.java 和 Interface2.java，存在相同签名的默认方法：

public interface Interface1 {
    default void defaultMethod() {
        System.out.println("我是Interface1接口中的默认方法");
    }
}

public interface Interface2 {
    default void defaultMethod() {
        System.out.println("我是Interface2接口中的默认方法");
    }
}

当实现类实现两个接口时，同名的默认方法将会发生冲突，解决办法是在实现类中重写这个默认方法：

public class MyClass implements Interface1, Interface2 {
    public void defaultMethod() {
        System.out.println("我是重写的默认方法");
    }
}

还有一种情况：实现类所继承的父类中也存在与默认方法的同名方法，此时存在三个同名方法：

// 声明父类，并在父类中也定义同名方法
public class FatherClass {
    public void defaultMethod() {
        System.out.println("我是FatherClass中的defaultMethod()方法");
    }
}

// 实现类继承父类，并实现两个接口
public class MyClass extends FatherClass implements Interface1, Interface2 {
}

实例化 MyClass 类，调用其 defaultMethod() 方法：

MyClass myClass = new MyClass();
myClass.defaultMethod();

此时编译执行，不会报错：

我是SuperClass中的defaultMethod()方法

实际上，在没有重写的情况下，它执行了实现类的父类 FatherClass 的 defaultMethod() 方法。

7.2 多个接口中存在重名常量

例如有两个接口，存在重名的常量：

public interface Interface1 {
    final int NUM = 100;
}

public interface Interface2 {
    final int NUM = 200;
}

此时在实现类中，我们可以使用接口名.常量名的方式分别调用：

public MyClass implements Interface1, Interface2 {
    System.out.println(Interface1.NUM);   
    System.out.println(Interface2.NUM);   
}

当实现类将入一个继承关系时：

class SuperClass {
    static int NUM = 300;
}

public MyClass extends SuperClass implements Interface1, Interface2 {   
    System.out.println(NUM);
}

当父类中的属性或常量与接口中的常量同名时，子类无法分辨同名的 NUM 是哪一个。编译程序将会报错：

MyClass.java:4: 错误: 对NUM的引用不明确
        System.out.println(NUM);
                           ^
  SuperClass 中的变量 NUM 和 Interface1 中的变量 NUM 都匹配
1 个错误

此时只有在子类中声明 NUM，才可以通过编译：

public MyClass extends SuperClass implements Interface1, Interface2 {
    int NUM = 3;
  System.out.println(NUM);
}

8. 小结

通过学习，我们知道了 Java 的接口是为了解决其单继承的弊端而产生的

可以使用 interface 关键字来声明一个接口

接口内部不能有具体的方法实现。

可以使用 implements 关键字来实现接口

一个接口可以继承多个父接口，接口名放在 extends 后面，以逗号分割。

从 Java 8 开始，接口中可以定义默认方法和静态方法。

活动

应用商城

合作伙伴

开发者

支持与服务

了解天翼云

Java接口

Java接口

1. 概念

2. 为什么需要接口

2.1 接口与类的区别

2.2 接口特性

2.3 抽象类和接口的区别

3. 接口的定义和实现

3.1 定义接口

3.1.1 接口声明

3.1.2 接口主体

3.2 实现接口

4. 接口继承

5. 默认方法和静态方法

5.1 默认方法

5.1.1 声明

5.1.2 调用和重写

5.1.3 使用场景

5.2 静态方法

5.2.1 声明

5.2.2 调用

6. 接口和抽象类的区别

7. 多个接口中的重名成员解决方法

7.1 多个接口存在重名默认方法

7.2 多个接口中存在重名常量

8. 小结

相关文章

Java中的方法重写详解

深入探讨Java的反射机制及其应用场景

这么多数组方法，你掌握了么？

深度解析compareToIgnoreCase方法的妙用

【Spring相关技术】spring进阶-自定义请求报文转对象HttpMessageConverter

jquery实现checkbox全选和反选

Java中的动态代理机制：原理与应用

深入理解Java中的Lambda表达式和流处理

基于混合配准策略的多模态医学图像配准方法研究

来看看Python迭代器能让你的代码提升100倍的密码

作者介绍

最新文章

Java中的方法重写详解

深入探讨Java的反射机制及其应用场景

这么多数组方法，你掌握了么？

【Spring相关技术】spring进阶-自定义请求报文转对象HttpMessageConverter

Java中的动态代理机制：原理与应用

深入理解Java中的Lambda表达式和流处理

热门文章

JAVA__接口的作用

什么是api接口

kotlin匿名内部类与接口实现

Go 语言入门很简单 -- 13. Go 接口 #私藏项目实操分享#

SpringBoot写的后端API接口如何写得更优雅

ts重点学习47-接口与类型别名得异同笔记

热门标签

相关产品

弹性云主机

天翼云电脑（公众版）

对象存储

云硬盘

随机文章

编程中大量if-elseif替换解决办法

二十三种设计模式-----归纳篇(JAVA)

TypeScript-函数接口和混合类型接口

【java基础】一篇文章彻底搞懂lambda表达式

java之Thread类实战模板（全）

HCIE_交换篇_MAC地址漂移