toString method (Java Questions)

How do you override the toString() method in a Java class?

Answer:
To override the `toString()` method in a Java class, you need to provide your own implementation of the `toString()` method that the Java platform calls when it requires a string representation of an object. This method is originally defined in the `Object` class, which is the superclass of all classes in Java. Overriding this method allows you to return a string that represents the state or value of the objects of your class in a meaningful way. The general steps to override the `toString()` method are as follows:
1. Declare a method with the exact signature as `public String toString()`.
2. Implement the method to return a `String` that appropriately represents the object's state.
Here is an example of how to override the `toString()` method in a Java class:
```
public class ExampleClass {
    private int number;
    private String name;

    // Constructor to initialize the object
    public ExampleClass(int number, String name) {
        this.number = number;
        this.name = name;
    }

    // Override the toString() method
    @Override
    public String toString() {
        return "ExampleClass{" +
               "number=" + number +
               ", name='" + name + '\'' +
               '}';
    }
}
```
In this example, the `toString()` method is overridden to return a string representation of `ExampleClass` objects that includes the values of its `number` and `name` fields. The `@Override` annotation is used to indicate that this method is intended to override a method declared in a superclass.
toString() provides a simple conversion of the object to a String.
The format and content of the resulting String is class specific, and (from the perspective of the java.lang.Object contract) there are no guarantees that it will be meaningful.

What is the difference between == and equals in Java?

Answer:
1. == compares object references. It tests if two object references are equal; i.e. if they refer to the same object.
2. equals(Object) tests if this object is "equal to" another one. What "equal to" means depends on how the object's class defines equality.
  The java.lang.Object class defines equals(other) to be this == other, but many classes override this definition.

When do you use the equals() method?

Answer:
When you need to know if the objects themselves (not the references) are equal.

What must you do in order to use the objects as a key in a hashtable?

Answer:
If you do not override the methods of a class, you will not be able to use those objects as keys in a hashtable and you will not get accurate results.

What does the equals() method in the class Object use for comparisons?

Answer:
The equals() method in the class Object uses only the == operator for comparisons.

When should you override the equals method?

Answer:
If you want objects of your class to be used as keys for a hashtable, then you must override equals() so that 2 different instances can be considered the same.

Why do the String and wrapper classes work well as keys in hashtables?

Answer:
The String and wrapper classes work well as keys in hashtables since they override the equals () method.

How would you implement an equals method for comparing private String lastName ?

Answer:

public boolean equals(Object o){
if(o instanceof Student){
 Student other = (Student)o;
   return this.lastName.equals(other.lastName);
 }
 else
   return false;
 }

What happens if the object does not pass the "instanceof" test when attempting to cast one object to another?

Answer:
If the object does not pass the instanceof test, then you will get a runtime ClassCastExceptiion. The "instanceof" operator is used to check if an object is an instance of a particular class or a subclass thereof, or if it implements a specific interface.
When you try to cast an object to another type without checking its actual type using the "instanceof" operator, the Java runtime will attempt to perform the cast. If the object is not an instance of the target type or a compatible type, the Java runtime will throw a ClassCastException, which is a runtime exception.
Here is an example to illustrate this:
```
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

public class Main {
   public static void main(String[] args) {
       Animal myAnimal = new Cat();
       if (myAnimal instanceof Dog) {
           Dog myDog = (Dog) myAnimal; 
           /* This line would throw a ClassCastException 
		   if not protected by the instanceof check */
       } else {
        System.out.println("myAnimal is not an instance of Dog.");
       }
    }
}
```
In this example, myAnimal is an instance of Cat. When checking if myAnimal is an instance of Dog using the "instanceof" operator, the test returns false. As a result, the attempt to cast myAnimal to Dog does not occur, and a ClassCastException is avoided.
However, if you were to remove the "instanceof" check and attempt the cast directly like this:
```
Dog myDog = (Dog) myAnimal;
```
A ClassCastException would be thrown at runtime, as myAnimal is not an instance of Dog or a subclass thereof.

Which three class methods are all public in
```
Class Class<T>
java.lang.Object
java.lang.Class<T>
```
Answer:
1. equals()
2. hashCode()
3. toString()
public int hashCode(): This method returns the hash code value for the object on which this method is invoked.
This method returns the hash code value as an integer and is supported for the benefit of "hashing based collection classes" such as Hashtable, HashMap, and HashSet . This method must be overridden in every class that overrides the equals method.