接口的使用

恋º

已于 2023-08-03 14:26:46 修改

阅读量100

点赞数

文章标签： java 开发语言

于 2023-08-03 14:23:14 首次发布

本文链接：https://blog.csdn.net/m0_74910230/article/details/132071278

版权

1.接口的理解

接口本质是契约、标准、规范，就像我们的法律一样。制定好大家需要遵守。

2.定义接口的关键字

interface

3.接口内部的结构说明

1.可以声明

属性：必须使用public static final修饰

方法：jdk8之前：声明抽象方法，修饰为public abstract

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MIN_SPEED);
        System.out.println(Flyable.MAX_SPEED);
    }
}
interface Flyable{
    //全局常量
    public static final int MIN_SPEED = 0;

    int MAX_SPEED = 7900;//可以省略public static final

    void fly();//方法可以省略public abstract 声明
}
interface Attack{
    public abstract void attack();
}

jdk8：声明为静态方法、默认方法

jdk8之后：声明为私有方法

public class InterfaceTest {
    public static void main(String[] args) {
        //知识点1：接口中声明的静态方法只能被接口来调用，不能使用其实现类进行调用
        //SubClass.method1();不能被调用
        CompareA.method1();

        /*知识点2：接口中声明的默认法昂发可以被实现类继承，实现类在没有重写此方法的情况下，默认调用接口声明的
        默认方法，如果实现类重写了此方法，则调用的是自己重写的方法*/
        SubClass s1 = new SubClass();
        s1.method2();

        /*知识点3：类实现了两个接口，面两个接口中自定义了同名同参数的默认方法。则实现类在没有重写此两个接口
        默认方法的情况下，会报错。 -->接口冲突
        要求：此时实现类必须要重写接口中定义的同名同参的方法。*/
        s1.method3();

        /*知识点4：子类（或实现类）继承了父类并实现了接口，父类和接口中声明了同名同参的方法。（其中，接口中的方法
        是默认方法）。默认情况下，子类（或实现类）在没有重写此方法的情况下，调用的是父类中的方法。-->类优先原则
         */
        s1.method4();
        s1.method();
    }
}
interface CompareA{
    //属性：声明为 public static abstract
    //方法：jdk8之前，只能声明抽象方法

    //jdk8中，静态方法
    public static void method1(){
        System.out.println("CompareA:北京");
    }
    //jdk8中，默认方法
    public default void method2(){
        System.out.println("CompareA:上海");
    }
    public default void method3(){
        System.out.println("CompareA:广州");
    }
    public default void method4(){
        System.out.println("CompareA:深圳");
    }
    /*jdk9新特性：定义私有方法
    protected void method5(){
        System.out.println("我是接口中定义的私有方法");
    }*/
}
class SubClass extends SuperClass implements CompareA,CompareB{
    @Override
    public void method2() {
        System.out.println("SubClass:上海");
    }
    public void method3() {
        System.out.println("SubClass:广州");
    }
    public void method4() {
        System.out.println("SubClass:深圳");
    }
    public void method(){
        //知识点5：如何在子类（或实现类）中调用父类或接口中被重写的方法
        method4();//调用自己类中的方法
        super.method4();//调用父类的
        method3();//调用自己类中的方法
        CompareA.super.method3();//调用接口CompareA中的默认方法
        CompareB.super.method3();//调用接口Compare中的默认方法
    }
}
interface CompareB{
    public default void method3(){
        System.out.println("CompareB:广州");
    }
}
class SuperClass{
    public void method4(){
        System.out.println("SuperClass:深圳");
    }
}

2.不可以声明

构造器、代码块等

4.接口与类的关系

实现关系

public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MIN_SPEED);
        System.out.println(Flyable.MAX_SPEED);
        Bullet b1 = new Bullet();
        b1.fly();
        b1.attack();
    }
}
interface Flyable{
    //全局常量
    public static final int MIN_SPEED = 0;

    int MAX_SPEED = 7900;//可以省略public static final

    void fly();//方法可以省略public abstract 声明
}
interface Attack{
    public abstract void attack();
}

abstract class Plane implements Flyable{

}
//或       （快捷键：Alt+Enter)
class Bullet implements Flyable,Attack{

    @Override
    public void fly() {
        System.out.println("让子弹飞飞一会儿");
    }

    @Override
    public void attack() {
        System.out.println("子弹可以击穿身体");
    }
}

5.格式

class A (extends SuperA) implements B,C{ }

·A相较于SuperA来讲，叫做子类

·A相较于B，C来讲，叫做实现类

6.满足此关系后，说明

1.类可以有多个接口。

2.类针对于接口的实现，一定程度上就弥补了类的单继承的局限性。

3.类必须将实现的接口中的所有的抽象方法都进行重写（或实现），方可实例化。否则，此实现类声明必须为抽象类。

7.接口与接口的关系

继承关系，且可以多继承

interface AA{
    void method1();
}
interface BB{
    void method2();
}
interface CC extends AA,BB{//接口可以多继承

}
class DD implements CC{

    @Override
    public void method1() {
        
    }

    @Override
    public void method2() {

    }
}

8.接口的多态性

接口名变量 = new 实现对象类；

public class USBTest {
    public static void main(String[] args) {
        //1.创建接口实现类的对象
        Computer computer = new Computer();
        Printer printer = new Printer();
        computer.transformData(printer);
        /*或
        Computer computer = new Computer();
        computer.transformData(new Printer());
         */
        System.out.println("-------------------");
        //2.创建接口实现类的匿名对象
        computer.transformData(new Camera());
        System.out.println("-------------------");
        //3.创建接口匿名实现类的对象
        USB usb1 = new USB(){
            public void start() {
                System.out.println("U盘开始工作");
            }
            public void stop() {
                System.out.println("U盘停止工作");
            }
        };
        computer.transformData(usb1);
        System.out.println("-------------------");
        //4.创建接口匿名实现类的匿名对象
        computer.transformData(new USB(){

            @Override
            public void start() {
                System.out.println("扫描仪开始工作");
            }

            @Override
            public void stop() {
                System.out.println("扫描仪结束工作");
            }
        });
    }
}
class Computer{
    public void transformData(USB usb){
        System.out.println("设备连接成功");
        usb.start();
        System.out.println("数据传输操作");
        usb.stop();
    }
}
//多态:USB usb = new Printer();
class Printer implements USB {

    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机停止工作");
    }
}
class Camera implements USB{

    @Override
    public void start() {
        System.out.println("照相机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("照相机停止工作");
    }
}
interface USB{
    public abstract void start();
    void stop();
}