概述：一种公共的规范标准，Java中的接口更多的体现在对行为的抽象。

1、接口的特点

1）接口用关键字Interface修饰；public interface 接口名{}

2）类实现接口用implements表示；public class 类名 implements 接口名{}

3）接口不能实例化

接口可参照多态的方式，通过实现类对象实例化，这叫接口多态

多态的形式：具体类多态，抽象类多态，接口类多态

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

2、接口的成员特点

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

2)构造方法：接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在。

一个类如果没有父类，默认继承自Object类

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

类和接口的关系：

Animal类 

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

Jumpping 接口 

public interface Jumpping {
    public abstract void jump();
}

Cat类继承Animal类实现Jumpping接口

public class Cat extends Animal implements Jumpping{
    public Cat() {
    }

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

    @Override
    public void eat() {
        System.out.println("猫在吃饭");
    }

    @Override
    public  void jump() {
        System.out.println("猫在跳高");
    }
}

测试类 

public class AnimalDemo {
    public static void main(String[] args) {
        Jumpping j=new Cat();
        j.jump();
        System.out.println("---");

        Animal a=new Cat();
        a.setName("加菲猫");
        a.setAge(2);
        System.out.println(a.getName()+"，"+a.getAge());
        a.eat();
//        a.jump();
        System.out.println("----");

//推荐使用具体类子类实现类
        Cat c=new Cat();
        c.setName("加菲");
        c.setAge(2);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

抽象类和接口的区别：