Java中interface详解

一.介绍

接口：接口就是一种规则，是对行为的抽象。

抽象类是对整个类整体进行抽象。

二.接口的定义和使用

1.接口代表规则，是行为的抽象。想要让哪个类拥有一个行为，就让这个类实现对应的接口就可以了。

2.当一个方法的参数是接口时，可以传递接口所有实现类的对象，这种方式称之为接口多态。

接口用关键字interface来定义

public  interface  接口名{}

接口不能实例化(不能创建对象)

接口和类之间是实现关系，通过implements关键字表示

public  class  类名  implements  接口名{}

接口的子类(实现类)

要么重写接口中的所有抽象方法

要么是抽象类

注意1：接口和类的实现关系，可以单实现，也可以多实现 。

public  class  类名  implements  接口名1， 接口名2{}

注意2：实现类还可以在继承一个类的同时实现多个接口。

public  class  类名  extends  父类  implements 接口名1， 接口名2{}

三.接口中成员的特点

1.成员变量

        只能是常量

        默认修饰符：public  static final

2.构造方法

        没有

3.成员方法

        只能是抽象方法

        默认修饰符：public abstract

JDK7以前：接口中只能定义抽象方法

四.接口和类之间的关系

1.类和类的关系

继承关系，只能单继承，不能多继承，但是可以多层继承

2.类和接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口(需要重写所有抽象方法)

3.接口和接口的关系

继承关系，可以单继承，也可以多继承。

细节：如果实现类实现了最下面的子接口，那么就需要重写所有的抽象方法

五.实例

测试类：

public class Test {
    public static void main(String[] args) {

        Frog f = new Frog("小青",1);
        System.out.println(f.getName() + " " + f.getAge());

        f.eat();
        f.swim();

        Rabbit r = new Rabbit("小白",2);
        System.out.println(r.getName() + " " + r.getAge());

        r.eat();
    }
}

接口：

public interface Swim {

    public abstract void swim();

}

父类：

public abstract class Animal{

    private String name;
    private int age;

    public Animal(){

    }

    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public int getAge(){
        return age;
    }

    public void setAge(int age){
        this.age = age;
    }

    public abstract void eat();
}

子类1(兔子)：

public class Rabbit extends Animal{

    public Rabbit(){

    }

    public Rabbit(String name, int age){
        super(name,age);
    }

    @Override
    public void eat(){
        System.out.println("兔子在吃胡萝卜");
    }
}

子类2(狗)：

public class Dog extends Animal implements Swim{

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }

    @Override
    public void swim(){
        System.out.println("狗刨");
    }
}

子类3(青蛙)：

public class Frog extends Animal implements Swim{

    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }
}

六.接口中新增方法

JDK8以后接口中新增方法：

1.允许在接口中定义默认方法，需要使用关键字default修饰

作用:解决接口升级问题

接口中默认方法的定义格式：

格式：public  default  返回值类型 方法名（参数列表）{}

例：public  default  void show() {}

接口中默认方法的注意事项：

（1）.默认方法不是抽象方法，所以不被强制重写。但是如果被重写，重写的时候去掉default关键字

（2）.public可以省略，default不能省略

（3）.如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

例：

测试类：

public class Test {
    public static void main(String[] args) {

        InterImpl ii = new InterImpl();

        ii.method();
        ii.show();
    }
}

接口：

public interface Inter {

    public abstract void method();

    public default void show(){
        System.out.println("接口中的默认方法-----show");
    }
}

实现类(实现接口)：

public class InterImpl implements Inter{

    @Override
    public void method(){
        System.out.println("实现类重写的抽象方法----method");
    }
}

2.允许在接口中定义静态方法，需要使用关键字static修饰

接口中默认方法的定义格式：

格式：public  static  返回值类型 方法名（参数列表）{}

例：public  static  void show() {}

接口中静态方法的注意事项：

（1）.静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

（2）.public可以省略，static不能省略

例：

测试类：

public class Test {
    public static void main(String[] args) {

        //调用接口中的show方法
        Inter.show();

        //调用实现类中的show方法
        InterImpl.show();

        //这里不叫重写,只是方法名相同，重写指：子类把从父类继承下来的虚方法表里面的方法进行覆盖,被static修饰的方法不是虚方法
    }
}

接口：

public interface Inter {

    public abstract void method();

    public static void show(){
        System.out.println("Inter中的静态方法-----show");
    }
}

实现类：

public class InterImpl implements Inter{

    @Override
    public void method(){
        System.out.println("InterImpl中的抽象方法----method");
    }

    public static void show(){
        System.out.println("InterImpl中的show方法");
    }
}

JDK9以后接口中新增方法：

作用：解决代码重复问题，不想让外界访问

私有方法分为两种：普通的私有方法，静态的私有方法。

接口中私有方法的定义格式：

格式：private  返回值类型 方法名（参数列表）{}

例：private void  show() {}

给默认方法(default)服务

格式：private static  返回值类型 方法名（参数列表）{}

例：private static  void show() {}

给静态方法(static)服务

例：

接口：

public interface Inter {
    
    public static void show1(){
        System.out.println("show1方法开始执行了");
        show3();
    }

    public static void show2(){
        System.out.println("show2方法开始执行了");
        show3();
    }
    
    private static void show3(){
        System.out.println("此处记录程序各种细节,这里有100行代码");
    }
}

七.适配器设计模式

作用：解决接口与接口实现类之间的矛盾问题

1.当一个接口中抽象方法过多，但是我只要使用其中一部分的时候，就可以用适配器设计模式

2.书写步骤：

编写中间类xxxAdapter,实现对应的接口

对接口中的抽象方法进行空实现

让真正的实现类继承中间类，并重写需要用的方法

为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰

接口:

public interface Inter {

    public abstract void methond1();
    public abstract void methond2();
    public abstract void methond3();
}

适配器：

public abstract class InterAdapter implements Inter{

    @Override
    public void methond1() {

    }

    @Override
    public void methond2() {

    }

    @Override
    public void methond3() {

    }

}

实现类：

public class InterImpl extends InterAdapter{
    @Override
    public void methond2() {
        System.out.println("只要用第二个方法");
    }
}