5.3. Special Methods¶

5.3.1. toString¶

The toString method returns a string representation of a class. Calling toString on a class that you’ve written will result in something like this:

1
2

Student person = new Student("Violet");
System.out.println(person.toString());

org.launchcode.java.demos.classes2.Student@61bbe9ba

Here, we called toString on a Student object. The default toString implementation is generally not very useful. Most of the time, you’ll want to write your own toString method to override the default and provide better results.

Here’s how we might do it for Student to produce a much more friendly message:

1
2
3
4
5
6

public String toString() {
   return name + " (Credits: " + numberOfCredits + ", GPA: " + gpa + ")";
}

Student person = new Student("Violet");
System.out.println(person.toString());

Violet (Credits: 0, GPA: 0.0)

In the example, we define the toString method to return a string that reports the class fields name, numberOfCredits, and gpa in a clear manner.

Note that toString is often implicitly called for you. For example, the output above could have been generated by the following code, which calls toString on person within System.out.println.

1
2

Student person = new Student("Violet");
System.out.println(person);

5.3.2. equals¶

Suppose we have two objects of type Student, say student1 and student2, and we want to determine if they are equal. If we try to compare them using ==, we will likely get a result we did not expect. This is because student1 and student2 are reference variables, which means they hold a reference to, or the address of, the actual Student objects. student1 and student2 evaluate as equal only when they have the same memory address.

To state that again: student1 and student2 will be equal (==) only when they refer to, or point at, the exact same object. Consider the example below, which creates two Student objects:

1
2
3
4
5
6

Student student1 = new Student("Maria", 1234);
Student student2 = new Student("Maria", 1234);

System.out.println(student1.name + ", " + student1.id + ": " + student1);
System.out.println(student2.name + ", " + student2.id + ": " + student2);
System.out.println(student1 == student2);

Maria, 1234: org.launchcode.java.demos.classes2.Student@3e3abc88
Maria, 1234: org.launchcode.java.demos.classes2.Student@6ce253f1
false

Even though the objects have the exact same keys and values, student1 and student2 point to different memory locations. Therefore, the == check returns false.

This is not usually how we want to compare objects. For example, we might want to consider two Student objects equal if they have the same name, email, or student ID.

The equals() method determines if one object is equal to another in this sense. We introduced the method when discussing strings, but it also applies to all other classes.

The code below shows how to use equals() to compare two students. Note that they have different names but the same student ID, indicating they are actually the same person.

1
2
3
4
5
6
7

Student bono1 = new Student("Paul David Hewson", 4);
Student bono2 = new Student("Bono", 4);

if (bono1.equals(bono2)) {
   System.out.println(bono1.getName() +
      " is the same as " + bono2.getName());
}

If we don’t provide our own equals() method, the default option only considers two objects equal if they are the exact same object, which means they point to the same memory address. This is identical to the behavior we see when using the == operator: bono1 == bono2.

In the example above we created two different Student objects, so the expression bono1.equals(bono2) evaluates to false. In order to compare two objects based on their properties, rather than their memory references, we need to define our own equals() method.

The difference between the comparison carried out by the default equals() method (and by the == operator), and how we would like to compare our classes, is the difference between identity and equality.

1. Two objects are identical if they both point to the same memory address. In essence, they are the same object. If object1 and object2 are identical, then changing one property value in object1 also changes that value for object2.
2. Two objects are equal if the values they store are the same at the time of comparison. student1 and student2 point to different memory addresses, but their values are all the same. Thus, we can consider them equal, even though they are not identical.

The default equals() method and the == operator test for identity, whereas we want to test for equality instead. We can do so by overriding the equals() method. We will discuss overriding in more detail later, but for now just recognize that it involves defining different behavior for an existing method.

Two things can be considered equal even if they do NOT have all the same values. In the case of the Student class, we might specify that two Student objects are equal if they have the same ID numbers. We would then write a new method definition for equals() as follows:

1
2
3
4

public boolean equals(Object toBeCompared) {
   Student theStudent = (Student) toBeCompared;
   return theStudent.getStudentId() == getStudentId();
}

Now if we evaluate bono1.equals(bono2) we will get a result of true, since the student IDs match.

One catch of working with equals() is that its input parameter must be of type Object, even if we’re working in a class like Student. The reason why will become more clear in the next lesson, when we introduce the Object class. For now, the practical implication is that we must convert, or cast, the input toBeCompared to be of type Student with the syntax (Student) toBeCompared. Then we compare the converted student’s ID (bono2.id) to that of the current student (bono1.id).

Here’s a visualization of the concepts of equality and identity:

Equality

When you test for equality, you look at two different objects and compare some aspect of them to each other.

Identity

When you test for identity, you look at two variables to see if they reference the exact same object.

1
2
3
4
5
6
7
8
9

public boolean equals(Object toBeCompared) {

   if (toBeCompared.getClass() != getClass()) {
      return false;
   }

   Student theStudent = (Student) toBeCompared;
   return theStudent.getStudentId() == getStudentId();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public boolean equals(Object toBeCompared) {

   if (toBeCompared == null) {
      return false;
   }

   if (toBeCompared.getClass() != getClass()) {
      return false;
   }

   Student theStudent = (Student) toBeCompared;
   return theStudent.getStudentId() == getStudentId();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public boolean equals(Object toBeCompared) {

   if (toBeCompared == this) {
      return true;
   }

   if (toBeCompared == null) {
      return false;
   }

   if (toBeCompared.getClass() != getClass()) {
      return false;
   }

   Student theStudent = (Student) toBeCompared;
   return theStudent.getStudentId() == getStudentId();
}

5.3.3. References¶

1. How to Implement Java’s equals Method Correctly
2. How to Implement Java’s hashCode Correctly

5.3.4. Check Your Understanding¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class Pet {

   private String name;

   Pet(String name) {
      this.name = name;
   }

   public String getName() {
      return name;
   }
}

String firstPet = "Fluffy";
Pet secondPet = new Pet("Fluffy");
Pet thirdPet = new Pet("Fluffy");

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public boolean equals(Object petToCheck) {

   if (petToCheck == this) {
      return true;
   }

   if (petToCheck == null) {
      return false;
   }

   if (petToCheck.getClass() != getClass()) {
      return false;
   }

   Pet thePet = (Pet) petToCheck;
   return thePet.getName() == getName();
}