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() 方法，计算出了它们的面积并输出。