接口及其细节

接口的定义和使用

•   接口用关键字interface来定义

        public interface 接口名{}

•   接口不能实例化
•   接口和类之间是实现关系，通过implements关键字表示

        public class 类名 implements 接口名{}

•   接口的子类（实现类）

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

        要么是抽象类

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

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

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

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

代码实例：

//父类

package oop_interface.a01_demo1;
//父类
public abstract class Animal {
    private String name;
    private int age;


    public Animal() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Animal{name = " + name + ", age = " + age + "}";
    }

    public abstract void eat();
}

//接口类

package oop_interface.a01_demo1;
//接口
public interface Swim {
    //接口中的抽象方法
    public abstract void swim();
}

//Frog子类

package oop_interface.a01_demo1;

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

//Dog子类

package oop_interface.a01_demo1;

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

//Rabbit子类

package oop_interface.a01_demo1;

public class Rabbit extends Animal{

    public Rabbit() {
    }

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

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

//Test测试类

package oop_interface.a01_demo1;

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 static final

• 构造方法

        没有

• 成员方法

        只能是抽象方法

        默认修饰符：public abstract

•  JDK7以前：接口中只能定义抽象方法。
• JDK8的新特性：接口中可以定义有方法体的方法。
• JDK9的新特性：接口中可以定义私有方法

       接口和类之间的关系

• 类和类的关系

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

• 类和接口的关系

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

• 接口和接口的关系

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

//接口和接口之间是继承关系，可以单继承，也可以多继承
//细节：如果实现类实现类最下面的子接口，那么就需要重写所有的抽象方法

）