接口知识点

文章目录

1.1 接口的概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方（JDK 9）。
接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它不是类，而是另外一种引用数据类型。

1.2 接口的定义格式

public class Demo1 {
    /*
    接口就是多个类的公共规范
    接口是一种引用数据类型，最重要的内容就是其中的抽象方法

    如何定义一个接口？
    public interface 接口名称{
        接口内容
    }

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

    如果是java7：那么接口中可以包含的内容有：
    1.常量
    2.抽象方法
    如果是java8：可以额外包涵有:
    3.默认方法
    4.静态方法
    如果是java9，还可以额外包涵有：
    5.私有方法
     */
}
public interface 接口名称 { 
    // 抽象方法 
    // 默认方法
    // 静态方法 
    // 私有方法 
}

1.2.1含有抽象方法

抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

代码如下：

/*
在任何版本的java中，接口都能定义抽象方法
格式：
public abstract 返回值类型 方法名称（参数列表）；

注意事项：
1. 接口当中的抽象方法，修饰符必须是两个固定的关键字， public abstract
2. 这两个关键字修饰符，可以选择性的省略（初学，不推荐）
3. 方法的三要素，可以随意定义
 */
public interface MyInterfaceAbstract {
    //这是一个抽象方法
    public abstract void methodAbs1();
    //这也是抽象方法
    abstract void methodAbs2();
    //这也是抽象方法
    public void methodAbs3();
    //这也是抽象方法
    void methodAbs4();
}

1.3接口使用步骤

//定义一个类
public class Demo01Interface {
    public static void main(String[] args) {
        //错误写法，不能直接new接口对象
        //MyInterfaceAbstract inter=new MyInterfaceAbstract();
        //创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs1();
        impl.methodAbs2();
        impl.methodAbs3();
        impl.methodAbs4();
    }
}

//定义一个接口类
public interface MyInterfaceAbstract {
    void methodAbs1();

    void methodAbs2();

    void methodAbs3();

    void methodAbs4();
}

//定义接口
public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{
    @Override
    public void methodAbs1() {
        System.out.println("这是我的第一种方法");
    }

    @Override
    public void methodAbs2() {
        System.out.println("这是我的第二种方法");
    }
    @Override
    public void methodAbs3() {
        System.out.println("这是我的第三种方法");
    }
    @Override
    public void methodAbs4() {
        System.out.println("这是我的第四种方法");
    }
}

1.3.1含有默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。

静态方法：使用 static 修饰，供接口直接调用。

代码如下：

/*
1.接口的默认方法，可以通过接口实现类对象，直接调用
2.接口的默认方法，也可以被接口实现类进行覆盖重写
 */
public class Demo02Interface {
    public static void main(String[] args) {
        //创建了实现类对象
        MyInterfaceDefaultA a=new MyInterfaceDefaultA();
        a.methodAbs();//调用抽象方法，实际运行的是右侧的实习类
        //调用默认方法，如果实现类当中没有，会向上找借口
        a.methodDefault();//这是新添加的默认方法
        System.out.println("-----------------------");
        MyInterfaceDefaultB b=new MyInterfaceDefaultB();
        b.methodAbs();
        b.methodDefault();//实现类B覆盖重写了接口的默认方法
    }
}


/*
从java8开始，接口允许定义默认方法
格式：
public default 返回值类型 方法名称（参数列表）{
    方法体
}
备注：
接口当中的默认方法，可以解决接口升级的问题
 */
public interface MyInterfaceDefault {
    //抽象方法
    public abstract void methodAbs();
    //新添加了一个抽象方法
    //public abstract void methodAbs2();
    //新添加的方法，改成默认方法
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法");
    }
}



public class MyInterfaceDefaultA implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，AAA");
    }
}


public class MyInterfaceDefaultB implements MyInterfaceDefault{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法，BBB");
    }
}

1.3.2静态方法的使用

/*
    注意：不能通过接口实现类的对象来调用接口当中的静态方法
    正确用法：通过接口名称，直接调用其中的静态方法
    格式：
    接口名称.静态方法名（参数）
 */
public class Demo03Interface {
    public static void main(String[] args) {
    //创建了实现类对象
        MyInterfaceStaticImpl impl=new MyInterfaceStaticImpl();
        //错误写法
        //impl.methodStatic();
        //直接通过接口名称调用静态方法
        MyInterfaceStatic.methodStatic();
    }
}


/*
从java8开始，接口当中允许定义静态方法
格式：
public static 返回值类型 方法名称（参数列表）{
    方法体
}
提示：就是将abstract或者default换成static即可，带上方法方法体
 */
public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是接口的静态方法！");
    }
}

public class MyInterfaceStaticImpl implements MyInterfaceStatic{
}