All Flashcards
Why is method overriding useful?
Allows a subclass to provide a specific implementation of a method already defined in its superclass.
When should you override a method?
When the subclass needs to behave differently than the superclass for a particular method call.
What happens if a subclass doesn't override a method?
The subclass inherits the superclass's implementation of the method.
Why are Javadoc comments often omitted in overridden methods?
The documentation is inherited from the superclass method.
What is the relationship between inheritance and overriding?
Inheritance provides the method, overriding allows specialized behavior in subclasses.
How does overriding promote polymorphism?
Allows objects of different classes to respond to the same method call in their own way.
What is the role of the @Override annotation?
It signals to the compiler that the method is intended to override a superclass method, catching errors if it doesn't.
Can a subclass override a private method of its superclass?
No, private methods are not accessible to subclasses and therefore cannot be overridden.
What is the difference between overriding and overloading?
Overriding replaces a superclass method, overloading creates a new method with the same name but different parameters.
How does overriding relate to the 'is-a' relationship?
A subclass 'is-a' type of its superclass, and overriding allows it to refine the superclass's behavior.
What is the output of the following code? class Animal { public void makeSound() { System.out.println("Generic animal sound"); } } class Dog extends Animal { @Override public void makeSound() { System.out.println("Woof!"); } } public class Main { public static void main(String[] args) { Animal myAnimal = new Dog(); myAnimal.makeSound(); } }
Woof!
Identify the error in the following code: class Parent { public void display() { System.out.println("Parent"); } } class Child extends Parent { public void show() { System.out.println("Child"); } @Override public void display(int x) { System.out.println("Child display"); } }
The @Override annotation is incorrect. The method display(int x) in the Child class does not override the display() method in the Parent class because they have different signatures. It's an overloaded method, not an overridden one.
What is the output of the following code? class Vehicle { public String getSpeed() { return "60 mph"; } } class Car extends Vehicle { @Override public String getSpeed() { return "100 mph"; } } public class Main { public static void main(String[] args) { Vehicle myVehicle = new Car(); System.out.println(myVehicle.getSpeed()); } }
100 mph
What is the output of the following code? class A { public int getValue() { return 5; } } class B extends A { } public class Main { public static void main(String[] args) { B b = new B(); System.out.println(b.getValue()); } }
5
What is the output of the following code? class Animal { public String speak() { return "Generic sound"; } } class Cat extends Animal { @Override public String speak() { return "Meow"; } } public class Main { public static void main(String[] args) { Animal animal = new Animal(); Cat cat = new Cat(); System.out.println(animal.speak()); System.out.println(cat.speak()); } }
Generic sound Meow
Identify the error in the following code: class Shape { public double area() { return 0; } } class Circle extends Shape { public double area(int radius) { return Math.PI * radius * radius; } }
The area(int radius) method in Circle is overloading, not overriding, the area() method in Shape because the signatures are different. To override, the method signature must be the same, and the @Override annotation is missing.
What is the output of the following code? class Parent { public void printMessage() { System.out.println("Parent message"); } } class Child extends Parent { @Override public void printMessage() { System.out.println("Child message"); } } public class Main { public static void main(String[] args) { Parent obj = new Child(); obj.printMessage(); } }
Child message
What is the output of the following code? class A { public String method() { return "A"; } } class B extends A { @Override public String method() { return super.method() + "B"; } } public class Main { public static void main(String[] args) { B b = new B(); System.out.println(b.method()); } }
AB
Identify the error in the following code: class Animal { public void eat() { System.out.println("Animal eating"); } } class Dog extends Animal { public void Eat() { System.out.println("Dog eating"); } }
The Eat() method in the Dog class is not overriding the eat() method in the Animal class because the method names are case-sensitive and different. It should be eat() to override correctly.
What is the output of the following code? class Vehicle { public String accelerate() { return "Vehicle accelerating"; } } class Car extends Vehicle { @Override public String accelerate() { return "Car accelerating fast"; } } public class Main { public static void main(String[] args) { Vehicle myVehicle = new Car(); System.out.println(myVehicle.accelerate()); } }
Car accelerating fast
What are the differences between method overriding and method overloading?
Overriding: Same method signature in subclass. | Overloading: Same method name, different parameter list in the same class.
What are the differences between inheritance and overriding?
Inheritance: Acquiring properties/methods from a superclass. | Overriding: Modifying the implementation of an inherited method.
What are the differences between using @Override and not using it when overriding a method?
Using @Override: Compiler checks if method is actually overriding. | Not using @Override: No compiler check, potential for errors if not overriding correctly.
What are the differences between overriding a method and creating a new method in a subclass?
Overriding: Changes the behavior of an existing method. | New method: Adds new functionality specific to the subclass.
What are the differences between public and private methods in the context of overriding?
Public methods: Can be inherited and overridden. | Private methods: Cannot be inherited or overridden.
What are the differences between the effect of overriding and not overriding a method on a subclass object?
Overriding: Subclass object uses the overridden method's implementation. | Not overriding: Subclass object uses the superclass's implementation.
What are the differences between the scope of overridden methods vs. overloaded methods?
Overridden methods: Exist in superclass and subclass, same signature. | Overloaded methods: Exist in the same class, different signatures.
What are the differences between late binding and early binding in the context of overriding?
Overriding: Uses late binding (runtime) to determine which method to call. | Overloading: Uses early binding (compile time) to determine which method to call.
What are the differences between the use of super in overriding and not overriding?
Overriding: super can be used to call the superclass's implementation. | Not overriding: super is not relevant as the superclass method is not being redefined.
What are the differences between the purpose of overriding and the purpose of implementing an interface method?
Overriding: To change the behavior of an inherited method. | Implementing: To provide a concrete implementation for an abstract method defined in an interface.