Java学习笔记------接口

接口

接口就是一种规则,对行为的抽象

定义和使用接口

用关键字interface来定义，public interface 接口名{}

接口不能实例化

接口和类之间是实现关系，通过impls关键字表示

public class 类名 implements 接口名{}

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

注意：

接口和类是实现关系，可以单实现，也可以多实线

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

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

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

练习

代码： 

package com.test.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 abstract void eat();

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

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("狗刨式游泳");

    }

    public String toString() {
        return "Dog{}";
    }
    public void look_home(){
        System.out.println("小狗"+this.getName()+"在看家");
    }
}

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

    public String toString() {
        return "Frog{}";
    }
}

public class Rabbit extends Animal {

    public Rabbit() {
    }

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

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

    public String toString() {
        return "Rabbit{}";
    }
}

public interface Swim {
    public abstract void swim();
}

public class test {
    public static void main(String[] args) {
        Rabbit r=new Rabbit("小白",2);
        System.out.println("兔子"+r.getName()+"年龄为"+r.getAge());
        r.eat();
        Dog d=new Dog("小黑",4);
        System.out.println("狗子"+d.getName()+"年龄为"+d.getAge());
        d.eat();
        d.swim();
        d.look_home();
        Frog f=new Frog("小青",1);
        System.out.println("青蛙"+f.getName()+"年龄为"+f.getAge());
        f.eat();
        f.swim();
    }
}

运行结果：

接口中的成员特点 

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

构造方法：接口中没有

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

接口和类之间的关系

类和类的关系：继承关系，只能单继承，不能多继承，但可以多层继承

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

接口和接口的关系：继承关系，可以单继承，也可以多继承