初识接口

标签：name void 接口 public 初识 Override abstract

接口

接口的定义和使用

接口用关键字interface来定义
接口不能实例化
接口和类之间是实现关系，通过implments关键字表示

public class 类名 implements 接口名{}
接口的子类（实现类）

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

要么是抽象类

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

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

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

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

如何使用接口

案例：

1.先画一个图去剖析这个题

2.开始编写JavaBean和测试类

写父类Animal，其中eat方法需要重写可以使用final修饰

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();
}

分别写出另外三个子类

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("青蛙会蛙泳");
    }
}

public class Rabbit extends Animal{
    public Rabbit() {
    }

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

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

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("狗会狗刨");
    }
}

写出测试类

public class Test {
    public static void main(String[] args) {
        Dog d=new Dog("花花",3);
        System.out.println(d.getName()+","+d.getAge());
        d.eat();
        d.swim();
        //另外两个对象相差不大，就不写了
    }
}

测试结果

接口中成员的特点

成员变量

只能是常量

默认修饰符：public static final
构造方法

没有
成员方法

只能是抽象方法

默认修饰符：public abstract

jdk7以前

接口和类之间的关系

类和类之间的关系

继承关系，只能单继承，不能多继承，但是可以多层继承
类和接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口，如果多个接口中有重名的方法，那么只需要重写一次就行
接口和接口的关系

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

如果使用的是子接口，那么使用子接口时候要重写父接口及子接口所有的方法

接口扩展

JDK8开始接口新增的方法

JDK7以前：接口中只能定义抽象方法
JDK8新特性：接口中可以定义有方法体的方法。(默认，静态)
JDK9新特性：接口中可以定义私有方法

JDK8以后接口新增的方法

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

作用：解决接口升级的问题

接口中默认的定义格式：

格式：public default 返回值类型方法名(参数列表){}
范例：public default void show(){}

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

默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字
public可以省略，default不能省略
如果实现了多个接口，多个接口存在相同名字的默认方法，子类就必须对该方法进行重写

Demo演示

public interface Inter {
    //写一个抽象方法
    public abstract void method();
    //写一个默认的方法
    public default void work(){
        System.out.println("这是一个默认的work");
    }
}

public class InterImpl implements Inter{

    @Override
    public void method() {
        System.out.println("重写的method");
    }

}

public class Test {
    public static void main(String[] args) {
        InterImpl li=new InterImpl();

        li.method();
        li.work();
    }
}

重写默认方法必须去掉default关键字即可

@Override
public void work() {
    Inter.super.work();
}

允许在接口中定义静态方法，需要用static修饰

接口中静态方法的定义格式

格式：public static 返回值类型方法名(参数列表){}
范例：public static void show(){}

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

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
public可以省略，static不能省略

接口的应用

接口代表行为，是行为的抽象。想要哪个类拥有一个行为，就让这个类实现对应接口就可以了。
当一个方法的参数是接口时，可以传递接口所有实现类的对象，这种方式称之为接口多态。

适配器设计模式

设计模式可以简单理解为解决问题的各种套路
适配器设计模式：解决接口与接口之间的矛盾问题

如何书写：

编写一个中间类XXXAdapter，XXX表示接口名，实现对应接口中的抽象方法进行空实现
让真正的实现类继承中间类，并重写需要用的方法
为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰

Demo演示：

public interface inter {
    public abstract void method1();
    public abstract void method2();
    public abstract void method3();
    public abstract void method4();
    public abstract void method5();
    public abstract void method6();
    public abstract void method7();
    public abstract void method8();
    public abstract void method9();
    public abstract void method10();
}

定义了一个接口，其中有十个抽象方法，这种时候如果只需要用方法5，但是需要重写所有抽象方法，就可以定义个适配器去做接口的空实现，最后让实现类只重写方法5即可

public class InterAdapter implements Inter{
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }

    @Override
    public void method5() {

    }

    @Override
    public void method6() {

    }

    @Override
    public void method7() {

    }

    @Override
    public void method8() {

    }

    @Override
    public void method9() {

    }

    @Override
    public void method10() {

    }
}

public class InterImp extends InterAdapter{
    @Override
    public void method5() {
    }
}

最后，避免外界创建适配器类的对象，中间的适配器类用abstract进行修饰

public abstract class InterAdapter implements Inter

标签：name,void,接口,public,初识,Override,abstract
From： https://www.cnblogs.com/lovedong/p/16873459.html

接口