What are some real-world examples of method overriding?

Can you give me some real-world examples of method overriding?

Sure! Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. For example, in a class hierarchy of animals, a superclass 'Animal' might have a method 'makeSound()', and subclasses like 'Dog' and 'Cat' can override this method to provide their own sounds.

That's interesting! Can you give me a specific code example?

Absolutely! Here's a simple example in Java:

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

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

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

In this code, both 'Dog' and 'Cat' override the 'makeSound()' method from the 'Animal' class.

What happens if I don't use the @Override annotation?

If you don't use the @Override annotation, the code will still compile and run, but it won't provide compile-time checking. This means if you accidentally change the method signature in the superclass, the subclass method won't override it, and you might not realize it until runtime.

Are there any performance implications of method overriding?

Generally, method overriding does not have significant performance implications. However, it can introduce a slight overhead due to dynamic method dispatch, which is how the Java Virtual Machine determines which method to call at runtime. In most cases, this overhead is negligible compared to the benefits of polymorphism.