Java接口：概述、多实现、多继承、JDK8后接口新增方法一、接口：二、接口的使用 三、接口与接口的关系 四、JDK8开始之后接口新增的方法

一、接口：

1.接口是什么？

• 接口也是一种规范：约束别人必须这样设计；
• 规范一定是公开的：比如学校规定每天早上8点上课，这些都是需要公开出去的；
• 所以接口里面设计的常量和抽象方法帮你徐都是公开化的，如果你不用public修饰，它也会默认为public，写不写都是公开的；
• 举个例子：
• 比如生活中的插座，规定是两孔就是两孔，你拿个三孔插入两孔是不是插不进。

2、接口的定义与特点

语法格式：

• 接口用interface关键字来定义
• 注意：由于接口体现规范思想，规范默认都是公开的，所以接口中代码层面沉淀的修饰符都可以省略不写

public interface 接口名{
//常量
//抽象方法
}

public interface InterfaceDemo {
    //常量
//    public static final String SCHOOL_NAME = "B站大学";
    String SCHOOL_NANE = "B站大学";        //不会报错默认公开
    String USER_NAME = "admin";
    String PASS_WORD = "123456";
    
    //抽象方法
//    public abstract void run();
    void run();     //不会报错，默认公开
    void eat();
    void write();
}

二、接口的使用

1.接口的实现

接口是用来被类实现（implements）的，实现接口的类称为实现类；实现类可以理解成所谓的子类。

修饰符 class 实现类 implements 接口1,接口2,接口3, ...{
    
}

从上面的代码中，接口可以被单类实现，也可以被类多实现。

例：

/*
运动员接口：体现运动员的规范
 */
public interface Athletes {
    //规范1：运动员要天天训练
    void run();
    //规范2：运动员要参加比赛
    void competition();
}

//食谱接口
public interface Recipe {
    //规范：运动员可选择吃什么
    void eat();
}

/*
足球运动员类——>接口实现类：可以多实现，逗号隔开
 */
public class FootballPlayer implements Athletes, Recipe {
    private String name;        //姓名

    public FootballPlayer(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name+"天天认真训练");
    }

    @Override
    public void competition() {
        System.out.println(name+"参加世界杯为国争光");
    }

    @Override
    public void eat() {
        System.out.println(name+"希望一天要吃10条海参补充体力");
    }
}

/*
测试类
 */
public class InterfaceImplementsTest {
    public static void main(String[] args) {
        FootballPlayer f = new FootballPlayer("赵鹏");
        f.run();
        f.competition();
        f.eat();
    }
}

控制台输出：

 三、接口与接口的关系

1.基本小结：

• 类和类的关系：但继承；
• 类和接口的关系：多实现；
• 接口和接口的关系：多继承，一个接口可以同时继承多个接口；

2.接口多继承的作用：

规范合并，整合多个接口为同一个接口，便于子类实现。

• 一个接口继承多个接口，得到多个接口的功能集结于自身，这样接口实现类就只需要实现一个接口，就能得到多个接口的功能。

/*
人接口
 */
public interface People {
    //规范：人必须睡觉吃东西
    void eat();
    void sleep();
}

/*
法律接口
 */
public interface Law {
    //规范：必须守法不能触犯法律
    void rule();
}

/*
运动员接口
多继承：人接口、法律接口 集结于一身
 */
public interface Athletes extends People,Law{
    //规范：运动员必须训练和比赛
    void run();
    void competition();
}

/*
接口实现类：篮球运动员
由于Athletes接口继承了多个接口，所以实现类只需要实现Athletes一个接口
 */
public class Basketballer implements Athletes{
    private String name;

    public Basketballer(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name+"篮球运动员加油训练");
    }

    @Override
    public void competition() {
        System.out.println(name+"篮球运动员必须参加比赛");
    }

    @Override
    public void rule() {
        System.out.println(name+"篮球运动员是守法的好公民");
    }

    @Override
    public void eat() {
        System.out.println(name+"篮球运动员必须吃大量食物");
    }

    @Override
    public void sleep() {
        System.out.println(name+"篮球运动员必须睡好觉");
    }
}

/*
测试类
 */
public class InterfaceExtendsTest {
    public static void main(String[] args) {
        Basketballer b = new Basketballer("林书豪");
        b.run();
        b.competition();
        b.eat();
        b.rule();
        b.sleep();
    }
}

控制台输出结果：

 四、JDK8开始之后接口新增的方法

1.默认方法：defalut修饰，实现类对象调用；

• 类似之前写的普通实例方法：必须用defalut修饰；默认会用public修饰。需要用接口的实现类的对象来调用；

defalut void run() {
    System.out.println("跑起来了");
}

示例： 

/*接口

 */
public interface InterfaceDemo {
    default void run(){
        System.out.println("默认方法被调用");
    }
}

/*
接口实现类
 */
public class InterfaceImplementsDemo implements InterfaceDemo{

}

/*
测试类
 */
public class Test {
    public static void main(String[] args) {
        //默认方法只能使用实现类对象名来调用
        InterfaceImplementsDemo interfaceImplementsDemo = new InterfaceImplementsDemo();
        interfaceImplementsDemo.run();
    }
}

控制台输出： 

2.静态方法：static修饰，接口名称调用；

• 默认会用public修饰，必须static修饰

注意：接口的静态方法必须要用接口本身的接口名来调用

static void inAddr() {
	System.out.println("我们都在bilibili教育中心快乐的学习Java~~");
}

3.私有方法：private修饰，jdk9开始才有的，只能在接口内部其他的默认方法或者私有方法访问。

私有的实例方法，必须使用private修饰，从JDK9才开始有的

只能在本接口中被其他的默认方法或者私有方法访问。

private void go() {
	System.out.println("准备~~")
}

/*接口

 */
public interface InterfaceDemo {
    /*
    默认方法
     */
    default void run(){
        System.out.println("默认方法被调用");
        //在接口内部的其他默认方法中调用私有方法
        go();   
    }
    /*
    静态方法
     */
    static void inAddr(){
        System.out.println("静态方法被调用");
//        go();    //报错，因为静态方法无法调用私有方法
    }
    /*
    私有方法
     */
    private void go() {
        System.out.println("准备~~");
        //在接口的内部，私有方法可以互相访问
        test(); 
    }
    private void test(){
        System.out.println("私有方法请私有方法吃饭");
    }
}

/*
接口实现类
 */
public class InterfaceImplementsDemo implements InterfaceDemo{

}

/*
测试类
 */
public class Test {
    public static void main(String[] args) {
        //默认方法只能使用实现类对象名来调用
        InterfaceImplementsDemo interfaceImplementsDemo = new InterfaceImplementsDemo();
        interfaceImplementsDemo.run();
        //默认方法必须使用接口本名来调用
        InterfaceDemo.inAddr();

    }
}

注意事项：他们都会被public修饰

最后

以上就是无私冬瓜最近收集整理的关于Java接口：概述、多实现、多继承、JDK8后接口新增方法一、接口：二、接口的使用 三、接口与接口的关系 四、JDK8开始之后接口新增的方法的全部内容，更多相关Java接口：概述、多实现、多继承、JDK8后接口新增方法一、接口：二、接口内容请搜索靠谱客的其他文章。