为什么要重写子类的toString和equals构造方法

重写子类的toString和equals构造方法是为了实现更准确的对象比较和输出。当子类继承父类时，子类可能会增加自己的属性和方法，这些属性和方法可能会影响对象的比较和输出。通过重写子类的toString和equals构造方法，我们可以确保子类对象的比较和输出包含了子类的属性和方法，并且比较和输出的结果更准确。同时，这也是遵循了面向对象的封装原则，子类应该对自己的属性和方法进行封装，而不应该依赖父类的实现。

相关问题

在“实验4”包中编写“实验2Point”和“实验 2Circle”类的子类“实验4Point” “实验 4.Circle”，并重写其构造方法、equals0方法和 toString0)方法; (2)在实验4”包中编写测试类实验4.Test，并测试上述方法的正确性。●

好的，根据您的要求，我提供以下Java代码示例：

实验2Point类：

public class 实验2Point {
    private int x;
    private int y;

    public 实验2Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    // getters and setters
    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof 实验2Point) {
            实验2Point other = (实验2Point) obj;
            return x == other.x && y == other.y;
        }
        return false;
    }

    @Override
    public String toString() {
        return "(" + x + ", " + y + ")";
    }
}

实验2Circle类：

public class 实验2Circle {
    private 实验2Point center;
    private double radius;

    public 实验2Circle(实验2Point center, double radius) {
        this.center = center;
        this.radius = radius;
    }

    // getters and setters
    public 实验2Point getCenter() {
        return center;
    }

    public void setCenter(实验2Point center) {
        this.center = center;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof 实验2Circle) {
            实验2Circle other = (实验2Circle) obj;
            return center.equals(other.center) && radius == other.radius;
        }
        return false;
    }

    @Override
    public String toString() {
        return "Circle with center " + center.toString() + " and radius " + radius;
    }
}

实验4Point类：

public class 实验4Point extends 实验2Point {
    public 实验4Point(int x, int y) {
        super(x, y);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof 实验4Point) {
            实验4Point other = (实验4Point) obj;
            return getX() == other.getX() && getY() == other.getY();
        }
        return false;
    }

    @Override
    public String toString() {
        return "实验4Point" + super.toString();
    }
}

实验4Circle类：

public class 实验4Circle extends 实验2Circle {
    public 实验4Circle(实验4Point center, double radius) {
        super(center, radius);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof 实验4Circle) {
            实验4Circle other = (实验4Circle) obj;
            return getCenter().equals(other.getCenter()) && getRadius() == other.getRadius();
        }
        return false;
    }

    @Override
    public String toString() {
        return "实验4Circle with center " + getCenter().toString() + " and radius " + getRadius();
    }
}

实验4.Test测试类：

public class 实验4Test {
    public static void main(String[] args) {
        实验2Point p1 = new 实验2Point(1, 2);
        实验2Point p2 = new 实验2Point(1, 2);
        System.out.println(p1.equals(p2)); // expected output: true
        System.out.println(p1.toString()); // expected output: (1, 2)

        实验4Point p3 = new 实验4Point(1, 2);
        实验4Point p4 = new 实验4Point(1, 2);
        System.out.println(p3.equals(p4)); // expected output: true
        System.out.println(p3.toString()); // expected output: 实验4Point(1, 2)

        实验2Circle c1 = new 实验2Circle(new 实验2Point(1, 2), 3);
        实验2Circle c2 = new 实验2Circle(new 实验2Point(1, 2), 3);
        System.out.println(c1.equals(c2)); // expected output: true
        System.out.println(c1.toString()); // expected output: Circle with center (1, 2) and radius 3.0

        实验4Point center = new 实验4Point(1, 2);
        实验4Circle c3 = new 实验4Circle(center, 3);
        实验4Circle c4 = new 实验4Circle(center, 3);
        System.out.println(c3.equals(c4)); // expected output: true
        System.out.println(c3.toString()); // expected output: 实验4Circle with center 实验4Point(1, 2) and radius 3.0
    }
}

设计动物类Animal，要求如下：(1)protected的成员变量包括名称name、年龄age、性别sex、腿的数量legNum、体重weight；(2)定义空构造方法，定义能够初始化所有成员变量的构造方法；(3)省略setter和getter方法；(4)功能方法包括：protected方法eating(String food)；重写Object类的toString()方法返回Animal对象的所有成员变量。 Pig类继承了Animal，Pig类的要求如下：(1)成员变量有长度length，高度height和颜色color；(2)定义构造方法能够初始化所有成员变量；(3)省略setter和getter方法；(4)功能方法包括：重写toString()方法返回Pig对象的所有成员变量；重写eating(String food)方法，food只能是Pig可以吃的食物；定义成员方法walking()表示Pig可以行走。 Chicken类继承Animal，Chicken类的要求如下：(1)成员变量有鸡冠颜色combColor；(2)定义构造方法能够初始化所有成员变量；(3)省略setter和getter方法；(4)功能方法有：重写toString()方法返回Chicken对象的所有成员变量，重写eating(String food)方法输出吃的动作和食物，定义成员方法flying()表示鸡可以飞。 定义测试类，完成如下任务：(1)创建猪对象佩奇peiqi，输出peiqi的基本信息，给peiqi喂白菜吃，peiqi在行走；(2)创建鸡对象杏花鸡xhj，输出xhj的基本信息，给xhj喂虫子，xhj在飞用java

好的，下面是使用Java语言实现的示例代码，来回答你的问题：

Animal类：

public class Animal {
    protected String name;
    protected int age;
    protected String sex;
    protected int legNum;
    protected double weight;

    public Animal() {
    }

    public Animal(String name, int age, String sex, int legNum, double weight) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.legNum = legNum;
        this.weight = weight;
    }

    protected void eating(String food) {
        System.out.println(name + " is eating " + food);
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", legNum=" + legNum +
                ", weight=" + weight +
                '}';
    }
}

Pig类：

public class Pig extends Animal {
    private double length;
    private double height;
    private String color;

    public Pig(String name, int age, String sex, int legNum, double weight, double length, double height, String color) {
        super(name, age, sex, legNum, weight);
        this.length = length;
        this.height = height;
        this.color = color;
    }

    @Override
    public String toString() {
        return "Pig{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", legNum=" + legNum +
                ", weight=" + weight +
                ", length=" + length +
                ", height=" + height +
                ", color='" + color + '\'' +
                '}';
    }

    @Override
    protected void eating(String food) {
        if (food.equals("cabbage")) {
            System.out.println(name + " is eating " + food);
        } else {
            System.out.println(name + " cannot eat " + food);
        }
    }

    public void walking() {
        System.out.println(name + " is walking");
    }
}

Chicken类：

public class Chicken extends Animal {
    private String combColor;

    public Chicken(String name, int age, String sex, int legNum, double weight, String combColor) {
        super(name, age, sex, legNum, weight);
        this.combColor = combColor;
    }

    @Override
    public String toString() {
        return "Chicken{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", legNum=" + legNum +
                ", weight=" + weight +
                ", combColor='" + combColor + '\'' +
                '}';
    }

    @Override
    protected void eating(String food) {
        System.out.println(name + " is pecking " + food);
    }

    public void flying() {
        System.out.println(name + " is flying");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        // 创建一只佩奇猪
        Pig peiqi = new Pig("Peiqi", 3, "Female", 4, 80.0, 1.5, 0.8, "Pink");
        System.out.println(peiqi.toString());
        peiqi.eating("cabbage");
        peiqi.walking();

        // 创建一只杏花鸡
        Chicken xhj = new Chicken("Xinghua", 1, "Male", 2, 1.0, "Red");
        System.out.println(xhj.toString());
        xhj.eating("worms");
        xhj.flying();
    }
}

在上面的代码中，我们首先定义了一个名为“Animal”的父类，它有一些protected成员变量如名称name、年龄age、性别sex、腿的数量legNum、体重weight等，还有一个空构造方法和一个能够初始化所有成员变量的构造方法。我们省略了getter和setter方法，并定义了一个名为“eating”的protected方法来表示动物吃东西的行为。我们还重写了Object类的toString()方法，以便在测试时打印出Animal对象的所有成员变量。

接下来，我们创建了一个名为“Pig”的子类，它继承了父类“Animal”的所有属性和方法，并新增了一些成员变量如长度length、高度height和颜色color等。我们使用构造函数来初始化父类变量和新增变量，并重写了父类的“eating”方法和新增了一个名为“walking”的方法来表示猪的行走行为。

然后，我们创建了一个名为“Chicken”的子类，它继承了父类“Animal”的所有属性和方法，并新增了一个成员变量如鸡冠颜色combColor。我们使用构造函数来初始化父类变量和新增变量，并重写了父类的“eating”方法和新增了一个名为“flying”的方法来表示鸡的飞行行为。

最后，我们创建了一个名为“Test”的测试类，在其中分别创建了一只猪对象和一只鸡对象，并测试了它们的基本信息以及相应的行为。