11.4. Object Class and Method Overriding (Java-Specific)

All classes in Java inherit from the Object class by default. Key methods:

• toString()
• equals()
• hashCode()

In Java, every class that you create automatically inherits from a class called Object. This is a fundamental concept because it means that all objects derived from your classes will have certain basic methods available to them. The three key methods mentioned here are:

• toString(): This method is used to get a string representation of an object. By default, it returns the class name followed by the object's hash code, but you can override it to return a more meaningful representation of the object’s state.
• equals(): This method checks whether two objects are equivalent. By default, it compares the memory addresses of the two objects, but you can override it to compare the actual content of objects.
• hashCode(): This method returns an integer representation of the object, which is used in hashing collections like HashMap. Override this method in conjunction with equals() to ensure that two equal objects have the same hash code.

Think of the Object class as a base membership at a gym. Everyone who registers gets the same basic membership benefits—like access to ground rules for behavior and identification. Each member can customize their experience (like through personal training or specialized classes), just as each class can override methods like toString() or equals() to provide unique functionalities.

Method Overriding allows a subclass to provide a specific implementation of a method already defined in its superclass.

Method overriding is an essential aspect of polymorphism, one of the pillars of object-oriented programming. When a subclass has a method with the same name and parameters as a method in its superclass, it can provide its own implementation of that method. This means that the subclass's method will be invoked instead of the superclass's version when called on a subclass object. It's important to note that this doesn't change the superclass version, but rather provides a new behavior for the subclass. For example, if we have a Animal class with a method sound(), we could create a subclass Dog that overrides this method to bark. This way, calling sound() on a Dog object will produce a sound specific to the Dog, while still maintaining an Animal reference.

Imagine a musician (the superclass) who has a basic skill of playing an instrument (method). Each musician may have their own style of playing that instrument (subclass). For instance, a guitarist may play a rock song completely differently than a classical guitarist. In programming terms, both play the same instrument (class), but they override the way it is played (method), providing their unique interpretation.

--