接口、接口中成员的特点、接口和类之间的关系、接口的应用、适配器设计模式

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

1，接口用interface定义，定义格式：public interface 接口名 {}

2，接口不能实例化

3，接口与类之间是实现关系，通过implements关键字来表示，定义格式：public class 类名 implements 接口名 {}

4，接口的子类（实现类），要么重写接口中的所有抽象方法，要么是抽象类

注意1：

接口和类的实现关系，可以单实现，也可以多实现

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

注意2：

实现类还可以在继承一个类的同时实现多个接口

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

练习：编写带有接口和抽象类的标准Javabean类

青蛙   属性：名字，年龄       行为：吃虫子，蛙泳

狗      属性：名字，年龄        行为：吃骨头，狗刨

兔子   属性：名字，年龄        行为：吃胡萝卜

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 interface swim {
    public abstract void swim();
}

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

总结：抽象类是将各类中共性的方法抽取出来，其他类继承抽象类即可重写该共性方法。

接口是将某些类中共性的方法抽取出来，其他类实现接口再对该方法进行重写。

接口中成员的特点

1，成员变量：只能是常量，默认修饰符：public static final

2，接口中没有构造方法

3，成员方法：只能是抽象方法，默认修饰符：public abstract

注意：jdk7以前，接口中只能定义抽象方法；jdk8的新特性，接口中可以定义有方法体的方法；jdk9新特性，接口中可以定义私有方法

接口和类之间的关系

1，类与类之间的关系：继承关系，只能单继承，不能多继承，但是可以多层继承

2，类与接口之间的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

如果两个接口中含有重名的方法method1，此时一个类继承了这两个接口，重写一次method1即可，method1既表示重写了接口1中的method1方法，也表示重写了接口2中的method1方法。

3，接口与接口之间的关系：继承关系，可以单继承，也可以多继承

接口中的静态方法不能被重写 

JDK9：接口中可以定义私有方法，私有方法分两种：普通私有方法，静态私有方法

定义私有方法是为了抽取方法体中的相同代码块

 接口的应用

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

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

适配器设计模式