接口小结

本文写作思路：

一、特点

A：接口用关键字interface表示

       格式：interface 接口名 {}

B：类实现接口用implements表示

      格式：class 类名 implements 接口名 {}

C：接口不能实例化

       如何实现实例化？---------多态

      由此可见：

           A：具体类多态（几乎不用）

           B：抽象类多态（常用）

           C：接口多态（最常用）

D：接口的子类

       A：可以是抽象类，但是意义不大；

       B：可以是具体类，要重写接口中的所有抽象方法（推荐）

//定义动物培训接口interface AnimalTrain {    public abstract void jump();}//抽象类是实现接口abstract class Dogg implements AnimalTrain {}//具体类实现接口class Catt implements AnimalTrain {    public void jump() {        System.out.println("猫可以调高了");    }}public class InterfaceDemo {    /**     * @param args     */    public static void main(String[] args) {        AnimalTrain at = new Catt();        at.jump();    }}

二、接口的成员特点

（1）成员变量

       在接口中的变量只能是常量，并且是静态的。

      默认修饰符：public static final

      建议：自己手动给出

interface Inter {    public int num = 10;    public final int num2 = 20;    public static final int num2 = 30;}//接口名+Impl这种格式是接口的实现类格式class InterImpl implements Inter {}public class InterfaceDemo2 {    /**     * @param args     */    public static void main(String[] args) {        //创建对象        Inter i = new InterImpl();        System.out.println(i.num);//10        System.out.println(i.num2);//20        //无法为最终变量num、num2分配值        /*i.num=100;        i.num2=200;*/        System.out.println(Inter.num);//10        System.out.println(Inter.num2);//20        System.out.println("----------------");    }}

（2）构造方法

       接口没有构造方法

      所有的类都默认继承自一个类：object

      类Object是类层次结构的根类，每个类都使用object作为超类。

interface Inter {    //错误：需要<标识符>    /*public Inter(){}*/}//接口名+Impl这种格式是接口的实现类格式/*class InterImpl implements Inter {    public InterImpl {        super();    }}*///等同于：class InterImpl extends Object implements Inter {    public InterImpl {        super();    }}public class InterfaceDemo2 {    /**     * @param args     */    public static void main(String[] args) {    }}

（3）成员方法

      默认修饰符：public abstract

      建议：自己手动给出

三、类与类、类与接口以及接口与接口的关系

（1）类与类

继承关系，只能单继承，可以多层继承。

（2）类与接口

实现关系，可以单实现，也可以多实现。

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

interface Father {    public abstract void show();}interface Mother {    public abstract void show2();}class son extends Object implements Father,Mother {    public void show(){        System.out.println("show son");    }    public void show2(){        System.out.println("show2 son");    }}public class InterfaceDemo3 {    /**     * 类与接口：可以是单实现，也可以是多实现。     * 并且还可以在继承一个类的同时实现多个接口。     */    public static void main(String[] args) {        //创建对象        Father f= new son();        f.show();        Mother m = new son();        m.show2();    }}

（3）接口与接口

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

四、抽象类和接口的区别

（1）成员区别

抽象类：

      成员变量：可以是变量，也可以是常量。

      构造方法：有

      成员方法：可以抽象，也可以非抽象。

接口：

      成员变量：只可以是常量

      成员方法：只可以抽象

（2）关系区别

     类与类：继承，单继承；

     类与接口：实现，单实现，多实现

     接口与接口：继承，单继承，多继承。

（3）设计理念的不同

抽象类：

       被继承体现的是：“is  a”的关系。抽象类中定义的是该继承体系的共性功能。

接口：

       被实现体现的是：“like  a”的关系，接口中定义的是该继承体系的扩展功能。

五、猫狗案例

//定义跳高接口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 JumpCat extends Cat implements Jumpping {    public JumpCat(){}    public JumpCat(String name,int age){        super(name,age);    }    public void jump(){        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("跳高狗");    }}public class Demo1 {    /**     * 猫狗案例：加入跳高的额外功能     * 分析：     *  从具体到抽象     *      猫：     *          姓名，年龄     *          吃饭，睡觉     *      狗：     *          姓名，年龄     *          吃饭，睡觉     *  由于有共性功能，所以，我们抽取出一个父类；     *  动物：     *      姓名，年龄     *      吃饭（）；     *      睡觉（）{}；     *  猫：继承自动物     *  狗：继承自动物     *     *  跳高的功能是一个新的扩展功能，定义一个接口     *  接口：     *      跳高；     *  部分猫：实现跳高     *  部分狗：实现跳高     *     * 实现：     *  从抽象到具体     *     * 使用：     *  具体类     */    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("加菲猫",5);        System.out.println(jc2.getName()+"-----"+jc2.getAge());        jc2.eat();        jc2.sleep();        jc2.jump();    }}

六、总结：

接口的设计理念是为了代码后期的扩展功能而实现，接口中定义的抽象方法主要是部分类的扩展功能，增添的功能。这也是它和抽象类的不同，抽象类是定义各类的共性特征。