0
0

java 接口 详解

一、概述

1.介绍 :

  1.     **接口技术用于描述类具有什么功能，但并不给出具体实现，当某个类要使用接口时，再去实现接口中的这些方法。类需要遵从接口中描述的统一规则进行定义，所以，接口是对外提供的一组规则，标准。**

2.定义 :

  1.     ①**定义接口**要用到**关键字interface**，格式如下 : 
  3.             **interface **接口名 {
  5.             } 
  7.     ②类和接口之间不再是继承，而是**实现关系**，用**implements关键字**表示。如下 : 
  9.             **class **类名 **implements **接口名 {
  11.             }
  13.     Δ需要注意的是：**与类的定义类似，接口的访问权限修饰符只能是public或者默认**。 
  15.     **IDEA中定义接口的步骤如下 : **
  17.     1>先像平时创建类一样正常点击New——>Java Class；如下图所示 : 

  1.      2>然后在弹出的窗口中选择Interface，输入接口名，回车即可。如下图所示 :

二、特点

1.接口成员变量的特点 :

  1.     Δ**接口中没有成员变量，只有公有静态常量。**
  3.     即**默认情况**下属性前都会有public static final 这三个关键字修饰。如下 : 
  5.     **public static final ****数据类型****常量名** = **常量值**;
  7.     Δ还记得我们在final关键字详解中讲到的——关于final修饰属性的初始化问题吗？
  9.     当时，我们说，final修饰的属性必须进行初始化，而对于公有静态常量，初始化的途径只有两条——①定义时②静态代码块中。但是很遗憾，接口中不允许存在代码块，而且接口没有构造方法。因此，这就要求我们**在接口中定义公有静态常量时，必须在定义时就赋初值**。否则IDEA报错。
  1.             **演示 : **
  3.             我们以DemoInterface接口为演示接口，在该接口中定义i变量，并定义Test类作为测试类，如下所示 : 

  1.             可以看到，IDEA对于i变量前的三个关键字均作了灰色处理，表明这三个修饰符是默认的，你写不写它都在！在测试类中，我们尝试更改i变量的值，IDEA会马上报错，如下图所示 : 

  1.             而可通过接口名来调用i变量也体现出static关键字的存在。

2.接口成员方法的特点 :

  1.     **①**在JDK**7.0**版本及其之前版本中，接口中仅支持**公有的抽象方法**：
  3.             **public abstract** 返回值类型 方法名();  
  5.     Δ事实上，**接口中的方法默认就是公有抽象方法，因此在接口中定义抽象方法时，可以省略掉abstract关键字**。
  7.     **②**从JDK**8.0**开始，接口中可以由**默认方法**和**静态方法**：
  9.             **默认方法**——**public default **返回值类型 方法名() {
  11.             }
  13.             **静态方法**——**public static **返回值类型 方法名() {
  15.             }
  17.     Δ需要注意的是，想定义**默认方法必须在前面添加default关键字**，因为接口中的方法如果你什么都不写，默认是公有的抽象的方法。默认方法可以有方法体，且不需要实现类去实现，其实就是我们平时见到的普通的成员方法。但是默认方法是可以被实现类重写的。**default关键字只能在接口中使用**。就算实现类要重写默认方法，实现类中重写后的方法也不能添加default修饰符，不然IDEA报错。
  19.     **③**JDK**9.0**以后，接口中可以有**私有方法 **:
  21.             **private **返回值类型 方法名() {
  23.             }
  1.             **演示 : **
  3.             我们以Demo2接口为演示接口，以Imple类作为Demo2接口的实现类，最后以Test2类作为测试类，代码如下 : 
  1. package knowledge.port.characters.methods;
  3. public interface Demo2 {
  4.     //①在JDK7.0版本之前，接口中仅支持公有的抽象方法：
  5.     public abstract void hello_world();
  7.     //②从JDK8.0开始，接口中可以由默认方法和静态方法：
  8.         //默认方法
  9.         public default void what_time() {
  10.             System.out.println("姥姥——姥姥——几点啦？");
  11.         }
  12.         //静态方法
  13.         public static double Sum(double x, double y) {
  14.             return x + y;
  15.         }
  17.     //③JDK9.0以后，接口中可以有私有方法 ：
  18.     private void own() {
  19.         System.out.println("这是👴的私有方法。");
  20.     }
  21.     public default void invoke_own() {
  22.         this.own();
  23.     }
  24. }
  26. class Imple implements Demo2{
  27.     @Override
  28.     public void hello_world() {
  29.         System.out.println("你好，世界！");
  30.     }
  31. }
  33. class Test2 {
  34.     public static void main(String[] args) {
  35.         Demo2 d2 = new Imple();
  36.         d2.hello_world();
  37.         System.out.println("---------------------------------");
  38.         d2.what_time();
  39.         System.out.println("传入的x与y的和 = " + Demo2.Sum(141, 135));
  40.         System.out.println("---------------------------------");
  41.         d2.invoke_own();
  42.     }
  43. }
  1.             **运行结果** : 

  1.             注意看我们在Demo2接口中定义的第一个抽象的方法， 在IDEA中，它是下面这样子的 : 

  1.             public 和 abstract修饰符均为灰色，再一次说明接口中的方法默认情况为公有的抽象方法。如果想使用默认方法，一定不要忘记添加default关键字。

3.接口构造方法的特点 :

  1.     接口存在的目的是为了规范类，因此接口也不可以被实例化。接口中不允许存在代码块，也没有需要初始化的成员，因此**接口没有构造方法（构造器）**。在接口中定义构造器IDEA会直接报错，如下图所示：

4.接口创建对象的特点 :

  1.     **①接口不能被实例化 :**
  3.             只能通过多态的方式实例化“子类”对象（这里的**“子类”指的是接口的实现类**）
  5.     **②接口的子类（实现类) : **
  7.             **可以是抽象类，也可以是普通类**。
  8.              **对于抽象实现类**，可以不用实现接口的所有方法，因为抽象类本身容许存在抽象方法，语法上是通过的。
  10.             **对于普通实现类**，要求实现接口的所有方法。
  1.             **演示 : **
  3.             我们以Demo3接口为演示接口，在接口中定义三个抽象方法greet(), exercise(), study()；以Imple1类和Imple2类作为Demo2接口的实现类，令Imple1类为抽象类，不实现Demo3接口中的抽象方法；令Imple2类为非抽象类，实现Demo3接口中的所有抽象方法。最后以Test3类作为测试类，**代码如下** : 
  1. package knowledge.port.object;
  3. public interface Demo3 {
  4.     public abstract void greet();
  5.     public abstract void exercise();
  6.     void study();   //默认隐含public abstract修饰符
  7. }
  9. abstract class Imple1 implements Demo3 {
  10.     //实现类Imple1类是抽象类，允许拥有抽象方法，因此可以不实现接口中的方法。
  11. }
  12. class Imple2 implements Demo3 {
  14.     @Override
  15.     public void greet() {
  16.         System.out.println("嗨，你好！");
  17.     }
  19.     @Override
  20.     public void exercise() {
  21.         System.out.println("文明其精神，野蛮其体魄！");
  22.     }
  24.     @Override
  25.     public void study() {
  26.         System.out.println("好好学习，天天向上！");
  27.     }
  28. }
  30. class Test3 {
  31.     public static void main(String[] args) {
  32.         Demo3 d3 = new Imple2();
  33.         d3.greet();
  34.         d3.exercise();
  35.         d3.study();
  36.     }
  37. }
  1.             **运行结果** : 

  1.             还记得我们讲过的alt + enter快捷键吗？假如接口中有许多许多许多的抽象方法，如果你要一个一个实现的话麻烦的一批，这时候用我们的快捷键就会方便许多，快捷键演示如下GIF动图：

5.接口继承关系的特点 :

  1.     **①类和接口之间的关系 : **
  3.     类与接口是实现关系，支持“多实现”，即**一个类可实现多个接口**。
  5.     **②接口与接口之间的关系 : **
  7.     接口与接口是继承关系，**java 支持接口的多继承，即一个接口可以同时继承多个接口**，格式如下 : 
  9.     接口 **extends **接口1，接口2，接口3...
  11.     **③继承和实现的区别 ： **
  13.     **继承体现的是“is a”的关系，父类中定义共性内容。**
  15.     **实现体现的是“like a”的关系，父接口中定义扩展内容。**
  17.     PS : 接口的“实现”可以看作是Java中对“单继承机制”的一个补充完善。接口可以在一定程度上实现代码解耦（接口规范性 + 动态绑定）。总的来看，**接口比继承更为灵活**。

三、应用 :

1.情景 :

  1.     实际开发中，为了更好地控制和管理项目，项目经理往往会定义一些接口，具体的实现细节由各位程序🐒实现。🐒儿这时就会根据需求，编写不同的类去实现项目👴给的接口。如下图所示 : 

  1.             这时候可能就会有p小将（**personable小将，指风度翩翩的人**）出来问了，直接让🐒儿们去编写类不久完了吗，为啥还得项目👴亲自动手，这不纯纯脱裤子放屁？
  2.              p小将您先别急，我给大家举个例子吧——
  3.              让三个程序🐒去编写程序，分别建立与Mysql，Oracle，以及DB2数据库的连接，这时，如果项目👴没有定义接口，而是直接让🐒儿编写实现连接的类。三个🐒对于连接的方法可能命名为了三种不同的形式，比方说1号🐒写得connect，2号🐒写得join，3号🐒写得link。如下所示 : 
  1. package knowledge.port.application;
  3. public class ToDataBase {
  4.     public static void main(String[] args) {
  5.         SqlConnect mysql = new SqlConnect();
  6.         mysql.connect();
  8.         OracleConnect oracle = new OracleConnect();
  9.         oracle.join();
  11.         DB2Connect db2 = new DB2Connect();
  12.         db2.link();
  13.     }
  14. }
  15. class SqlConnect {
  16.     public void connect() {
  17.         System.out.println("连接到Mysql数据库。");
  18.     }
  19. }
  20. class OracleConnect {
  21.     public void join() {
  22.         System.out.println("连接到Oracle数据库。");
  23.     }
  24. }
  25. class DB2Connect {
  26.     public void link() {
  27.         System.out.println("连接到DB2数据库。");
  28.     }
  29. }
  1.             **运行结果** : 

  1.             项目经理如果就这b样儿给上级交上去，要给喷烂😁。
  2.              由此，我们看到开发中使用接口的必要性 : 
  1.     1.无法确定每个程序🐒写得类是否规范，是否符合要求，无法预测最终软件的质量和规范。也无法控制软件最终的功能。
  2.      2.接口涉及了统一调用的问题，即接口编程。
  1.             解决方案 : 
  3.             我们可以定义ConnectInterface接口， 并在接口中定义抽象方法connect() ，并让🐒儿们去编写类实现这个接口，然后在调用类中**利用多态参数，使接口作为形参**。
  5.            ** ConnectInterface接口代码如下 : **
  1. package knowledge.port.application;
  3. public interface ConnectInterface {    //接口规定了连接方法必须是connect
  4.     public abstract void connect();
  5. }
  1.              **实现类，调用类代码如下 : **
  1. package knowledge.port.application;
  3. public class ToDataBase {
  4.     public static void main(String[] args) {
  5.         SqlConnect mysql = new SqlConnect();
  6.         ToDataBase.connect(mysql);
  8.         OracleConnect oracle = new OracleConnect();
  9.         ToDataBase.connect(oracle);
  11.         DB2Connect db2 = new DB2Connect();
  12.         ToDataBase.connect(db2);
  13.     }
  14.     public static void connect(ConnectInterface connectInterface) {
  15.         connectInterface.connect();
  16.     }
  17. }
  18. class SqlConnect implements ConnectInterface{
  19.     public void connect() {
  20.         System.out.println("连接到Mysql数据库。");
  21.     }
  22. }
  23. class OracleConnect implements ConnectInterface{
  24.     public void connect() {
  25.         System.out.println("连接到Oracle数据库。");
  26.     }
  27. }
  28. class DB2Connect implements ConnectInterface{
  29.     public void connect() {
  30.         System.out.println("连接到DB2数据库。");
  31.     }
  32. }

2.多态 :

  1.             在上文中我们提到，接口不能被实例化，而是通过多态的方法实例化子类对象。意思就是说，**接口引用指向子类对象也是多态的体现**。 实际上，接口的多态要从两方面说起。首先我们来说说接口多态的传递性。

①多态的传递性 :

  1.             **多态的传递性**，指的是——**如果一个类通过implements关键字实现了某个接口，而这个接口此时又继承了另一个接口，那么就相当了这个类同时实现了这两个接口**。而且可以用父接口的引用指向实现类对象。
  2.              我们以FatherInterface为父接口，在父接口中定义一个公有抽象方法f()，SonInterface为子接口，**Achieve类为子接口的实现类**。以Test类为测试类。**代码如下** :    
  1. package knowledge.port.application.deliver;
  3. public interface FatherInterface {
  4.     public abstract void f();
  5. }
  6. interface SonInterface extends FatherInterface {
  7.     //子接口中啥也没有，但是显然继承了父接口中的公有抽象方法。
  8. }
  9. class Achieve implements SonInterface{
  10.     @Override
  11.     public void f() {
  12.         System.out.println("实现类Achieve实现了子接口中————继承自父接口的抽象方法。");
  13.     }
  14. }
  15. class Test {
  16.     public static void main(String[] args) {
  17.         //可以使用子接口引用指向实现类的多态
  18.         SonInterface sonInterface = new Achieve();
  19.         sonInterface.f();
  20.         //也可以使用父接口引用指向实现类的多态
  21.         FatherInterface fatherInterface = new Achieve();
  22.         fatherInterface.f();
  23.     }
  24. }
  1.           **  运行结果 : **

  1.             注意，如果此时实现类中没有实现f() 方法，IDEA会报错，如下图所示 :

子接口中没有定义抽象方法，但是子接口继承了父接口，也就拥有了父接口的非私有方法。因此实现类必须实现父接口的抽象方法，而这相当于实现类也实现了父接口，即实现类同时实现了多个接口。

②关于接口的多态参数和多态数组 :

  1.             其次，对于我们在多态篇讲到的多态的应用——多态参数和多态数组**，接口也同样适用**！喏，上面咱们举的项目经理的例子就是接口多态参数的体现。
  2.              对于接口的多态参数和多态数组，up将其**内容补充在了多态的应用——多态参数和多态数组详解一文中**，方便大家对比记忆和理解。博文链接如下：          https://blog.csdn.net/TYRA9/article/details/128920758https://blog.csdn.net/TYRA9/article/details/128920758

四、总结 :

  1.     🆗，以上就是关于java 接口 详解的全部内容了。我们重点介绍了接口的特点，其中又分为了成员变量，成员方法，构造方法，创建对象，继承关系五部分。这五部分要求大家必须掌握，至此，我们的面向对象三大特性之多态篇正式结束😎！**感谢阅读**！
标签： java 开发语言 jvm
本文转载自: https://blog.csdn.net/TYRA9/article/details/129174384
版权归原作者 Cyan_RA9 所有， 如有侵权，请联系我们删除。
登录后发布评论

“java 接口 详解”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？