【java基础】接口(interface)

水深无声 2023-09-24 21:18 132阅读 0赞

### 文章目录 ###

*  基础介绍
 *  接口的定义
 *  关于接口字段和方法的说明
 *  使用接口
 *  抽象类和接口
 *  接口方法冲突的一些说明
 *   *  方法相同名称和参数，返回值相同
     *  方法名称相同，参数不同，返回值相同
     *  方法返回值不同，名称参数相同
     *  方法完全相同，一个有默认实现
     *  接口和类中方法冲突
 *  总结

# 基础介绍 #

接口用来描述类应该做什么，而不是指定它们具体应该怎么做。  
在java中，接口不是类，而是对希望符合这个接口的类的一组需求。java只能继承一个类，但是可以实现多个接口。

# 接口的定义 #

接口的定义如下

interface sports {
        
    
    }

接口定义其实就是和类定义相似的。只不过把class换成了interface

我们在interface可以定义方法，就像抽象类那样定义未实现的方法即可。类实现接口时就必须重写方法或者自己成为抽象类

interface Sports {
        
    
        void run();
    }

在接口里面可以定义方法的默认实现，使用default关键字，如果类实现接口时没有重写该方法，那么该方法就会使用默认实现

interface Sports {
        
    
        void run();
        
        default void jump(){
        
            
        }
    }

现在，我们可以暂时将接口看做为没有实例字段的抽象类。

# 关于接口字段和方法的说明 #

在接口中，我们不能定义实例字段，但是可以定义静态字段。

interface A {
        
        public static final int a = 1;
    }

但是上面这样写IDEA会有提示

![在这里插入图片描述][90e192f228bd4758b3beaf8b06558a5f.png]

表示字段冗余，其实，在接口中我们定义的字段只能使用**public static final**进行修饰

我们在接口中可以定义静态方法

interface A {
        
        public static void t() {
        
    
        }
    }

对于接口里面的内容，其实我们public修饰符可以不用写，因为接口里面字段和方法的访问修饰符**只能是public**。

# 使用接口 #

我们先定义一个接口，内容如下

interface Sports {
        
        void run();
    }

我们创建一个类来实现接口

class Cat implements Sports {
        
    
        @Override
        public void run() {
        
            System.out.println("cat--run");
        }
    }

这个其实和继承基本类似的，只是将关键字从extends换成了implements

关于接口，我们不能够使用new来实例化一个接口

Sports sports = new Sports(); // ERROR

但是可以声明接口变量，然后引用实现了这个接口的类对象即可

Sports cat = new Cat(); // OK

对于接口，我们将其看作实现接口类的父类就很好理解了

# 抽象类和接口 #

对于一个类，我们只能继承一个类，但是可以实现多个接口。我们就可以将接口看做没有实例字段，并且可以被多继承的抽象类

interface A {
        
    
    }
    
    interface B {
        
    
    }
    
    class C implements A, B {
        
        
    }

# 接口方法冲突的一些说明 #

## 方法相同名称和参数，返回值相同 ##

我们知道，一个类可以实现多个接口，如果接口有相同的方法名称和参数会怎么样呢？如果有相同的名称和参数，并且返回值相同，那么我们只需要实现一个t方法即可

interface A {
        
        void t1();
    }
    
    interface B {
        
        void t1();
    }
    
    class C implements A, B {
        
    
        @Override
        public void t1() {
        
    
        }
    }

## 方法名称相同，参数不同，返回值相同 ##

如果方法只有参数不同，那么我们需要实现2个方法，也就是会进行重载

interface A {
        
        void t1();
    }
    
    interface B {
        
        void t1(int a);
    }
    
    class C implements A, B {
        
        @Override
        public void t1() {
        
        }
    
        @Override
        public void t1(int a) {
        
        }
    }

## 方法返回值不同，名称参数相同 ##

如果方法名称相同，参数相同，而返回值不同，那么就会报错，我们无法同时实现2个名称相同，参数也相同但是返回值不同的方法。

interface A {
        
        int t1();
    }
    
    interface B {
        
        void t1();
    }

一个类无法同时实现A接口和B接口

## 方法完全相同，一个有默认实现 ##

如果2个接口一个有默认实现，一个没有默认实现，对于这种情况，我们也必须实现该方法

interface A {
        
        default void t1() {
        
        }
    }
    
    interface B {
        
        void t1();
    }
    
    class C implements A, B {
        
    
        @Override
        public void t1() {
        
            A.super.t1();
        }
    }

但是我们可以通过 **接口名.super.方法名调用默认实现的方法**

## 接口和类中方法冲突 ##

对于接口和类冲突的，都以类为准，也就是**类优先原则**，不管接口是否有默认实现都会被超类中的方法覆盖

interface A {
        
        default void t1() {
        
            System.out.println("interface");
        }
    }
    
    interface B {
        
        void t1();
    }
    
    class C {
        
        public void t1() {
        
            System.out.println("class");
        }
    }
    
    class D extends C implements A, B {
        
    
    }

我们使用D来调用t1方法将会输出class

D d = new D();
            d.t1();  // 输出class

# 总结 #

对于接口，我们将其看作可以被多继承的，并且不能有实例字段的抽象类就行了。对于接口和接口发生冲突时，只要返回类型相同我们就可以处理，如果返回类型不同那就不能同时实现有冲突的接口了。如果接口和超类发生冲突，那么就是以类优先原则来进行解决的。

[90e192f228bd4758b3beaf8b06558a5f.png]: https://img-blog.csdnimg.cn/90e192f228bd4758b3beaf8b06558a5f.png