Method overriding

Hello there, young Java enthusiast! Today, we’re going to embark on an exciting journey into the world of programming and learn about a fascinating concept called “Method Overriding.” Don’t worry if it sounds a bit tricky at first – I’ll break it down into bite-sized pieces with simple examples.

What is Method Overriding?

In Java, method overriding is a way for a class to provide a specific implementation for a method that is already defined in its superclass (parent class). It allows a subclass (child class) to provide a specialized version of a method that is already present in its superclass.

Imagine you have a robot superclass with a general method called move(), and then you have specific robot subclasses like DancingRobot and FlyingRobot that want to move in their unique ways. Method overriding allows each subclass to have its own version of the move() method.

Let’s Dive into Code

The Superclass (Parent Class)

// The Robot class is our superclass
class Robot {
    // The move method in the superclass
    void move() {
        System.out.println("The robot is moving.");
    }
}

In the above code, we have a simple Robot class with a move() method that prints a basic message.

The Subclass (Child Class)

// The DancingRobot class is a subclass of Robot
class DancingRobot extends Robot {
    // Overriding the move method in the subclass
    @Override
    void move() {
        System.out.println("The dancing robot is grooving to the beat!");
    }
}

Now, we’ve created a DancingRobot class that extends (inherits from) the Robot class. Notice the @Override annotation – it tells Java that we’re intentionally overriding the move() method from the superclass.

Putting it All Together

public class Main {
    public static void main(String[] args) {
        // Create a DancingRobot object
        DancingRobot myRobot = new DancingRobot();

        // Call the move method on the DancingRobot
        myRobot.move();
    }
}

In the Main class, we create an instance of DancingRobot and call its move() method. Here’s the magic of method overriding – even though move() is defined in the superclass (Robot), the version in the subclass (DancingRobot) gets executed.

Output:

The dancing robot is grooving to the beat!

Recap

In simple terms, method overriding is like having a basic set of rules in the superclass, and each subclass can customize or override those rules to suit its specific needs. It’s a powerful way for classes to share a common interface while providing their unique behaviors.

Keep exploring the exciting world of Java programming, and remember – every robot can dance to its own tune!