在抽象父类中重写toString（）是个好主意吗？

Question

I have two class like the below, but is it a good idea to explicitly put toString() into abstract parent class or should I just omit it in the parent class and override directly in a child class ?

//Parent class
public abstract class Shape {
    @Override
    public abstract String toString();
}

//Child class
public class Circle extends Shape {
    @Override
    public String toString() {
        return "This is a Circle";
    }
}

Answer 1

Depending on what are you trying to define in the parent class (just the concept, some basic attributes, some common behaviour) you can do multiple things. As @Joakim Danielson said, if you leave it declared as abstract it forces the non-abstract sub-classes to implement it, which may lead to you repeating some similar code in their toString() implementations. In many cases, you want toString() to list the attributes and their values (which may all be in the domain of the parent class, possibly hidden as private ), or to do something like:

//Parent class
public abstract class Shape {
    protected abstract double surface();
    @Override
    public String toString() {
        return "I am a geometric shape and my surface is: " + surface();
    }
}

//Child class
public class Circle extends Shape {
    private double r;
    public Circle(double r) {
        this.r = r;
    }
    @Override
    public String toString() {
        return super.toString() + " and my radius is: " + r;
    }
    @Override
    protected double surface() {
        return r * r * Math.PI;
    }
}

//Main class
class Main {
    public static void main(String[] args) {
        Shape c = new Circle(2.0);
        System.out.println(c.toString());
    }
}

//Output
I am a geometric shape and my surface is: 12.566370614359172 and my radius is: 2.0

in which case you also extend the functionality of the parent class. That way, you can move some of the expected, common behaviour up to the parent class level and it enables you to not implement toString() in classes you don't need it to add any more additional info.

//Child class
public class Square extends Shape {
    private double a;
    public Square(double a) {
        this.a = a;
    }
    @Override
    protected double surface() {
        return a * a;
    }
}

//Main class
class Main {
    public static void main(String[] args) {
        Shape[] shapes = {new Circle(2.0), new Square(3.0)};
        for (Shape shape : shapes)
            System.out.println(shape.toString());
    }
}

//Output
I am a geometric shape and my surface is: 12.566370614359172 and my radius is: 2.0
I am a geometric shape and my surface is: 9.0

Answer 2

When you declare it abstract you force the subclasses of Shape to implement it, otherwise it is optional. So it is a tool to make toString mandatory if you want it to be.

Of course it isn't guaranteed to be implemented in sub-subclasses.