接口的概述，使用以及其与抽象类，类的区别和用法

接口的特点

A:接口用关键字interface表示 
        interface 接口名 {}
B:类实现接口用implements表示
        class 类名 implements 接口名 {}
C:接口不能实例化
        那么，接口如何实例化呢?
        按照多态的方式来实例化。    
D:接口的子类
        a:可以是抽象类。但是意义不大。
        b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
 由此可见：
    A:具体类多态(几乎没有)
    B:抽象类多态(常用)
    C:接口多态(最常用)

//定义动物培训接口
interface AnimalTrain {
    public abstract void jump();
}

//抽象类实现接口
abstract class Dog implements AnimalTrain {
    //这里不需要重写接口中的jump方法，因为这是一个抽象类
}

//具体类实现接口
class Cat implements AnimalTrain {
    //具体类继承接口，然后实现这个抽象方法
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

class InterfaceDemo {
    public static void main(String[] args) {
        //AnimalTrain是抽象的; 无法实例化
        //AnimalTrain at = new AnimalTrain();
        //at.jump();
        //这里采用多态的方法，实例化这个接口，然后调用其已经被重写过的方法
        AnimalTrain at = new Cat();
        at.jump();
    }
}

接口的成员特点

    成员变量；只能是常量，并且是静态的。
            默认修饰符：public static final
            建议：自己手动给出。
    构造方法：接口没有构造方法。
    成员方法：只能是抽象方法。
            默认修饰符：public abstract
            建议：自己手动给出。

抽象类和接口的区别：

A:成员区别
    抽象类：
        成员变量：可以变量，也可以常量
        构造方法：有
        成员方法：可以抽象，也可以非抽象
    接口：
        成员变量：只可以常量
        成员方法：只可以抽象

B:关系区别
    类与类
        继承，单继承
    类与接口
        实现，单实现，多实现
    接口与接口
        继承，单继承，多继承

C:设计理念区别
    抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
    接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

类与类 接口与类 接口与接口之间的关系

类与类：
    继承关系,只能单继承,可以多层继承。
类与接口：
    实现关系,可以单实现,也可以多实现。
    并且还可以在继承一个类的同时实现多个接口。
接口与接口：
    继承关系,可以单继承,也可以多继承。

interface Father {
    public abstract void show();
}

interface Mother {
    public abstract void show2();
}

interface Sister extends Father,Mother {

}

//class Son implements Father,Mother //多实现
class Son extends Object implements Father,Mother {
    public void show() {
        System.out.println("show son");
    }

    public void show2() {
        System.out.println("show2 son");
    }
}

class InterfaceDemo3 {
    public static void main(String[] args) {
        //创建对象
        Father f = new Son();
        f.show();
        //f.show2(); //报错

        Mother m = new Son();
        //m.show(); //报错
        m.show2();
    }
}

例1

/*
    猫狗案例,加入跳高的额外功能

    分析：从具体到抽象
        猫：
            姓名,年龄
            吃饭，睡觉
        狗：
            姓名,年龄
            吃饭，睡觉

        由于有共性功能，所以，我们抽取出一个父类：
        动物：
            姓名,年龄
            吃饭();
            睡觉(){}

        猫：继承自动物
        狗：继承自动物

        跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
        接口：
            跳高

        部分猫：实现跳高
        部分狗：实现跳高
    实现；
        从抽象到具体

    使用：
        使用具体类
*/
//定义跳高接口
interface Jumpping {
    //跳高功能
    public abstract void jump();
}

//定义抽象类
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 void sleep() {
        System.out.println("睡觉觉了");
    }
}

//具体猫类
class Cat extends Animal {
    public Cat(){}

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

    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//具体狗类
class Dog extends Animal {
    public Dog(){}

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

    public void eat() {
        System.out.println("狗吃肉");
    }
}

//有跳高功能的猫

//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
    public JumpDog() {}

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

    public void jump() {
        System.out.println("跳高狗");
    }
}

class InterfaceTest {
    public static void main(String[] args) {
        //定义跳高猫并测试
        JumpCat jc = new JumpCat();
        jc.setName("哆啦A梦");
        jc.setAge(3);
        System.out.println(jc.getName()+"---"+jc.getAge());
        jc.eat();
        jc.sleep();
        jc.jump();
        System.out.println("-----------------");

        JumpCat jc2 = new JumpCat("加菲猫",2);
        System.out.println(jc2.getName()+"---"+jc2.getAge());
        jc2.eat();
        jc2.sleep();
        jc2.jump();

        //定义跳高狗并进行测试的事情自己完成。
    }
}

例2

/*
    老师和学生案例,加入抽烟的额外功能

    分析：从具体到抽象
        老师：姓名，年龄，吃饭，睡觉
        学生：姓名，年龄，吃饭，睡觉

        由于有共性功能，我们提取出一个父类，人类。

        人类：
            姓名，年龄
            吃饭();
            睡觉(){}

        抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口

        抽烟接口。

        部分老师抽烟：实现抽烟接口
        部分学生抽烟：实现抽烟接口

    实现：从抽象到具体

    使用：具体
*/
//定义抽烟接口
interface Smoking {
    //抽烟的抽象方法
    public abstract void smoke();
}

//定义抽象人类
abstract class Person {
    //姓名
    private String name;
    //年龄
    private int age;

    public Person() {}

    public Person(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 void sleep() {
        System.out.println("睡觉觉了");
    }
}

//具体老师类
class Teacher extends Person {
    public Teacher() {}

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

    public void eat() {
        System.out.println("吃大白菜");
    }
}

//具体学生类
class Student extends Person {
    public Student() {}

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

    public void eat() {
        System.out.println("吃红烧肉");
    }
}

//抽烟的老师
class SmokingTeacher extends Teacher implements Smoking {
    public SmokingTeacher() {}

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

    public void smoke() {
        System.out.println("抽烟的老师");
    }
}

//抽烟的学生
class SmokingStudent extends Student implements Smoking {
    public SmokingStudent() {}

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

    public void smoke() {
        System.out.println("抽烟的学生");
    }
}

class InterfaceTest2 {
    public static void main(String[] args) {
        //测试学生
        SmokingStudent ss = new SmokingStudent();
        ss.setName("林青霞");
        ss.setAge(27);
        System.out.println(ss.getName()+"---"+ss.getAge());
        ss.eat();
        ss.sleep();
        ss.smoke();
        System.out.println("-------------------");

        SmokingStudent ss2 = new SmokingStudent("刘意",30);
        System.out.println(ss2.getName()+"---"+ss2.getAge());
        ss2.eat();
        ss2.sleep();
        ss2.smoke();

        //测试老师留给自己练习
    }
}