Inheritance in Java

In Java, inheritance is a mechanism where one class acquires the properties and behaviors (methods) of another class. It allows for code reuse and the creation of hierarchical relationships between classes. Inheritance promotes the concept of "is-a" relationships. For example, a Dog class might inherit from an Animal class because a dog "is an" animal.

Basic Syntax of Inheritance:

        
        class Parent {
            // Parent class code
        }

        class Child extends Parent {
            // Child class code
        }
        
        

In this example:

• Parent is the superclass (or base class).
• Child is the subclass (or derived class).
• The subclass Child inherits all accessible fields and methods of the Parent class.

Extending Classes in Java:

In Java, a subclass can extend only one superclass (Java does not support multiple inheritance via classes). When a class extends another, it inherits its non-private fields and methods. You can override methods and add new ones.

Method Overriding:

When a subclass defines a method that already exists in the parent class with the same name and signature, it is called method overriding.

The main reason for method overriding is to provide specific behavior for a method in the subclass that is different from the parent class.

Method Overriding Syntax:

        
        class Parent {
            void display() {
                System.out.println("Parent's display method");
            }
        }

        class Child extends Parent {
                        @Override
            void display() {
                System.out.println("Child's display method");
            }
        }
        
        

In this example:

• The Child class overrides the display() method of the Parent class.
• The @Override annotation indicates that you are overriding a method from the parent class.

Key Points about Method Overriding:

1. Same Method Signature: The method in the subclass must have the same name, return type, and parameters as the method in the parent class.
2. Inheritance Hierarchy: The subclass can override the parent class’s method.
3. Access Modifiers: The access level can be the same or more permissive (e.g., from protected to public) but it cannot be more restrictive.
4. Polymorphism: Method overriding is a key feature for achieving runtime polymorphism in Java.

Example:

        
        class Animal {
            void sound() {
                System.out.println("Animal makes a sound");
            }
        }

        class Dog extends Animal {
                        @Override
            void sound() {
                System.out.println("Dog barks");
            }
        }

        class Main {
            public static void main(String[] args) {
                Animal myAnimal = new Animal(); // Animal reference and object
                Animal myDog = new Dog(); // Animal reference but Dog object

                myAnimal.sound(); // Outputs: Animal makes a sound
                myDog.sound();    // Outputs: Dog barks (due to method overriding)
            }
        }
        
        

Important Concepts in Method Overriding:

1. Dynamic Method Dispatch (Polymorphism): The method that gets called is determined at runtime, not compile time. Even though the reference type is Animal, the method for Dog is invoked because the object is actually of type Dog.
2. The super Keyword: You can call the parent class's overridden method using super.methodName().

        
        class Dog extends Animal {
                        @Override
            void sound() {
                super.sound();  // Call the parent class method
                System.out.println("Dog barks");
            }
        }
        
        

Overriding vs Overloading:

1. Overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass (same method signature).
2. Overloading occurs when multiple methods in the same class have the same name but different parameters (number or type).

Example of Overloading:

        
        class Calculator {
            // Overloaded method to add two integers
            int add(int a, int b) {
                return a + b;
            }

            // Overloaded method to add three integers
            int add(int a, int b, int c) {
                return a + b + c;
            }
        }

        class Main {
            public static void main(String[] args) {
                Calculator calc = new Calculator();
                System.out.println(calc.add(2, 3));      // Calls add(int, int)
                System.out.println(calc.add(1, 2, 3));   // Calls add(int, int, int)
            }
        }
        
        

Final Thoughts:

• Inheritance promotes code reuse and a clear structure.
• Method overriding enables runtime polymorphism, allowing dynamic method calls.
• Java uses single inheritance (one class can inherit from only one other class), but interfaces allow for multiple inheritance of behavior.