0
Jump into concepts and practice - no test required
Recommended
Abstract methods let you define a method without giving its details. This means subclasses must provide their own version of the method.
abstract class ClassName { abstract returnType methodName(parameters); }
The class containing an abstract method must be declared abstract.
Abstract methods have no body (no curly braces, just a semicolon).
abstract class Animal { abstract void makeSound(); }
abstract class Shape { abstract double area(); }
abstract class Vehicle { abstract void startEngine(); } class Car extends Vehicle { @Override void startEngine() { System.out.println("Car engine started"); } }
This program shows an abstract class Animal with an abstract method makeSound. Dog and Cat classes provide their own sounds. The sleep method is shared.
abstract class Animal { abstract void makeSound(); void sleep() { System.out.println("Animal is sleeping"); } } class Dog extends Animal { @Override void makeSound() { System.out.println("Dog barks"); } } class Cat extends Animal { @Override void makeSound() { System.out.println("Cat meows"); } } public class Main { public static void main(String[] args) { Animal dog = new Dog(); Animal cat = new Cat(); dog.makeSound(); dog.sleep(); cat.makeSound(); cat.sleep(); } }
Time complexity: Abstract methods themselves do not affect time complexity; it depends on the subclass implementation.
Space complexity: No extra space is used by abstract methods alone.
Common mistake: Forgetting to implement all abstract methods in subclasses causes compile errors.
Use abstract methods when you want to force subclasses to provide specific behavior, unlike normal methods that can have default behavior.
Abstract methods have no body and must be implemented by subclasses.
Classes with abstract methods must be declared abstract.
Abstract methods help design flexible and reusable code by defining a contract for subclasses.
abstract methods in Java is correct?abstract, have no body, and specify the return type and method name.abstract after void. abstract public void display() {} incorrectly provides a method body ({}). void abstract display(); misses the access modifier and places abstract incorrectly.abstract class Animal {
abstract void sound();
}
class Dog extends Animal {
void sound() {
System.out.println("Bark");
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Dog();
a.sound();
}
}Animal is abstract with an abstract method sound(). Class Dog extends Animal and provides implementation for sound() that prints "Bark".main, an Animal reference points to a Dog object. Calling sound() invokes Dog's implementation, printing "Bark".abstract class Shape {
abstract void draw();
}
class Circle extends Shape {
void draw() {
System.out.println("Drawing Circle");
}
}
class Square extends Shape {
}
public class Test {
public static void main(String[] args) {
Shape s = new Square();
s.draw();
}
}Shape has abstract method draw(). Circle correctly implements it. Square does not implement draw().Square does not implement the abstract method, it must be declared abstract or implement the method. Otherwise, compilation error occurs.startEngine() behavior. Which approach using abstract methods is best to ensure this?startEngine() behavior, so subclasses must be forced to implement this method.startEngine(). Create a concrete class Vehicle with a startEngine() method that prints a generic message, and override it in subclasses. provides a generic method that can be overridden but does not force implementation. Create an interface Vehicle with a default startEngine() method, and override it in subclasses if needed. uses an interface with a default method, which subclasses may skip overriding. Create a class Vehicle with a private startEngine() method and call it from subclasses. uses a private method, which is not accessible to subclasses.