设计接口shape1，定义一个抽象方法display shape

以下是设计接口shape1，定义一个抽象方法display_shape的示例代码：

public interface Shape1 {
    public void displayShape();
}

这个接口包含一个抽象方法displayShape()，任何类实现这个接口必须重写这个方法。这个接口可以用来实现各种形状的类，如圆形、矩形、三角形等，这些类必须实现displayShape()方法来显示形状。

相关问题

定义一个抽象类为形状类Shape，其中包含抽象方法display()，在其子类圆形Circle和长方形Rectangle中实现该抽象方法，分别输出“这是一个圆形”和“这是一个长方形”。编写MainClass，在其main()函数中进行测试。

在Java中，你可以按照以下步骤创建这个抽象类和它的两个子类：

首先，我们定义一个名为`Shape`的抽象类，它有一个抽象方法`display()`：

abstract class Shape {
    abstract void display();
}

然后，我们创建两个实现了`Shape`抽象类的具体子类：`Circle`和`Rectangle`，它们分别覆盖了`display()`方法：

class Circle extends Shape {
    @Override
    public void display() {
        System.out.println("这是一个圆形");
    }
}

class Rectangle extends Shape {
    @Override
    public void display() {
        System.out.println("这是一个长方形");
    }
}

接下来，在`MainClass`中，我们可以创建这两个子类的对象并调用它们的`display()`方法进行测试：

public class MainClass {
    public static void main(String[] args) {
        Shape circle = new Circle(); // 创建一个Circle对象
        circle.display(); // 输出 "这是一个圆形"

        Shape rectangle = new Rectangle(); // 创建一个Rectangle对象
        rectangle.display(); // 输出 "这是一个长方形"
    }
}

在这个例子中，尽管`circle`和`rectangle`都是`Shape`类型的引用，但由于多态性，它们分别调用了各自子类的`display()`方法，展示了多态带来的灵活性。

【实践训练】 1. 定义抽象类 Shape，其中包含抽象方法 double getPeremeterO求周长和 double getArea0求面积。 定义一个矩形类，继承此抽象类，并自行扩充成员变量和方法，定义一个方法 一次直接显示长和宽、周长和面积。 定义一个测试类，测试矩形类。 2. 定义一个接口 CompareObject，具有方法 compareTo0用于比较两个对象。 定义一个类 Position 从 CompareObject 派生而来，有x和y属性表示其坐标， 该类实现 compare To0方法，用于比较两个对象距离原点(0,0)的距离。 定义测试类测试 Position 类的 compareTo0方法。

1.

// Shape.java
public abstract class Shape {
    public abstract double getPerimeter();
    public abstract double getArea();
}

// Rectangle.java
public class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public void display() {
        System.out.println("Length: " + length);
        System.out.println("Width: " + width);
        System.out.println("Perimeter: " + getPerimeter());
        System.out.println("Area: " + getArea());
    }

    @Override
    public double getPerimeter() {
        return 2 * (length + width);
    }

    @Override
    public double getArea() {
        return length * width;
    }
}

// Test.java
public class Test {
    public static void main(String[] args) {
        Rectangle rect = new Rectangle(5, 10);
        rect.display();
    }
}

2.

// CompareObject.java
public interface CompareObject {
    public int compareTo(Object o);
}

// Position.java
public class Position implements CompareObject {
    private int x;
    private int y;

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

    @Override
    public int compareTo(Object o) {
        Position other = (Position) o;
        double distance1 = Math.sqrt(x * x + y * y);
        double distance2 = Math.sqrt(other.x * other.x + other.y * other.y);
        if (distance1 < distance2) {
            return -1;
        } else if (distance1 > distance2) {
            return 1;
        } else {
            return 0;
        }
    }
}

// Test.java
public class Test {
    public static void main(String[] args) {
        Position p1 = new Position(3, 4);
        Position p2 = new Position(5, 12);
        int result = p1.compareTo(p2);
        if (result < 0) {
            System.out.println("p1 is closer to the origin.");
        } else if (result > 0) {
            System.out.println("p2 is closer to the origin.");
        } else {
            System.out.println("p1 and p2 are equidistant from the origin.");
        }
    }
}