Java教程29—Java中的接口

偏执的太偏执、 2022-05-13 12:42 219阅读 0赞

*   *  Java接口
     *  Java中的接口有什么用？
     *  Java中的接口示例
     *  接口和继承
     *  Java中的Tag或Marker接口
     *  嵌套接口
     *  以下是关于接口的关键要点：
     *  java中接口的优点

## Java接口 ##

在过去的教程中，我们讨论了抽象类被用于实现部分抽象。  
与抽象类不同，接口用于完全抽象。  
抽象是一个过程，您只显示“相关”的数据并“隐藏”用户不必要的对象细节。  
在本指南中，我们将介绍java中的接口、使用它的原因以及在Java编程中使用接口时必须遵循的规则。

Java中的接口是什么？  
接口看起来像一个类，但它不是一个类。  
接口可以像类一样拥有方法和变量，但接口中声明的方法默认是抽象的（只有方法名字，没有方法体，请参阅：Java抽象方法）。  
此外，默认情况下，接口中声明的变量是`public，static和final`。我们将在本指南后面详细介绍。

--------------------

## Java中的接口有什么用？ ##

如上所述，它们用于完全抽象。  
由于接口中的方法没有body，因此必须先由类实现它们才能访问它们。  
实现接口的类必须实现该接口的所有方法。  
此外，java编程语言不允许您继承多个类，但是您可以在类中实现多个接口。

语法：  
通过指定关键字“`interface`”声明接口。例如：

interface MyInterface
    {
        /* 所有方法默认都是public abstract
         * 正如下面 没有方法体
         */
        public void method1();
        public void method2();
    }

--------------------

## Java中的接口示例 ##

这是类实现接口的方式。  
它必须提供在接口中声明的所有方法体，或者换句话说，您可以说该类必须实现接口的所有方法。

注意：  
类是实现接口，接口是继承接口。

interface MyInterface
    {
        
        /* 编译器实际上是这么编译它的:
         * public abstract void method1();
         * public abstract void method2();
         */
        public void method1();
        public void method2();
    }
    
    class Demo implements MyInterface
    {
        
        /* 这个类必须实现所有的抽象方法
         * 否则会报编译器错误
         */
        public void method1()
        {
            System.out.println("implementation of method1");
        }
        public void method2()
        {
            System.out.println("implementation of method2");
        }
        public static void main(String arg[])
        {
            MyInterface obj = new Demo();
            obj.method1();
        }
    }
    
    Output:
    
    implementation of method1

--------------------

## 接口和继承 ##

如上所述，接口不能实现另一个接口。  
它必须扩展其他接口。  
请参阅下面的示例，其中我们有两个接口Inf1和Inf2。  
Inf2扩展了Inf1所以如果类实现了Inf2，它必须提供Inf2和Inf1接口的所有方法的实现。

interface Inf1{
        
        public void method1();
    }
    interface Inf2 extends Inf1 {
        
        public void method2();
    }
    public class Demo implements Inf2{
        
        /* 尽管只实现了接口2，但是它必须实现inf1中的所有方法
         * 因为接口 Inf2 继承自 Inf1
         */
        public void method1(){
            System.out.println("method1");
        }
        public void method2(){
            System.out.println("method2");
        }
        public static void main(String args[]){
            Inf2 obj = new Demo();
            obj.method2();
        }
    }

在这个程序中，类Demo只实现接口Inf2，但是它必须提供接口的所有方法的实现Inf1，因为接口Inf2扩展了Inf1。

--------------------

## Java中的Tag或Marker接口 ##

空接口称为标记或标记接口。  
例如，Serializable，EventListener，Remote（java.rmi.Remote）是标记接口。  
这些接口中没有任何字段和方法。

--------------------

## 嵌套接口 ##

在另一个接口或类中声明的接口称为嵌套接口。  
它们也被称为内部接口。  
例如，集合框架中的Entry接口是在Map接口中声明的。  
这就是我们不直接使用它的原因，我们是这样使用它的：Map.Entry。

--------------------

## 以下是关于接口的关键要点： ##

*  1）我们无法在java中实例化接口。这意味着我们无法创建接口的对象。
 *  2）接口提供完全抽象，因为它具体的方法都没有。另一方面，抽象类提供了部分抽象，因为它可以具有抽象和具体（带有body的方法）方法。
 *  3）implements是类用于实现接口的关键字。
 *  4）提供实现接口的方法的任何类，都需要声明为public。
 *  5）实现任何接口的类必须实现该接口的所有方法，否则应该将该类声明为abstract。
 *  6）接口不能声明为private, protected或者transient。
 *  7）默认情况下，所有接口方法都是abstract和public。
 *  8）默认情况下，接口中声明的变量是public，static和final。

interface Try
    {
        int a=10;
        public int a=10;
        public static final int a=10;
        final int a=10;
        static int a=0;
    }

上面的声明语句实际上是一样的效果。

*  9）接口变量必须在声明时初始化，否则编译器将抛出错误。

interface Try
    {
        
        int x;//编译期错误
    }

上面的代码将抛出编译时错误，因为变量x的值在声明时未初始化。

*  10）在任何实现类中，您不能更改在接口中声明的变量，因为默认情况下，它们是public，static和final。  
    这里我们实现了具有变量x的接口“Try”。  
    当我们尝试设置变量x的值时，我们得到了编译错误，因为默认情况下变量x是public static final，并且无法重新初始化最终变量。

class Sample implements Try
    {
        
        public static void main(String args[])
        {
            x=20; //编译期错误
        }
    }

*  11）接口可以继承任何接口但不能实现它。类实现接口，接口继承接口。
 *  12）一个类可以实现任意数量的接口。
 *  13）如果两个接口中有两个或多个相同的方法，并且一个类实现两个接口，则该方法的实现一次就足够了。

interface A
    {
        
        public void aaa();
    }
    interface B
    {
        
        public void aaa();
    }
    class Central implements A,B
    {
        
        public void aaa()
        {
            //任何代码
        }
        public static void main(String args[])
        {
            //语句
        }
    }

*  14）类不能实现两个具有相同名称但返回类型不同的方法的接口。

interface A
    {
        
        public void aaa();
    }
    interface B
    {
        
        public int aaa();
    }
    
    class Central implements A,B
    {
        
    
        public void aaa() // error
        {
        }
        public int aaa() // error
        {
        }
        public static void main(String args[])
        {
    
        }
    }

*  15）变量名冲突时可以通过接口名调用。

interface A
    {
        
        int x=10;
    }
    interface B
    {
        
        int x=100;
    }
    class Hello implements A,B
    {
        
        public static void Main(String args[])
        {
            /* 两个接口都存在x变量
             * 所以我们使用接口名来解决变量问题
             */
            System.out.println(x);
            System.out.println(A.x);
            System.out.println(B.x);
        }
    }

--------------------

## java中接口的优点 ##

使用接口的优点如下：

*  在不关心实现部分的情况下，我们可以做到实现的安全性
 *  在java中，不允许多重继承，但是您可以使用接口来使用它，因为您可以实现多个接口。

--------------------

原文地址：

https://beginnersbook.com/2013/05/java-interface/