java——接口

目录

一:接口

(1)理解

(2)定义格式:

(3)注意事项

二:接口的实现:

2.1 接口的一般使用

2.2 接口的默认方法

2.3 接口的静态方法

2.4 接口的私有化方法 

        2.4.1普通私有方法:

        2.4.2 静态私有方法:

 2.5 接口的常量定义

一:接口

(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);//访问变量
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值