大家好，又见面了，我是你们的朋友全栈君。

接口（interface）

有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

接口(interface)是抽象方法和常量值的定义的集合。

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

接口定义举例

public interface Runner 
   int id = 1
   public void start()
   public void run()
   public void stop(）    
}

案例:

蝙蝠会飞,又会用牙齿咬

首先定义一个飞行的接口：

package cn.com.Classwork190124;

/*
    如果一个类中，既有抽象方法，又有非抽象方法，那么该类只能定义为抽象类，不能定义为接口
    如果一个类中，只有抽象方法，没有非抽象方法，那么该类可以定义为接口
                            一般就定义为接口
    定义一个接口，使用interface关键字  接口，类，枚举，注解等都是java中的类型
    接口中所有的方法，都是抽象方法
        所以也可以说，接口就是一个特殊的抽象类

    接口中除了定义方法外，还可以定义成员变量
                特点；方法和属性默认都是public修饰，也可以使用protected，但不能用private
                      所有的属性都是静态的常量，默认省略了static和final修饰符，属性的值必须实例化（初始化）

 */

public interface Flyable {
    public final int wingsNumber = 2;
    public abstract void fly();

}

接着定义一个咬人的接口：

package cn.com.Classwork190124;

public interface Bitable {
    public int teethNumber = 0;
    public abstract void bite();
}

最后定义蝙蝠类去实现这两个接口：

package cn.com.Classwork190124;

/*
    在JAVA中，一个类无法继承自多个类，但是可以实现多个接口，使用关键字implements
                                        多个接口之间使用“,”隔开  多个接口之间，没有先后顺序
    这个类叫做实现类，这个类必须实现所有接口的所有方法
 */

public class Bat implements Flyable,Bitable {
    @Override
    public void bite() {
        System.out.println("吸血");
    }

    @Override
    public void fly() {
        System.out.println("用翅膀飞");
    }

    public static void main(String[] args) {
        System.out.println(Flyable.wingsNumber);
    }
}

接口的特点：

用 interface 来定义。

接口中的所有成员变量都默认是由public static final修饰的。

接口中的所有方法都默认是由public abstract修饰的。

接口没有构造方法。构造方法用于创建对象

实现接口的类中必须提供接口中所有方法的具体实现内容。

多个无关的类可以实现同一个接口

一个类可以实现多个无关的接口

与继承关系类似，接口与实现类之间存在多态性

接口也可以继承另一个接口，使用extends关键字。

实现接口的类中必须提供接口中所有方法的具体实现内容。

多个无关的类可以实现同一个接口

一个类可以实现多个无关的接口

与继承关系类似，接口与实现类之间存在多态性

定义Java类的语法格式：

< modifier> class < name> [extends < superclass>]

[implements < interface> [,< interface>]* ] {

< declarations>*

}
此外，接口还常常被用来当做定义常量的集合：

package cn.com.Classwork190124;

/*
    接口也经常用来被定义常量的集合  默认省略public static final
    定义更简单，使用更方便
 */

public interface Power {
    int vol = 220;
    double hz = 50.0;
}

案例：

在这里插入图片描述
如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类。

接口也可以继承另一个接口，使用extends关键字

interface MyInterface

{

String s=“MyInterface”;

public void absM1();

}

interface SubInterface extends MyInterface

{

public void absM2();

}

public class SubAdapter implements SubInterface

{

public void absM1(){System.out.println(“absM1”);}

public void absM2(){System.out.println(“absM2”);}

}

JDK8新增接口中抽象方法的默认实现使用default关键字

package cn.com.Classwork190124;

public interface Bitable {
    public int teethNumber = 0;
    //public abstract void bite();
    /*
    java新增接口中抽象方法的默认实现   使用default关键字
    加上default关键字后需要实现方法体
    子类中成为覆盖该方法
     */
    default void bite() {
        System.out.println("用牙齿咬");
    }
}

注意：如果实验发现明明用的是jdk8却报错为：Extension methods are not supported at language level ‘6’ 请进入idea file->project structure 在project选项卡下将图中被圈的部分改为8即可（language level不能比项目的jdk版本高）。
在这里插入图片描述
还可以附带static的默认实现方法

package cn.com.Classwork190124;

/*
    接口也经常用来被定义常量的集合  默认省略public static final
    定义更简单，使用更方便
 */

public interface Power {
    int vol = 220;
    double hz = 50.0;
    /*
    jdk8新增功能
     */
    public static void lightOn(){
        System.out.println("默认的点灯方法");
    }

    public static void main(String[] args) {
        Power.lightOn();
    }
}

练习

定义一个接口用来实现两个对象的比较。

package cn.com.Classwork190124;

public interface CompareObject<object> {
    public int compareto(object o);
    //若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
}

定义一个Circle类。

package cn.com.Classwork190124;

public class Circle {
    private double radius;
    private final double PI=3.14;

    public double findArea(){
        return PI*radius*radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }
}

定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。

package cn.com.Classwork190124;

public class ComparableCircle extends Circle implements CompareObject<Circle> {
    @Override
    public int compareto(Circle o) {
        if(this.getRadius()==o.getRadius()){
            return 0;
        }else if(this.getRadius()<=o.getRadius()){
            return -1;
        }else {
            return 1;
        }
    }
}

定义一个测试类TestInterface，创建两个ComaparableCircle对象，调用compareTo方法比较两个类的半径大小。

package cn.com.Classwork190124;

import java.util.Scanner;

public class TestInterface {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ComparableCircle c1 = new ComparableCircle();
        ComparableCircle c2 = new ComparableCircle();
        c1.setRadius(sc.nextDouble());
        c2.setRadius(sc.nextDouble());
        System.out.println(c1.compareto(c2));
    }
}

思考：参照上述做法定义矩形类Rectangle和ComparableRectangle类，在ComparableRectangle类中给出compareTo方法的实现，比较两个矩形的面积大小。
emmmmm换汤不换药我这里就不赘述了（绝对不是因为太懒！）。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/158476.html原文链接：https://javaforall.net