利用接口继承完成对生物、动物、人三个接口的定义。其中生物接口定义呼吸抽象方法；动物接口除具备生物接口特征之外，还定义了吃饭和睡觉两个抽象方法；人接口除具备动物接口特征外，还定义了思维和学习两个抽象方法。定义一个学生类实现上述人接口。

// 生物接口
interface Biology {
    void breathe();
}

// 动物接口
interface Animal extends Biology {
    void eat();
    void sleep();
}

// 人接口
interface Person extends Animal {
    void think();
    void learn();
}

// 学生类实现人接口
class Student implements Person {
    @Override
    public void breathe() {
        System.out.println("学生在呼吸");
    }

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

    @Override
    public void sleep() {
        System.out.println("学生在睡觉");
    }

    @Override
    public void think() {
        System.out.println("学生在思考");
    }

    @Override
    public void learn() {
        System.out.println("学生在学习");
    }
}

相关问题

抽象方法能被子接口继承吗？

可以，抽象方法可以被子接口继承。子接口可以继承父接口中的所有成员（包括方法、常量和嵌套类型），并且可以在子接口中添加新的成员。当子接口继承一个抽象方法时，它可以选择实现该方法，也可以将其进一步声明为抽象方法。下面是一个简单的例子：

public interface A {
    void foo();
}

public interface B extends A {
    void bar();
}

public interface C extends B {
    // 继承A接口中的抽象方法foo()
    // 声明新的抽象方法baz()
    void baz();
}

在这个例子中，接口A中定义了一个抽象方法foo()，接口B继承了接口A，并添加了一个新的方法bar()。接口C继承了接口B，并继承了接口A中的方法foo()，并声明了一个新的抽象方法baz()。因此，C接口中包含了三个方法：foo()、bar()和baz()，其中foo()和baz()是抽象方法，需要在实现C接口的类中进行实现。

1关：继承及方法重写；第2关 抽象类；第3关 接口及实现类定义

第一关：继承及方法重写

在面向对象编程中，继承是指一个类可以继承另一个类的属性和方法。被继承的类称为父类或基类，继承的类称为子类或派生类。

方法重写是指在子类中定义与父类中同名、同参数列表的方法，从而覆盖父类中的方法。重写后的方法可以改变父类方法的实现，但不能改变其参数列表和返回值类型。

代码示例：

class Animal {
    public void move() {
        System.out.println("动物在移动");
    }
}

class Dog extends Animal {
    public void move() {
        System.out.println("狗在跑");
    }
}

public class Test {
    public static void main(String args[]) {
        Animal a = new Animal();
        Animal b = new Dog();
        a.move();//输出：动物在移动
        b.move();//输出：狗在跑
    }
}

在上述代码中，Animal 是父类，Dog 是子类。子类 Dog 继承了父类 Animal 的属性和方法，并且重写了父类中的 move() 方法。在 main() 方法中，分别创建了父类对象 a 和子类对象 b，调用它们的 move() 方法，输出了不同的信息。

第二关：抽象类

抽象类是一种特殊的类，它不能被实例化，只能被继承。抽象类中可以定义抽象方法，抽象方法只有声明，没有实现，需要在子类中实现。

抽象类通常用于定义一些基础的方法和属性，而具体实现则由子类来完成。抽象类可以被用来约束子类的行为，保证子类实现了父类中定义的抽象方法。

代码示例：

abstract class Shape {
    protected int x;
    protected int y;

    public void setDimension(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public abstract double getArea();
}

class Rectangle extends Shape {
    public double getArea() {
        return x * y;
    }
}

class Circle extends Shape {
    public double getArea() {
        return Math.PI * x * x;
    }
}

public class Test {
    public static void main(String args[]) {
        Shape s1 = new Rectangle();
        Shape s2 = new Circle();
        s1.setDimension(10, 20);
        s2.setDimension(30, 0);
        System.out.println("矩形的面积为：" + s1.getArea());
        System.out.println("圆形的面积为：" + s2.getArea());
    }
}

在上述代码中，Shape 是抽象类，它定义了一个抽象方法 getArea()，Rectangle 和 Circle 是 Shape 的子类，它们实现了抽象方法 getArea()。在 main() 方法中，分别创建了 Rectangle 和 Circle 的对象，并且调用它们的 setDimension() 和 getArea() 方法，计算出了它们的面积并输出。

第三关：接口及实现类定义

接口是一种特殊的类，它只定义了方法签名，没有对方法的实现进行定义。接口可以被类实现，实现类需要实现接口中定义的所有方法。

接口通常用于定义一些共同的行为，保证实现类都能够按照接口定义的方式进行行为。接口可以被用来约束实现类的行为，保证实现类实现了接口中定义的所有方法。

代码示例：

interface Shape {
    void setDimension(int x, int y);
    double getArea();
}

class Rectangle implements Shape {
    private int x;
    private int y;

    public void setDimension(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public double getArea() {
        return x * y;
    }
}

class Circle implements Shape {
    private int x;

    public void setDimension(int x, int y) {
        this.x = x;
    }

    public double getArea() {
        return Math.PI * x * x;
    }
}

public class Test {
    public static void main(String args[]) {
        Shape s1 = new Rectangle();
        Shape s2 = new Circle();
        s1.setDimension(10, 20);
        s2.setDimension(30, 0);
        System.out.println("矩形的面积为：" + s1.getArea());
        System.out.println("圆形的面积为：" + s2.getArea());
    }
}

在上述代码中，Shape 是接口，它定义了两个方法 setDimension() 和 getArea()，Rectangle 和 Circle 分别实现了接口 Shape，并且实现了接口中定义的两个方法。在 main() 方法中，分别创建了 Rectangle 和 Circle 的对象，并且调用它们的 setDimension() 和 getArea() 方法，计算出了它们的面积并输出。