How to Override tostring() method in Java?

The toString() function of any Java object returns a string representation of the object. By default, this function produces a string that contains the class name of the object, a "@" sign, and its hexadecimal hash code. However, there are situations when you would want to provide the object a more useful string representation.

Why Override the toString() Method?

The toString() function of any Java object returns a string representation of the object. This method typically produces a string that includes the class name of the object, a "@" sign, and the hash code of the object in hexadecimal format. This default representation, meanwhile, might not always be helpful.

Consider a Person class, for instance, which has the fields name and age. The toString() method's default output looks like this if you try to print an instance of this class:

It's difficult to determine what the object represents because this string doesn't provide any information about the person's name or age. One can override the toString() method & define a custom string representation to give the Person object a more meaningful representation.

Best Practices for Overriding the toString() Method

Here are some best practices to keep in mind when overriding the toString() method in Java:

Fill out the string representation with all pertinent data. Make sure to include all the data that is pertinent to your application because the toString() method's goal is to create a meaningful representation of the object.
Stick to a standard format. For all objects belonging to the same class, use the same format. It will be simpler to compare and comprehend the objects as a result.
Use complex things with caution. A string representation shouldn't be generated in an indefinite loop if your class has fields that are complicated objects. Either leave these attributes out of the string representation or give the complex object its own toString() method.
When troubleshooting, stay away from the toString() method. Although the toString() method can be helpful for debugging, this is not its intended application. Instead, make use of a debugger or logging framework.
Do not depend on the default configuration. Don't rely on the toString() method's default implementation to give your objects a meaningful string representation because it is not very useful.

We can make meaningful and reliable string representations of your objects in Java by adhering to certain best practises.

Here's the full Person class with the overridden toString() method:

Person.java

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        System.out.println(person);
    }
}

Output:

Person{name='Alice', age=25}

Using the toString() function that we've overridden in the Person class, we've produced a Person object in this example with the name "Alice" and the age 25. The toString() method's custom string representation for the Person object is displayed in the output.

Overriding the toString() method in Java is a simple but powerful way to provide a meaningful string representation of your objects. By following the best practices outlined in in this section, we had generated consistent string representations that are easy to read and comprehend in the code. Recall to adopt a consistent format, be cautious with complex objects, and remember to include all pertinent information in the string representation. These principles will help you develop a toString() method that accurately and succinctly represents your objects.

Next TopicInserting a Node in a Doubly Linked List in Java

← prev next →