自学Java之day10_java接口

接口概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。引用数据类型：数组，类，接口。接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。 接口就是多个类的公共的规范标准。

接口的定义

定义接口的格式：

public interface 接口名称 {

// 抽象方法

// 默认方法

// 静态方法

// 私有方法

}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。

如果是（JDK 7及以前），那么接口中可以包含的内容有：

常量
抽象方法

定义抽象方法

格式：

public abstract 返回值类型方法名称(参数列表);

例如：

package demo01;

public interface DemoInterface01 {
    //定义抽象方法
    public abstract void method1();
    //定义抽象方法
    abstract void method2();
    //定义抽象方法
    void method3();
    //定义抽象方法
    public void method4();
}

注意事项：

接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
这两个关键字修饰符，可以选择性地省略。
方法的三要素，可以根据业务需要随意定义

定义常量

接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。从效果上看，这其实就是接口的【常量】。

格式：

public static final 数据类型常量名称 = 数据值;

例如：

public interface MyInterfaceConst {

    // 这其实就是一个常量，一旦赋值，不可以修改
    public static final int NUM_OF_MY_CLASS = 12;

}

注意事项：

接口当中的常量，可以省略public static final，注意：不写也照样是这样。
接口当中的常量，必须进行赋值；不能不赋值。
接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）任何

接口的实现

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。非抽象子类实现接口：必须重写接口中所有抽象方法，如果继承了接口的默认方法，即可以直接调用，也可以重写。

接口使用步骤：

1：接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：
public class 实现类名称 implements 接口名称 {
// ...
}
2：接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
3：创建实现类的对象，进行使用。

注意事项：

如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

代码举例：

定义接口MyInterface01

package myDemo01;

public interface MyInterface01 {
    //定义接口常量
    public static final int value = 18;
    //定义接口抽象方法
    public abstract void print();

}

定义接口实现类MyInterface01Imp

package myDemo01;

//1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口。
public class MyInterface01Imp implements MyInterface01 {
//2：接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
    @Override
    public void print() {
        System.out.println("我接口中的常量值是"+value);
    }
}

定义测试类Interface01Test

package myDemo01;

public class Interface01Test {
    public static void main(String[] args) {
        //3： 创建实现类的对象，进行使用。
        MyInterface01Imp imp = new MyInterface01Imp();
        //使用实现类中的默认方法
        imp.print();
        //访问接口中的常量
        System.out.println(MyInterface01.value);
    }
}

代码执行后的结果

从Java 8开始，接口里还可以定义默认方法。

格式：
public default 返回值类型方法名称(参数列表) {
方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题。

默认方法如何使用：

默认方法可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

代码举例

定义接口MyInterface02

package myDemo01;

public interface MyInterface02 {

    //定义默认方法
    public default void defaultMethod() {
        System.out.println("我是老接口");
    }
}

定义实现类MyInterface02ImpA继承接口中的默认方法

package myDemo01;

//定义实现类，实现接口
public class MyInterface02ImpA implements MyInterface02 {
//默认方法可以继承
}

定义实现类MyInterface02ImpB重写接口中的默认方法

package myDemo01;

public class MyInterface02ImpB implements MyInterface02 {
    // 重写默认方法

    @Override
    public void defaultMethod() {
        System.out.println("接口升级了");
    }
}

定义测试类Interface02Test

package myDemo01;

public class Interface02Test {
    public static void main(String[] args) {
        //创建实现类对象
        MyInterface02ImpA impA = new MyInterface02ImpA();
        // 调用默认方法，实际运行的是接口中继承下来的方法
        impA.defaultMethod();
        // 创建了实现类对象
        MyInterface02ImpB impB = new MyInterface02ImpB();
        // 调用，默认方法，实际运行的是右侧实现类(重写之后的方法)。
        impB.defaultMethod();
    }
}

代码执行后的结果

从Java 8开始，接口当中还允许定义静态方法。

格式：
public static 返回值类型方法名称(参数列表) {
方法体
}

注意：静态方法也是有方法体

静态方法的使用：

静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用
格式：接口名称.静态方法名(参数);
静态方法无法重写

代码举例

定义接口MyInterface03

package myDemo01;

public interface MyInterface03 {
    public static void method() {
        System.out.println("我是接口中的静态方法");
    }
}

定义接口实现类MyInterface03Imp

package myDemo01;

public class MyInterface03Imp implements MyInterface03 {
    // 无法重写静态方法
}

定义测试类Interface03Test

package myDemo01;

public class Interface03Test {
    public static void main(String[] args) {
        // 创建了实现类对象
        MyInterface03Imp imp = new MyInterface03Imp();

        // 错误写法！实现类调用静态方法  imp.method;

        // 直接通过接口名称调用静态方法
        MyInterface03.method();

    }
}

代码执行后结果

从Java 9开始，接口当中还允许定义私有方法

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。

1. 普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型方法名称(参数列表) {
方法体
}

2. 静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型方法名称(参数列表) {
方法体
}

私有方法的使用

私有方法：只有在接口当中的默认方法里调用。
私有静态方法：只有在接口当中的默认方法和静态方法里调用。

代码举例

定义接口MyInterface04

package myDemo01;

public interface MyInterface04 {
    //定义默认方法
    public default void methodDefault1() {
        //私有方法只有接口中的默认方法可以调用。
        methodPrivate();
        //私有静态方法：接口中的默认方法可以调用
        methodStaticPrivate();
    }

    public default void methodDefault2() {
        methodPrivate();
        methodStaticPrivate();

    }

    //定义私有方法
    private void methodPrivate() {
        System.out.println("我是私有方法，我抽取了默认方法中的重复代码");
    }

    //定义静态方法
    public static void methodStatic1() {
        //私有静态方法：接口中的静态方法也可以调用
        methodStaticPrivate();
    }

    public static void methodStatic2() {
        methodStaticPrivate();
    }

    //定义私有静态方法
    private static void methodStaticPrivate() {
        System.out.println("我是私有静态方法，我抽取了静态方法中的重复代码");

    }
}

定义接口实现类MyInterface04Imp

package myDemo01;

public class MyInterface04Imp implements MyInterface04 {
}

定义接口的测试类Interface04Tes

package myDemo01;

public class Interface04Test {
    public static void main(String[] args) {
        //创建接口实现类对象
        MyInterface04Imp imp = new MyInterface04Imp();
        //调用默认方法
        imp.methodDefault1();
        System.out.println("===========");
        imp.methodDefault2();
        System.out.println("===========");
        //调用接口中静态方法
        MyInterface04.methodStatic1();
        System.out.println("===========");
        MyInterface04.methodStatic2();
    }
}

代码执行后的结果

使用接口的时候，需要注意：

1：接口是没有静态代码块或者构造方法的。因为没有构造方法，不能创建对象。
2：一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
// 覆盖重写所有抽象方法
}
3：如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4：如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5：如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6：一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

自学Java之day10_java接口

接口概述

接口的定义

如果是（JDK 7及以前），那么接口中可以包含的内容有：

接口的实现

接口使用步骤：

从Java 8开始，接口里还可以定义默认方法。

从Java 8开始，接口当中还允许定义静态方法。

从Java 9开始，接口当中还允许定义私有方法

使用接口的时候，需要注意：

day49_Cookie丶Session

day50_JSP

day52_EL丶JSTL

day47_HTTP請求消息丶Request對象

day45_XML

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結