JavaSE——Interface接口

接口是一种规范，因为Java中只能由一个父类，当我们需要使用到多个父类的特定功能的时候，接口就可以帮助实现。

1. 接口和类是两个并列的结构
2. 实现接口的顺序：class A extends B implments C,D{}
3. 接口中的成员

3.1、JDK7以前，只能定义全局常量(public static final)和抽象方法(public abstract)但是可以省略不写
3.2、JDK8，还可以定义静态方法、默认方法

4. 类如果实现了接口中所有的抽象方法，该类就可以实例化，如果没有完全实现，此类是一个抽象类。

JDK7中事项的全局常量和抽象方法

public class world {
    public static void main(String[] args){
        p a=new p();
        a.fun();
        a.f();
        System.out.println("速度是"+flyable.MAX_SPEED);//可以使用接口调用全局变量
    }
}

interface flyable{
    public static final int MAX_SPEED=100;
    public abstract void fun();
    void f();
}

abstract class plane implements flyable{

    @Override
    public void fun() {
        System.out.println("飞机能飞");
    }
}
class p extends plane{

    public void fun(){
        System.out.println("小飞机不能飞");
    }

    @Override
    public void f() {
        System.out.println("hhh");
    }
}

JDK8新增的静态方法和默认方法

public class test {
    public static void main(String[] args) {
        B a=new B();
        A.fun1();
        a.fun2();
        a.fun3();
    }
}

interface A{
    public static void fun1(){
        System.out.println("这是静态方法");
    }
    
    public default void fun2(){//这里默认方法要加上default
        System.out.println("这是默认方法");
    }
    public default void fun3(){//这里默认方法要加上default
        System.out.println("这是子类的默认方法");
    }
}

class B extends fB implements A{//如果父类调用的默认方法和子类方法重名了，则调用父类方法。
    public void fun2(){//注意这里重写后不能加上default
        System.out.println("这是重写后的默认方法");
    }
}

class fB{
    public void fun3(){
        System.out.println("这是父类的默认方法");
    }
}
//这是静态方法
//这是重写后的默认方法
//这是父类的默认方法

5. 接口和接口之间可以继承

interface A{}
interface B{}
interface C extends A,B{}

6. 如何访问到接口中的默认方法

public class world {
    public static void main(String[] args) {
        man a =new man();
        a.help();
    }
}

interface Mom{
    public default void help() {
        System.out.println("先救妈");
    }
}

interface wife{
    public default void help(){
        System.out.println("先救媳妇");
    }
}

class man implements Mom,wife{

    @Override
    public void help() {
        Mom.super.help();
    }
}
//先救妈

代理模式

public class world {
    public static void main(String[] args) {
        Server server=new Server();
        ProxyServer proxyServer=new ProxyServer(server);//这里使用了多态，server是接口的实现类
        proxyServer.browse();
    }
}

interface NetWork{
    public abstract void browse();
}
//被代理类
class Server implements NetWork{
    @Override
    public void browse() {
        System.out.println("真实的服务器访问网络");
    }
}
//代理类
class ProxyServer implements NetWork{
    private NetWork work;

    public ProxyServer(NetWork work){
        this.work=work;
    }

    public void check(){
        System.out.println("联网之前检查工作");
    }

    @Override
    public void browse() {
        check();
        work.browse();
    }
}

面试题

接口和类是同级的，当重名的时候出现问题，需要注意的是默认方法重名的时候使用的是父类的方法。

时刻记着接口当中的全局常量和抽象方法

练习题

public class world {
    public static void main(String[] args) {
        comparableCircle c1=new comparableCircle(3.2);
        comparableCircle c2=new comparableCircle(3.4);
        int res=c1.compareTo(c2);
        if(res>0) System.out.println("c1 bigger");
        else if(res<0) System.out.println("c2 bigger");
        else System.out.println("similar");
    }
}


class Circle{
    private Double r;
    public void setCircle(Double r){
        this.r=r;
    }
    public Double getCircle(){
        return r;
    }

    public Circle(Double r) {
        this.r = r;
    }
    public Circle(){

    }
}

interface CompareObject{
    public abstract int compareTo(Object o);
}

class comparableCircle extends Circle implements CompareObject{

    public comparableCircle(){
        super();
    }
    public comparableCircle(Double r){
        super(r);
    }
    @Override
    public int compareTo(Object o) {
        if(this==o) return 1;
        if(o instanceof comparableCircle){
            return this.getCircle().compareTo(((comparableCircle) o).getCircle());
        }else return 0;
    }
}