java——接口

就是蠢啊

已于 2024-05-10 20:22:37 修改

阅读量1.1k

点赞数 26

分类专栏： Java语法知识文章标签： java 开发语言

于 2024-05-10 20:21:59 首次发布

本文链接：https://blog.csdn.net/m0_74012211/article/details/138615787

版权

Java语法知识专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一：接口

（1）理解

在实际生活中，接口非常常见。比如在使用电脑，手机或者其他家电，给他们插电时，插头都能插到插/座孔中，这些插孔/座都能称之为接口。可是，这些家电在生产之前制造商并没有沟通插头与插座的型号问题，但是用的时候却都可以用（国内的家电在国内可以正常使用）。

由此可见，接口是一种公共的规范。

在Java中，也是这样：接口就是多个类的公共规范；

（2）定义格式：

        public interface 接口名（）{

接口内容；

        }

接口是引用数据类型，最重要的是其中的 抽象方法 ；

当然，对于不同的JDK版本，其可容纳的内容一般不同，这里不做解释了。

（3）注意事项

1.抽象类的修饰符必须是 public abstract ;

2.这两个关键字可以省略不写，也可以省略其中一个；

二：接口的实现：

2.1 接口的一般使用

（1）接口类不能直接创建接口对象进行访问,必须有一个 “实现类” 来 “实现” （类比于抽象类必须有一个继承对象来间接访问）；

(2) 接口的实现类必须覆盖重写接口所有的抽象方法（覆盖重写与抽象类中子类的覆盖重写原则相同，即去掉 abstract , 鼠标放在报错代码处，Alt+Enter,选择实现方法即可自动实现）；

（3）如果实现类没有覆盖重写接口的所有抽象方法，那么它必须是抽象类；

下面是一个普通接口的案例：

接口有两个抽象方法，实现类实现接口，并覆盖重写所有抽象方法，测试类中创建实现类对象，来访问实现类的抽象方法；

package Interface01;

public interface MyInterface {
    //接口中主要是 抽象方法
    //public abstract可以省略不写
    public void eat();
    void sleep();    
}

package Interface01;

public class MyInterfaceImplement implements MyInterface {

    @Override
    public void eat() { //重写接口方法 eat
        System.out.println("好好吃饭饭");
    }

    @Override
    public void sleep() { //重写接口方法 sleep
        System.out.println("睡觉觉也是很好的事情");
    }
}

package Interface01;

public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterfaceImplement m=new MyInterfaceImplement();
        m.sleep();
        m.eat();
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=10335:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo Interface01.MyInterfaceDemo
睡觉觉也是很好的事情
好好吃饭饭

进程已结束,退出代码0

2.2 接口的默认方法

背景：如果一个接口有很多实现类，我们又需要在接口中添加一个方法，这样的话我们必须在许多实现类中覆盖重写新添加的方法，这会非常麻烦。那么我们可不可以在不改变许多实现类的情况下，仍然能访问新添加的方法呢？

默认方法可以解决这个问题：

定义格式：public default void 方法名（）{

方法体

}

案例演示：

有一个接口为 MyInterface ,有两个实现类 MyInterfaceImplement , MyInterfaceImplement02 ，还有一个测试类 MyInterfaceDemo;

其中，MyInterfaceImplement 实现类直接访问接口新增的默认方法，MyInterfaceImplement02 实现类覆盖重写了接口新增的默认方法；

代码如下：

package Interface01;

public interface MyInterface {
    //接口中主要是 抽象方法
    //public abstract可以省略不写
    public void eat();
    void sleep();

    public default void drunk() {//接口的默认方法
        System.out.println("这是接口的默认方法");
    }
}

package Interface01;

public class MyInterfaceImplement implements MyInterface {

    @Override
    public void eat() { //重写接口方法 eat
        System.out.println("好好吃饭饭");
    }

    @Override
    public void sleep() { //重写接口方法 sleep
        System.out.println("睡觉觉也是很好的事情");
    }

}

package Interface01;

public class MyInterfaceImplement02 implements MyInterface{

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }
}

package Interface01;

public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterfaceImplement m=new MyInterfaceImplement();
        m.sleep();
        m.eat();
        m.drunk();//只接使用接口的默认方法
    }
}

ackage Interface01;
public class MyInterfaceImplement02 implements MyInterface{

    @Override
    public void eat() {
        System.out.println("吃吃吃，就会吃啊");
    }

    @Override
    public void sleep() {
        System.out.println("睡觉呼呼的睡啊");
    }
    @Override
    public  void drunk() {//接口的默认方法
        System.out.println("接口的默认方法也可以覆盖重写哦");
    }
}

package Interface01;

public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterfaceImplement m=new MyInterfaceImplement();
        m.sleep();
        m.eat();
        m.drunk();//只接使用接口的默认方法
        System.out.println("============");

        MyInterfaceImplement02 m2=new MyInterfaceImplement02();
        m2.eat();
        m2.sleep();
        m2.drunk();
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=12499:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo Interface01.MyInterfaceDemo
睡觉觉也是很好的事情
好好吃饭饭
这是接口的默认方法
============
吃吃吃，就会吃啊
睡觉呼呼的睡啊
接口的默认方法也可以覆盖重写哦

进程已结束,退出代码0

2.3 接口的静态方法

有一些内容与类的对象无关，可以供类共享，这种内容就可以用 static 来定义；

格式：public static void 方法名（）{

方法体

}；

访问的时候，通过接口名直接调用，与方法的对象是否创建无关；

我在前面的基础上的接口中，增添了一个静态方法，在测试类中使用接口名就可以直接调用；

package Interface01;

public interface MyInterface {
    //接口中主要是 抽象方法
    //public abstract可以省略不写
    void eat();
    void sleep();

    public default void drunk() {//接口的默认方法
        System.out.println("这是接口的默认方法");
    }

    public static void love(){
        System.out.println("爱出者爱返，福往者福来");
    };
}

package Interface01;

public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterfaceImplement m=new MyInterfaceImplement();
        m.sleep();
        m.eat();
        m.drunk();//只接使用接口的默认方法
        System.out.println("============");

        MyInterfaceImplement02 m2=new MyInterfaceImplement02();
        m2.eat();
        m2.sleep();
        m2.drunk();
        System.out.println("========");
        MyInterface.love();//静态方法，接口名直接调用，不需要实现类对象调用
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=8357:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo Interface01.MyInterfaceDemo
睡觉觉也是很好的事情
好好吃饭饭
这是接口的默认方法
============
吃吃吃，就会吃啊
睡觉呼呼的睡啊
接口的默认方法也可以覆盖重写哦
========
爱出者爱返，福往者福来

进程已结束,退出代码0

2.4 接口的私有化方法

2.4.1普通私有方法：

其目的是降低接口中多个默认方法代码的冗余性，专门为默认方法服务，又防止其被接口实现类的对象调用造成不当使用，从而进行私有化定义；

格式：private void 方法名：（参数列表）{ } ；

举例演示：

我们创建了一个接口，里面有两个默认方法和一个默认方法的私有化定义；创建了一个实现类来实现它，还创建了一个测试类进行测试；

package Interface01;
public interface MyInterface {
    public default void drunk() {//接口的默认方法
        System.out.println("这是接口的默认方法");
        DefaultCommon();    //调用默认方法的私有化方法

    }
    public default void love(){//接口的默认方法
        System.out.println("爱出者爱返，福往者福来");
        DefaultCommon();    //调用默认方法的私有化方法
    }
    private void DefaultCommon(){//默认方法的私有化
        System.out.println("aaaaaa");
        System.out.println("aaaaaa");
        System.out.println("aaaaaa");
    }
}

package Interface01;
public class MyInterfaceDemo {
    public static void main(String[] args) {
       MyInterfaceImplement02 m=new MyInterfaceImplement02();
       m.love();
    }
}

C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=9329:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo Interface01.MyInterfaceDemo
爱出者爱返，福往者福来
aaaaaa
aaaaaa
aaaaaa

进程已结束,退出代码0

2.4.2 静态私有方法：

其目的是降低接口中多个静态方法的代码的冗余性，专门为静态方法服务，又防止其被接口直接调用造成不当使用，从而进行私有化定义；

格式：public static void 方法名：（参数列表）{ } ；

我们创建了一个接口，里面有两个静态方法和一个静态方法的私有化定义；创建了一个测试类进行测试；

package Interface01;
import static Interface01.MyInterface.DefaultCommon;
public interface MyInterface {
    public static void drunk() {//接口的默认方法
        System.out.println("这是接口的默认方法");
            DefaultCommon(); //调用默认方法的私有化方法

    }
    public static void love(){//接口的默认方法
        System.out.println("爱出者爱返，福往者福来");
            DefaultCommon(); //调用默认方法的私有化方法
    }
    static void DefaultCommon(){//默认方法的私有化
        System.out.println("aaaaaa");
        System.out.println("aaaaaa");
        System.out.println("aaaaaa");
    }
}

package Interface01;
public class MyInterfaceDemo {
    public static void main(String[] args) {
       MyInterface.love();//接口名直接调用静态方法
    }
}

2.5 接口的常量定义

前面说了，接口中重要的内容是抽象方法，那么可不可定义变量呢？答案是肯定的，只不过所谓的” 变量 “只能是常量。

规则：public static final 数据类型常量名 = 数值；由于 final 的存在，其定义时必须赋值，且一旦赋值后不能改变；

由于是 static 修饰的，所以使用类名直接访问即可；

注意：(1) 变量名尽量全部大写，不同单词间使用下划线隔开，如：

public static static int CLASS_NUMBER = 6 ;

(2) public static final 是默认的，可以写，也可以不写；

案例演示：

我在前面基础上的接口中定义了一个常量，在测试类中通过类名直接访问；

package Interface01;
import static Interface01.MyInterface.DefaultCommon;

public interface MyInterface {
    
    int NUMBER=99;//定义”变量“;
    
    public static void drunk() {//接口的默认方法
        System.out.println("这是接口的默认方法");
            DefaultCommon(); //调用默认方法的私有化方法
    }
    public static void love(){//接口的默认方法
        System.out.println("爱出者爱返，福往者福来");
            DefaultCommon(); //调用默认方法的私有化方法
    }
    static void DefaultCommon(){//默认方法的私有化
        System.out.println("aaaaaa");
        System.out.println("aaaaaa");
        System.out.println("aaaaaa");
    }
}

package Interface01;
public class MyInterfaceDemo {
    public static void main(String[] args) {
       MyInterface.love();//接口名直接调用静态方法
       System.out.println(MyInterface.NUMBER);//访问变量
    }
}