Java 接口及相关知识合集

阅读说明

代码块内  [   ]  中的内容可以省略

一、接口的介绍

• 接口(Interface)，在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
• 接口是一种引用类型，最重要的内容就是其中的抽象方法。

二、接口的定义与使用

1.定义

public interface 接口名称{
	//接口内容
	//抽象方法(接口的核心内容)
}

2.使用

实现接口的关键字：implements

public [abstract] class 类名称 implements 接口名称{
    //类的内容
    //重写抽象方法
}

【注意】

1.接口不能直接实例化，必须用一个实现类来实现接口
2.接口的 实现类必须重写接口中所有的抽象方法
3.如果实现类没有重写所有接口中的抽象方法，那么这个实现类一定是抽象类
4.接口中 没有构造方法和静态代码块

三、接口中允许定义的内容

java版本	可被定义的内容
java 7	常量
	抽象方法
java 8	默认方法
	静态方法
java 9	私有方法

1.常量

(1)定义格式

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

(2)使用

接口名称.常量名;

【注意】

• 接口中的常量始终被public static final三个关键字修饰，且不可更改，编写代码时可以省略不写
• 常量定义之后必须赋值
• 命名规则：全部字母大写，多个单词用 _ 分隔

2.抽象方法（重点）

(1)定义格式

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

【注意】

• 接口中的抽象方法始终被public abstract关键字修饰，且不可更改，编写代码时可以省略不写
• 抽象方法没有方法体

(2)抽象类使用实例

定义 接口，并用多种形式定义 抽象方法（效果相同）

public interface InterfaceAbstract {

    //这是一个抽象方法
    public abstract void methodOne();
    //这是一个抽象方法
    abstract void methodTwo();
    //这是一个抽象方法
    public void methodThree();
    //这是一个抽象方法
    void methodFour();

}

创建 实现类 实现接口
实现类必须重写接口中所有的抽象方法

public class InterfaceAbstractImpl implements InterfaceAbstract{

    @Override
    public void methodOne() {
        System.out.println("第一个方法");
    }
    @Override
    public void methodTwo() {
        System.out.println("第二个方法");
    }
    @Override
    public void methodThree() {
        System.out.println("第三个方法");
    }
    @Override
    public void methodFour() {
        System.out.println("第四个方法");
    }
    
}

在 测试类 中创建 实现类 对象

public class Test01Interface {
    public static void main(String[] args) {
        InterfaceAbstractImpl interfaceAbstract = new InterfaceAbstractImpl();
        interfaceAbstract.methodOne();
        interfaceAbstract.methodTwo();
        interfaceAbstract.methodThree();
        interfaceAbstract.methodFour();
    }
}

运行结果

3.默认方法

默认方法可以用于 接口升级、拼接lambda表达式

(1).定义格式

[public] default 返回值类型 方法名称(){
    方法体;
}

【注意】

• 接口中的默认方法始终被public关键字修饰，且不可更改，编写代码时可以省略不写
• 默认方法可以被实现类对象直接调用，可以被实现类重写

4.静态方法

方法的内容属于类时，应该使用静态方法

(1)定义格式

[public] static 返回值类型 方法名称（参数列表）{
    方法体;
}

【注意】

• 接口中的抽象方法始终被public关键字修饰，且不可更改，编写代码时可以省略不写
• 静态方法只能通过接口名称来调用（避免继承多个接口中存在重复静态方法）

5.私有方法

不可以被实现类使用的方法应该私有化

(1)定义格式

普通私有方法
解决多个默认方法的重复代码问题

private 返回值类型 方法名称（参数列表）{
    方法体;
}

静态私有方法
解决私有方法重复代码的问题

private static 返回值类型 方法名称（参数列表）{
    方法体;
}

四、接口的多实现与多继承

1.实现多个接口

(1)格式

public class 实现类 implements 接口1, 接口2, ... {
    //重写所有抽象方法
}

(2)代码实例

定义两个接口

public interface InterfaceOne {
    public abstract void methodOne();
    void method();
}

public interface InterfaceTwo {
    public abstract void methodTwo();
    void method();
}

创建实现类，继承两个接口

public class InterfaceImpl /* extends Object */implements InterfaceOne,InterfaceTwo{
    @Override
    public void methodOne() {
        System.out.println("InterfaceOne和InterfaceTwo接口中重复的method方法只需要在实现类中重写一次");
    }
    @Override
    public void method() {
        System.out.println("重写了InterfaceOne接口中的methodOne方法");
    }
    @Override
    public void methodTwo() {
        System.out.println("重写了InterfaceTwo接口中的methodTwo方法");
    }
}

【注意】

1.一个类的直接父类是唯一的，但可以同时实现多个接口
2.如果出现多个接口出现重复抽象方法，实现类只需要覆盖重写一个即可
3.如果没有实现所有的抽象方法，那么实现类必须是一个抽象类==
4.如果多个接口中存在重复的默认方法，那么实现类必须对重复的默认方法进行重写
5.一个类如果直接父类当中的方法和接口中的默认方法重复，会优先使用直接父类的抽象方法（父类方法的优先级大于接口）

2.接口的多继承

(1) 格式

public interface 接口 extends 接口1, 接口2, ...{
	//接口内容
}

(2)多继承实例

定义两个接口

public interface InterfaceOne {
    void methodOne();
}

public interface InterfaceTwo {
    void methodTwo();
}

定义一个 接口 继承两个接口

public interface InterfaceTest extends InterfaceOne,InterfaceTwo{
    void method();
}

【注意】

1.如果多个接口中的抽象方法重复，没关系
2.如果多个父接口的默认方法重复，则子接口必须带着 default 关键字对重复的默认方法进行重写

五、接口类型作为方法的参数和返回值

//定义接口
interface Interface {
    //接口中的test抽象方法
    void test();
}

//创建测试类
public class Test {

    public static void main(String[] args) {
        //使用匿名内部类创建接口对象，作为参数
        Interface anInterface = new Interface() {
            @Override
            public void test() {
                System.out.println("这是接口类型作为方法的参数");
            }
        };
        //向method方法传递参数，并调用接口中的test方法
        method(anInterface).test();
    }

	//声明一个以Interface为参数和返回值类型的方法
    public static Interface method(Interface para){
        //使用参数调用test()方法
        para.test();
        //使用匿名对象的匿名内部类作为方法的返回值
        return new Interface() {
            @Override
            public void test() {
                System.out.println("这是接口类型作为方法的返回值");
            }
        };
    }

}

运行结果

六、接口与类

以下内容引自 菜鸟教程 — Java 接口

1.接口与类相似点

一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

2.接口与类的区别

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

3.接口与抽象类

抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(java 8+可以)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。