An instance method in a subclass with the same signature (name, plus the number and the type of its parameters) and return type as an instance method in the superclass overrides the superclass's method.

The ability of a subclass to override a method allows a class to inherit from a superclass whose behavior is "close enough" and then to modify behavior as needed. The overriding method has the same name, number and type of parameters, and return type as the method that it overrides. An overriding method can also return a subtype of the type returned by the overridden method. This subtype is called a covariant return type.

When overriding a method, you might want to use the @Override annotation that instructs the compiler that you intend to override a method in the superclass. If, for some reason, the compiler detects that the method does not exist in one of the superclasses, then it will generate an error.

If a subclass defines a static method with the same signature as a static method in the superclass, then the method in the subclass hides the one in the superclass.

The distinction between hiding a static method and overriding an instance method has important implications:

• The version of the overridden instance method that gets invoked is the one in the subclass.
• The version of the hidden static method that gets invoked depends on whether it is invoked from the superclass or the subclass.

Consider an example that contains two classes. The first is Animal, which contains one instance method and one static method:

public class Animal {
   public static void testClassMethod() {
      System.out.println("The static method in Animal");
   }
   public void testInstanceMethod() {
      System.out.println("The instance method in Animal");
   }
}

The second class, a subclass of Animal, is called Cat:

public class Cat extends Animal {
   public static void testClassMethod() {
      System.out.println("The static method in Cat");
   }
   public void testInstanceMethod() {
      System.out.println("The instance method in Cat");
   }

   public static void main(String[] args) {
      Cat myCat = new Cat();
      Animal myAnimal = myCat;
      Animal.testClassMethod();
      myAnimal.testInstanceMethod();
   }
}

The Cat class overrides the instance method in Animal and hides the static method in Animal. The main method in this class creates an instance of Cat and invokes testClassMethod() on the class and testInstanceMethod() on the instance.

The output from this program is as follows:

The static method in Animal
The instance method in Cat

As promised, the version of the hidden static method that gets invoked is the one in the superclass, and the version of the overridden instance method that gets invoked is the one in the subclass.

As demonstrated above, in Java, Subclasses of a class can define their own unique behaviors and yet share some of the same functionality of the parent class. This is called "polymorphism". The dictionary definition of polymorphism refers to a principle in biology in which an organism or species can have many different forms or stages. This principle can also be applied to object-oriented programming and languages like the Java language.

Hiding Fields

Within a class, a field that has the same name as a field in the superclass hides the superclass's field, even if their types are different. Within the subclass, the field in the superclass cannot be referenced by its simple name. Instead, the field must be accessed through super, which is covered in the next section. Generally speaking, we don't recommend hiding fields as it makes code difficult to read.

Modifiers

The access specifier for an overriding method can allow more, but not less, access than the overridden method. For example, a protected instance method in the superclass can be made public, but not private, in the subclass.

You will get a compile-time error if you attempt to change an instance method in the superclass to a static method in the subclass, and vice versa.

Questions

1. Consider the following two classes:

public class ClassA {
   public void methodOne(int i) {
   }
   public void methodTwo(int i) {
   }
   public static void methodThree(int i) {
   }
   public static void methodFour(int i) {
   }
}

public class ClassB extends ClassA {
   public static void methodOne(int i) {
   }
   public void methodTwo(int i) {
   }
   public void methodThree(int i) {
   } 
   public static void methodFour(int i) {
   }
}

a. Which method overrides a method in the superclass?
b. Which method hides a method in the superclass?
c. What do the other methods do?