2019-05-28 java学习日记

接口(interface)

接口的概述

从狭义的角度讲就是指java中的interface
从广义的角度讲就是对外提供规则的都是接口

接口的特点

1，接口用关键字interface表示：
　　interface 接口名 {}

2，类实现接口用implements表示：
　　class 类名 implements 接口名 {}

3，接口不能被实例化，因为调用抽象方法没有意义，
　　可以按照多态的方式实例化

接口的子类

1，可以是抽象类。但是意义不大
2，可以是具体类。要重写接口中的所有抽象方法

注：接口中的方法都是抽象的

接口成员特点：

成员变量：

1，成员变量只能是常量，并且是静态且公共的
2，默认修饰符：public static final，三个关键字可以互相交换位置
3，构造方法：接口没有构造方法

成员方法：

1，只能是抽象方法
2，默认修饰符：public abstract

注：一个类不写继承任何类,默认继承Object类

继承格式：

class Demo /*extends Object*/ implements Inter { }

类与类、类与接口、接口与接口的关系：

类与类：

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

类与接口：

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

如：

class Demo extends Object implements InterA,InterB {}

注意：

class Demo extends Object implements InterA,implement InterB {}

这样是非法的，不被允许的

接口与接口：

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

抽象类和接口的区别

成员区别

抽象类：

成员变量：可以变了，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象

接口：

成员变量：只可以常量

成员方法：只可以抽象

关系区别

类与类

继承，单继承

类与接口

实现，单实现，多实现

接口与接口

继承，单继承，多继承

设计理念区别

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

class Test_Animal {
    public static void main(String[] args){
        Cat c = new Cat("小白",8);
        c.eat();
        c.sleep();

        JumpCat js = new  JumpCat("跳高猫",9);
        jc.eat();
        jc.sleep();
        jc.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 void setName(String name){        //设置姓名 
        this.name = name;
    }

    public String getName(){                      // 获取姓名 
        return name;
    }

    public void setAge(int age){                 //设置年龄 
        this.age = age;
    }

    public String getAge(){                      //获取年龄 
        return age;
    }

    public abstract void eat();                 //吃饭 

    public abstract void sleep();              //睡觉 


}
interface Jumping {                              //跳高接口
    public void jump(){};
}
class Cat extends Animal
{
    public Cat(){}                                  //空参构造

    public Cat(String name,int age){       //有参构造 
        super(name,age);
    }

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

}

class JumpCat extends Cat implements Jumping {
    public void jump(){

    public JumpCat(){}                                   //空参构造 

    public JumpCat(String name,int age){        //有参构造 
        super(name,age);
    }
    System.out.println("猫跳高");
    }
}