接口,是Java语言中的一种引用类型,是方法的集合,如果说类的内部封装了成员变量、构造方法和成员方法,那么接口的内部主要就是封装了方法,包括抽象方法(JDK7及以前),默认方法和静态方法(JDK8)。

接口的定义与类相似,使用interface关键字,它会被编译成 .class 文件,但一定要明确它并不是类,而是另外一种引用数据类型(接口,类,数组)。

public class 类名.java -->.class

public interface 接口名.java-->.class

接口的使用,它不能创建对象,但是可以被实现(implements,类似于被继承)。一个实现接口的类(可以看做是接口的子类),需要实现接口中的所有抽象方法,创建该类对象,就可以调用方法了,否则它必须是一个抽象类。

定义格式

public interface 接口名称{
    //抽象方法(可选,可以省略)
    //默认方法(必选,不可省略)
    //静态方法
}

含有抽象方法

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

public interface InterFaceName{
    public abstract void method();
}

含有默认方法和静态方法

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

静态方法:使用static修饰,供接口直接调用

public interface InterFaceName{
    public default void method(){
        //执行语句
    }
    public static void methods(){
        //执行语句
    }
}

基本实现

类与接口的实现关系即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类,实现的动作类似继承,格式相仿,关键字是inplements

非抽象子类实现接口

  1. 必须重写接口中所有抽象方法
  2. 继承了接口的默认方法,即可以直接调用,class 类名 implememnts 接口名{ //重写接口中的抽象方法【必须】 //重写接口中的默认方法【可选】 }

 


  

class 类名 implements 接口名{
    //重写接口中抽象方法【必选】
    //重写接口中的默认方法【可选】
}

抽象方法的使用(必须全部实现)

定义接口

public interface LiveAble{
    //定义抽象方法
    public abstract void eat();
    public abstract void singing();
}

定义实现类

public class Beauty implements LiveAble{
    @Override
    public void eat(){
        System.out.println("吃播开始“);
    }
    @Override
    public void singing(){
        System.out.println("歌手准备“);
    }
}

定义测试类:

public class InterfaceDemo{
    public static void main(String[] args){
        //创建子类对象
        Beauty b = new Beauty();
        //调用实现后的方法
        b.eat();
        b.sleep();
    }
}


输出结果:
吃播上线
歌手准备

默认方法的使用

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

1,继承默认方法,代码如下

定义接口:

public interface LiveAble{
    public default void fly(){
        System.out.println("超人来了“);
    }
}

定义实现类:

public class Beauty implements LiveAble{
    //继承,什么都不用写,直接使用
}

定义测试类:

public class InterFaceDemo{
    public static void main(String[] args){
        //创建子类对象
        Beauty b = new Beauty();
        //调用默认方法
        b.fly();
    }
}

输出结果:
超人来了

重写默认方法:

定义接口

public interface LiveAble{
    public default void fly(){
        System.out.println("超人来了“);
    }
}

定义实现类

public class Beauty impliemnts LiveAble{
    @Override
    public void fly(){
        System.out.println("自由自然地飞");
    }
}

定义测试类

public class InterFaceDemo{
    public static void main(String[] args){
    //创建类对象
    Beauty b = new Beauty();
    //调用方法
    }
}


输出结果:
自由自在地飞

静态方法的使用

静态与 .class 文件相关,只能使用接口名调用,不可以通过实现类的类名或者实现类的对象调用

定义接口

public interface LiveAble{
    public static void run(){
        System.out.println("paoqilai");
    }
}

 定义实现类:

public class Beauty implements LiveAble{
    //无法重写静态方法
}

定义测试类:

pbulic class InterFaceDemo{
    public static void main(String[] args){
        //Beauty.run();//[错误]无法继承方法,也无法调用
        LiveAble.run();//
    }
}

输出结果:
paoqilai

成员变量的使用

接口,无法定义成员变量,但是可以定义常量,其值不可以改变,默认使用public static final 修饰

定义接口:

public interface LiveAble{
    int NUM0; // 错误,必须赋值
    int NUM1=10; //正确,省去了默认修饰符,public static final
    public static final int NUM2 = 100;//正确,完整写法
}

定义测试类

public class InterfaceDemo{
    public static void main(String[] args){
        System.out.println(LiveAble.NUM1);
        System.out.println(LiveAble.NUM2);
    }
}

输出结果:
10
100

接口的多实现

在继承体系中,一个类只能继承一个类,对于接口而言,一个类是可以实现多个接口的,这叫做接口的多实现。所以,一个类能继承一个类,同时实现多个接口。

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3...{
    //重写接口中的抽象方法【必须】
    //重写接口中的默认方法【不重名时可选】
}

抽象方法

接口中,多个抽象方法是,实现类必须重写所有的抽象方法。如果抽象方法有重名,只需重写一次

默认方法

接口中,有多个默认方法时,实现类都可以继承使用。如果默认方法有重名,必须重写一次

静态方法

接口中,存在同名的静态方法并不会冲突,原因是只能通过各自接口名访问静态方法

接口的多继承

一个接口能继承另外一个或者多个接口,这和类之间的继承比较相似。接口的继承使用extends关键字,子接口继承父类接口的方法。如果父类接口中的默认方法有重名的,那么子接口需要重写一次。

定义父接口:

interface A{
    public default void method(){
        System.out.println("AAA")};
    }
}


interface B{
    public default void method(){
        System.out.println("BBB");
    }
}

定义子接口:

interface D extends A,B{
    @Override
    public default void method(){
        System.out.printl("DDDD");
    }
}

抽象类和接口对比(小结)

相同点:

都位于继承的顶端,用于被其他类实现或继承;

都不能直接实例化对象

都包含抽象方法,其子类都必须覆写这些抽象方法

区别:

抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重复性

接口只能包含抽象方法

一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

抽象类为继承体系中的共性内容;

接口为继承体系中的扩展功能;

成员区别:

  • 抽象类:变量、常量;有构造方法;有抽象方法,也有非抽象方法
  • 接口:常量、抽象方法

关系区别:

  • 类与类:继承、单继承
  • 类与接口:实现、可以单实现,也可以多实现
  • 接口与接口:继承、单继承、多继承

设计理念区别:

  • 抽象类:对类抽象,包括属性、行为
  • 接口:对行为抽象,主要是行为