MACRO NEPAL
Abstract Methods Declaration in Java
awiskar acharya
October 29, 2025
4:49 pm

Introduction

Imagine you're creating a blueprint for a house—you specify that there must be doors and windows, but you don't define exactly what they look like. That's what abstract methods do in Java! They declare what needs to be done without specifying how it should be done.

Abstract methods are like contracts that subclasses must fulfill—they define behavior that must be implemented, but leave the specific implementation details to the subclasses.

What are Abstract Methods?

Abstract methods are methods declared without an implementation (without a method body). They must be implemented by the first concrete (non-abstract) subclass that extends the abstract class.

Key Characteristics:

  • 🔓 No implementation: Only method signature, no method body
  • 📝 Must be implemented: Concrete subclasses must provide implementation
  • 🏗️ Define contracts: Specify what subclasses must do
  • 🎯 Enforce structure: Ensure consistent API across subclasses
  • ⚡ Enable polymorphism: Foundation for runtime method resolution

Code Explanation with Examples

Example 1: Basic Abstract Method Declaration

public class BasicAbstractMethods {
public static void main(String[] args) {
System.out.println("=== BASIC ABSTRACT METHOD DECLARATION ===");
// Cannot instantiate abstract classes
// Animal animal = new Animal(); // COMPILER ERROR!
// But we can use concrete subclasses
Dog dog = new Dog();
Cat cat = new Cat();
Bird bird = new Bird();
// Calling implemented abstract methods
System.out.println("Dog sound: " + dog.makeSound());
System.out.println("Cat sound: " + cat.makeSound());
System.out.println("Bird sound: " + bird.makeSound());
// Polymorphism with abstract classes
System.out.println("\n=== POLYMORPHISM WITH ABSTRACT CLASSES ===");
Animal animal1 = new Dog();
Animal animal2 = new Cat();
Animal animal3 = new Bird();
System.out.println("Animal1: " + animal1.makeSound());
System.out.println("Animal2: " + animal2.makeSound());
System.out.println("Animal3: " + animal3.makeSound());
// Calling concrete methods from abstract class
System.out.println("\n=== CONCRETE METHODS IN ABSTRACT CLASSES ===");
dog.breathe();  // Inherited from Animal
cat.breathe();  // Inherited from Animal
bird.breathe(); // Inherited from Animal
}
}
// Abstract class with abstract methods
abstract class Animal {
// ✅ Abstract method - no implementation
public abstract String makeSound();
// ✅ Abstract method with parameters
public abstract String move(int distance);
// ✅ Concrete method - has implementation
public void breathe() {
System.out.println("Animal is breathing...");
}
// ✅ Can have constructors (but cannot be instantiated directly)
public Animal() {
System.out.println("Animal constructor called");
}
// ✅ Can have instance variables
protected String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// Concrete class must implement all abstract methods
class Dog extends Animal {
public Dog() {
this.name = "Dog";
System.out.println("Dog constructor called");
}
// ✅ MUST implement abstract methods
@Override
public String makeSound() {
return "Woof! Woof!";
}
@Override
public String move(int distance) {
return "Dog runs " + distance + " meters happily";
}
// ✅ Can add additional methods
public void fetch() {
System.out.println("Dog is fetching the ball!");
}
}
class Cat extends Animal {
public Cat() {
this.name = "Cat";
System.out.println("Cat constructor called");
}
@Override
public String makeSound() {
return "Meow! Meow!";
}
@Override
public String move(int distance) {
return "Cat gracefully moves " + distance + " meters";
}
public void climb() {
System.out.println("Cat is climbing the tree!");
}
}
class Bird extends Animal {
public Bird() {
this.name = "Bird";
System.out.println("Bird constructor called");
}
@Override
public String makeSound() {
return "Chirp! Chirp!";
}
@Override
public String move(int distance) {
return "Bird flies " + distance + " meters in the sky";
}
public void fly() {
System.out.println("Bird is flying high!");
}
}
// ❌ This won't compile - abstract methods not implemented
/*
class InvalidAnimal extends Animal {
// COMPILER ERROR: Must implement all abstract methods
// Missing makeSound() and move() implementations
}
*/

Output:

=== BASIC ABSTRACT METHOD DECLARATION ===
Animal constructor called
Dog constructor called
Animal constructor called
Cat constructor called
Animal constructor called
Bird constructor called
Dog sound: Woof! Woof!
Cat sound: Meow! Meow!
Bird sound: Chirp! Chirp!
=== POLYMORPHISM WITH ABSTRACT CLASSES ===
Animal1: Woof! Woof!
Animal2: Meow! Meow!
Animal3: Chirp! Chirp!
=== CONCRETE METHODS IN ABSTRACT CLASSES ===
Animal is breathing...
Animal is breathing...
Animal is breathing...

Example 2: Abstract Classes with Multiple Abstract Methods

public class MultipleAbstractMethods {
public static void main(String[] args) {
System.out.println("=== MULTIPLE ABSTRACT METHODS ===");
// Testing different shapes
Circle circle = new Circle(5.0);
Rectangle rectangle = new Rectangle(4.0, 6.0);
Triangle triangle = new Triangle(3.0, 4.0, 5.0);
// Using abstract methods
System.out.println("Circle area: " + circle.calculateArea());
System.out.println("Circle perimeter: " + circle.calculatePerimeter());
circle.display();
System.out.println("\nRectangle area: " + rectangle.calculateArea());
System.out.println("Rectangle perimeter: " + rectangle.calculatePerimeter());
rectangle.display();
System.out.println("\nTriangle area: " + triangle.calculateArea());
System.out.println("Triangle perimeter: " + triangle.calculatePerimeter());
triangle.display();
// Polymorphic behavior
System.out.println("\n=== POLYMORPHIC BEHAVIOR ===");
Shape[] shapes = { circle, rectangle, triangle };
for (Shape shape : shapes) {
System.out.println("Shape: " + shape.getClass().getSimpleName());
System.out.println("Area: " + shape.calculateArea());
System.out.println("Perimeter: " + shape.calculatePerimeter());
shape.display();
System.out.println();
}
// Abstract class with mixed abstract and concrete methods
System.out.println("=== MIXED ABSTRACT AND CONCRETE METHODS ===");
AdvancedShape advancedCircle = new AdvancedCircle(7.0);
advancedCircle.displayInfo();
}
}
// Abstract class with multiple abstract methods
abstract class Shape {
// Multiple abstract methods
public abstract double calculateArea();
public abstract double calculatePerimeter();
public abstract void display();
// Concrete method
public String getShapeType() {
return this.getClass().getSimpleName();
}
// Can have static methods
public static void printShapeInfo(Shape shape) {
System.out.println("Shape Info:");
shape.display();
System.out.println("Area: " + shape.calculateArea());
System.out.println("Perimeter: " + shape.calculatePerimeter());
}
}
class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double calculateArea() {
return Math.PI * radius * radius;
}
@Override
public double calculatePerimeter() {
return 2 * Math.PI * radius;
}
@Override
public void display() {
System.out.println("Circle with radius: " + radius);
}
// Additional method specific to Circle
public double getDiameter() {
return 2 * radius;
}
}
class Rectangle extends Shape {
private double width;
private double height;
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public double calculateArea() {
return width * height;
}
@Override
public double calculatePerimeter() {
return 2 * (width + height);
}
@Override
public void display() {
System.out.println("Rectangle with width: " + width + ", height: " + height);
}
public boolean isSquare() {
return width == height;
}
}
class Triangle extends Shape {
private double sideA;
private double sideB;
private double sideC;
public Triangle(double sideA, double sideB, double sideC) {
this.sideA = sideA;
this.sideB = sideB;
this.sideC = sideC;
}
@Override
public double calculateArea() {
// Using Heron's formula
double s = (sideA + sideB + sideC) / 2;
return Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC));
}
@Override
public double calculatePerimeter() {
return sideA + sideB + sideC;
}
@Override
public void display() {
System.out.println("Triangle with sides: " + sideA + ", " + sideB + ", " + sideC);
}
public boolean isRightAngled() {
double[] sides = {sideA, sideB, sideC};
java.util.Arrays.sort(sides);
return Math.abs((sides[0] * sides[0] + sides[1] * sides[1]) - (sides[2] * sides[2])) < 0.0001;
}
}
// Abstract class with mixed methods
abstract class AdvancedShape {
// Abstract methods
public abstract double calculateArea();
public abstract double calculatePerimeter();
// Concrete methods
public void displayInfo() {
System.out.println("=== Shape Information ===");
System.out.println("Type: " + this.getClass().getSimpleName());
System.out.println("Area: " + calculateArea());
System.out.println("Perimeter: " + calculatePerimeter());
displayDetails();
System.out.println("========================");
}
// Abstract method for detailed display
public abstract void displayDetails();
// Template method pattern
public final void processShape() {
System.out.println("Processing shape...");
validate();
calculateArea();
calculatePerimeter();
displayInfo();
System.out.println("Shape processing completed!");
}
// Hook method - can be overridden
protected void validate() {
System.out.println("Basic validation passed");
}
}
class AdvancedCircle extends AdvancedShape {
private double radius;
public AdvancedCircle(double radius) {
this.radius = radius;
}
@Override
public double calculateArea() {
return Math.PI * radius * radius;
}
@Override
public double calculatePerimeter() {
return 2 * Math.PI * radius;
}
@Override
public void displayDetails() {
System.out.println("Circle Details:");
System.out.println("  Radius: " + radius);
System.out.println("  Diameter: " + (2 * radius));
}
@Override
protected void validate() {
if (radius <= 0) {
throw new IllegalArgumentException("Radius must be positive");
}
System.out.println("Circle validation passed");
}
}

Output:

=== MULTIPLE ABSTRACT METHODS ===
Circle area: 78.53981633974483
Circle perimeter: 31.41592653589793
Circle with radius: 5.0
Rectangle area: 24.0
Rectangle perimeter: 20.0
Rectangle with width: 4.0, height: 6.0
Triangle area: 6.0
Triangle perimeter: 12.0
Triangle with sides: 3.0, 4.0, 5.0
=== POLYMORPHIC BEHAVIOR ===
Shape: Circle
Area: 78.53981633974483
Perimeter: 31.41592653589793
Circle with radius: 5.0
Shape: Rectangle
Area: 24.0
Perimeter: 20.0
Rectangle with width: 4.0, height: 6.0
Shape: Triangle
Area: 6.0
Perimeter: 12.0
Triangle with sides: 3.0, 4.0, 5.0
=== MIXED ABSTRACT AND CONCRETE METHODS ===
=== Shape Information ===
Type: AdvancedCircle
Area: 153.93804002589985
Perimeter: 43.982297150257104
Circle Details:
Radius: 7.0
Diameter: 14.0
========================

Example 3: Abstract Methods in Real-World Scenarios

public class RealWorldAbstractMethods {
public static void main(String[] args) {
System.out.println("=== REAL-WORLD ABSTRACT METHODS ===");
// Database operations
System.out.println("=== DATABASE OPERATIONS ===");
Database mysql = new MySQLDatabase();
Database postgres = new PostgreSQLDatabase();
mysql.connect();
mysql.executeQuery("SELECT * FROM users");
mysql.disconnect();
System.out.println();
postgres.connect();
postgres.executeQuery("SELECT * FROM products");
postgres.disconnect();
// Payment gateway integration
System.out.println("\n=== PAYMENT GATEWAYS ===");
PaymentGateway stripe = new StripeGateway();
PaymentGateway paypal = new PayPalGateway();
processPayment(stripe, 100.0);
processPayment(paypal, 150.0);
// Notification system
System.out.println("\n=== NOTIFICATION SYSTEM ===");
Notification email = new EmailNotification();
Notification sms = new SMSNotification();
Notification push = new PushNotification();
sendNotification(email, "Welcome to our service!");
sendNotification(sms, "Your verification code is 123456");
sendNotification(push, "New message received");
// Report generation
System.out.println("\n=== REPORT GENERATION ===");
Report pdfReport = new PDFReport();
Report excelReport = new ExcelReport();
Report htmlReport = new HTMLReport();
generateReport(pdfReport);
generateReport(excelReport);
generateReport(htmlReport);
}
// Polymorphic method for payments
public static void processPayment(PaymentGateway gateway, double amount) {
System.out.println("Processing $" + amount + " payment...");
gateway.authenticate();
gateway.processPayment(amount);
System.out.println("Payment completed!\n");
}
// Polymorphic method for notifications
public static void sendNotification(Notification notification, String message) {
notification.prepare();
notification.send(message);
System.out.println();
}
// Polymorphic method for reports
public static void generateReport(Report report) {
report.initialize();
report.generateContent();
report.format();
report.finalizeReport();
System.out.println();
}
}
// Database abstraction
abstract class Database {
protected String connectionString;
protected boolean isConnected;
// Abstract methods that must be implemented
public abstract void connect();
public abstract void disconnect();
public abstract void executeQuery(String query);
// Concrete methods
public boolean isConnected() {
return isConnected;
}
public void setConnectionString(String connectionString) {
this.connectionString = connectionString;
}
// Template method pattern
public final void executeTransaction(String... queries) {
connect();
try {
for (String query : queries) {
executeQuery(query);
}
System.out.println("Transaction completed successfully");
} finally {
disconnect();
}
}
}
class MySQLDatabase extends Database {
@Override
public void connect() {
System.out.println("Connecting to MySQL database...");
isConnected = true;
System.out.println("Connected to MySQL successfully");
}
@Override
public void disconnect() {
System.out.println("Disconnecting from MySQL database...");
isConnected = false;
System.out.println("Disconnected from MySQL");
}
@Override
public void executeQuery(String query) {
if (!isConnected) {
throw new IllegalStateException("Not connected to database");
}
System.out.println("Executing MySQL query: " + query);
// Simulate query execution
System.out.println("Query executed successfully");
}
// MySQL specific method
public void enableSSL() {
System.out.println("MySQL SSL enabled");
}
}
class PostgreSQLDatabase extends Database {
@Override
public void connect() {
System.out.println("Connecting to PostgreSQL database...");
isConnected = true;
System.out.println("Connected to PostgreSQL successfully");
}
@Override
public void disconnect() {
System.out.println("Disconnecting from PostgreSQL database...");
isConnected = false;
System.out.println("Disconnected from PostgreSQL");
}
@Override
public void executeQuery(String query) {
if (!isConnected) {
throw new IllegalStateException("Not connected to database");
}
System.out.println("Executing PostgreSQL query: " + query);
// Simulate query execution
System.out.println("Query executed successfully");
}
// PostgreSQL specific method
public void enableReplication() {
System.out.println("PostgreSQL replication enabled");
}
}
// Payment gateway abstraction
abstract class PaymentGateway {
protected String apiKey;
protected boolean authenticated;
// Abstract methods
public abstract void authenticate();
public abstract void processPayment(double amount);
public abstract void refundPayment(String transactionId);
// Concrete methods
public void setApiKey(String apiKey) {
this.apiKey = apiKey;
}
public boolean isAuthenticated() {
return authenticated;
}
// Template method for secure payment
public final void makeSecurePayment(double amount) {
authenticate();
if (!authenticated) {
throw new IllegalStateException("Authentication failed");
}
processPayment(amount);
logTransaction(amount);
}
protected void logTransaction(double amount) {
System.out.println("Transaction logged: $" + amount);
}
}
class StripeGateway extends PaymentGateway {
@Override
public void authenticate() {
System.out.println("Authenticating with Stripe...");
authenticated = true;
System.out.println("Stripe authentication successful");
}
@Override
public void processPayment(double amount) {
if (!authenticated) {
throw new IllegalStateException("Not authenticated with Stripe");
}
System.out.println("Processing payment of $" + amount + " via Stripe");
System.out.println("Charging credit card...");
System.out.println("Payment processed successfully via Stripe");
}
@Override
public void refundPayment(String transactionId) {
System.out.println("Processing refund for transaction: " + transactionId + " via Stripe");
System.out.println("Refund completed via Stripe");
}
// Stripe specific method
public void createCustomer() {
System.out.println("Creating customer in Stripe");
}
}
class PayPalGateway extends PaymentGateway {
@Override
public void authenticate() {
System.out.println("Authenticating with PayPal...");
authenticated = true;
System.out.println("PayPal authentication successful");
}
@Override
public void processPayment(double amount) {
if (!authenticated) {
throw new IllegalStateException("Not authenticated with PayPal");
}
System.out.println("Processing payment of $" + amount + " via PayPal");
System.out.println("Redirecting to PayPal...");
System.out.println("Payment authorized via PayPal");
System.out.println("Payment processed successfully via PayPal");
}
@Override
public void refundPayment(String transactionId) {
System.out.println("Processing refund for transaction: " + transactionId + " via PayPal");
System.out.println("Refund completed via PayPal");
}
// PayPal specific method
public void createBillingAgreement() {
System.out.println("Creating PayPal billing agreement");
}
}
// Notification system abstraction
abstract class Notification {
protected String recipient;
// Abstract methods
public abstract void prepare();
public abstract void send(String message);
public abstract String getType();
// Concrete methods
public void setRecipient(String recipient) {
this.recipient = recipient;
}
public String getRecipient() {
return recipient;
}
// Template method
public final void sendNotification(String message) {
prepare();
send(message);
confirmDelivery();
}
protected void confirmDelivery() {
System.out.println(getType() + " notification delivered to: " + recipient);
}
}
class EmailNotification extends Notification {
public EmailNotification() {
this.recipient = "[email protected]";
}
@Override
public void prepare() {
System.out.println("Preparing email notification...");
System.out.println("Setting up SMTP server...");
System.out.println("Email prepared successfully");
}
@Override
public void send(String message) {
System.out.println("Sending email to: " + recipient);
System.out.println("Subject: Notification");
System.out.println("Body: " + message);
System.out.println("Email sent successfully");
}
@Override
public String getType() {
return "Email";
}
}
class SMSNotification extends Notification {
public SMSNotification() {
this.recipient = "+1234567890";
}
@Override
public void prepare() {
System.out.println("Preparing SMS notification...");
System.out.println("Connecting to SMS gateway...");
System.out.println("SMS prepared successfully");
}
@Override
public void send(String message) {
System.out.println("Sending SMS to: " + recipient);
System.out.println("Message: " + message);
System.out.println("SMS sent successfully");
}
@Override
public String getType() {
return "SMS";
}
}
class PushNotification extends Notification {
public PushNotification() {
this.recipient = "user_device_token";
}
@Override
public void prepare() {
System.out.println("Preparing push notification...");
System.out.println("Connecting to push service...");
System.out.println("Push notification prepared successfully");
}
@Override
public void send(String message) {
System.out.println("Sending push notification to: " + recipient);
System.out.println("Title: App Notification");
System.out.println("Body: " + message);
System.out.println("Push notification sent successfully");
}
@Override
public String getType() {
return "Push";
}
}
// Report generation abstraction
abstract class Report {
protected String title;
protected String content;
// Abstract methods
public abstract void initialize();
public abstract void generateContent();
public abstract void format();
public abstract void save();
// Concrete methods
public void setTitle(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
// Template method
public final void finalizeReport() {
format();
save();
System.out.println("Report finalized: " + title);
}
}
class PDFReport extends Report {
@Override
public void initialize() {
this.title = "PDF Report";
System.out.println("Initializing PDF report...");
}
@Override
public void generateContent() {
this.content = "PDF Report Content";
System.out.println("Generating PDF content...");
}
@Override
public void format() {
System.out.println("Formatting for PDF...");
System.out.println("Adding PDF headers and footers...");
}
@Override
public void save() {
System.out.println("Saving as PDF file...");
System.out.println("PDF report saved: " + title + ".pdf");
}
}
class ExcelReport extends Report {
@Override
public void initialize() {
this.title = "Excel Report";
System.out.println("Initializing Excel report...");
}
@Override
public void generateContent() {
this.content = "Excel Report Content";
System.out.println("Generating Excel content with formulas...");
}
@Override
public void format() {
System.out.println("Formatting for Excel...");
System.out.println("Adding Excel formulas and formatting...");
}
@Override
public void save() {
System.out.println("Saving as Excel file...");
System.out.println("Excel report saved: " + title + ".xlsx");
}
}
class HTMLReport extends Report {
@Override
public void initialize() {
this.title = "HTML Report";
System.out.println("Initializing HTML report...");
}
@Override
public void generateContent() {
this.content = "<html><body>HTML Report Content</body></html>";
System.out.println("Generating HTML content...");
}
@Override
public void format() {
System.out.println("Formatting for HTML...");
System.out.println("Adding CSS styles and HTML tags...");
}
@Override
public void save() {
System.out.println("Saving as HTML file...");
System.out.println("HTML report saved: " + title + ".html");
}
}

Output:

=== REAL-WORLD ABSTRACT METHODS ===
=== DATABASE OPERATIONS ===
Connecting to MySQL database...
Connected to MySQL successfully
Executing MySQL query: SELECT * FROM users
Query executed successfully
Disconnecting from MySQL database...
Disconnected from MySQL
Connecting to PostgreSQL database...
Connected to PostgreSQL successfully
Executing PostgreSQL query: SELECT * FROM products
Query executed successfully
Disconnecting from PostgreSQL database...
Disconnected from PostgreSQL
=== PAYMENT GATEWAYS ===
Processing $100.0 payment...
Authenticating with Stripe...
Stripe authentication successful
Processing payment of $100.0 via Stripe
Charging credit card...
Payment processed successfully via Stripe
Payment completed!
Processing $150.0 payment...
Authenticating with PayPal...
PayPal authentication successful
Processing payment of $150.0 via PayPal
Redirecting to PayPal...
Payment authorized via PayPal
Payment processed successfully via PayPal
Payment completed!
=== NOTIFICATION SYSTEM ===
Preparing email notification...
Setting up SMTP server...
Email prepared successfully
Sending email to: [email protected]
Subject: Notification
Body: Welcome to our service!
Email sent successfully
Email notification delivered to: [email protected]
Preparing SMS notification...
Connecting to SMS gateway...
SMS prepared successfully
Sending SMS to: +1234567890
Message: Your verification code is 123456
SMS sent successfully
SMS notification delivered to: +1234567890
Preparing push notification...
Connecting to push service...
Push notification prepared successfully
Sending push notification to: user_device_token
Title: App Notification
Body: New message received
Push notification sent successfully
Push notification delivered to: user_device_token
=== REPORT GENERATION ===
Initializing PDF report...
Generating PDF content...
Formatting for PDF...
Adding PDF headers and footers...
Saving as PDF file...
PDF report saved: PDF Report.pdf
Report finalized: PDF Report
Initializing Excel report...
Generating Excel content with formulas...
Formatting for Excel...
Adding Excel formulas and formatting...
Saving as Excel file...
Excel report saved: Excel Report.xlsx
Report finalized: Excel Report
Initializing HTML report...
Generating HTML content...
Formatting for HTML...
Adding CSS styles and HTML tags...
Saving as HTML file...
HTML report saved: HTML Report.html
Report finalized: HTML Report

Example 4: Advanced Abstract Method Concepts

public class AdvancedAbstractConcepts {
public static void main(String[] args) {
System.out.println("=== ADVANCED ABSTRACT METHOD CONCEPTS ===");
// Abstract classes with constructors
System.out.println("=== ABSTRACT CLASS CONSTRUCTORS ===");
Car myCar = new SportsCar("Ferrari", 2023);
myCar.displayInfo();
myCar.start();
myCar.drive();
// Interface with default and abstract methods
System.out.println("\n=== INTERFACE ABSTRACT METHODS ===");
Calculator scientificCalc = new ScientificCalculator();
Calculator basicCalc = new BasicCalculator();
System.out.println("Scientific 10 + 5 = " + scientificCalc.add(10, 5));
System.out.println("Basic 10 + 5 = " + basicCalc.add(10, 5));
scientificCalc.displayType();
basicCalc.displayType();
// Multiple inheritance with interfaces
System.out.println("\n=== MULTIPLE INHERITANCE ===");
SmartDevice smartphone = new Smartphone();
smartphone.powerOn();
smartphone.connectToWiFi();
smartphone.takePhoto();
// Abstract class vs Interface
System.out.println("\n=== ABSTRACT CLASS VS INTERFACE ===");
FileProcessor textProcessor = new TextFileProcessor();
FileProcessor imageProcessor = new ImageFileProcessor();
textProcessor.processFile("document.txt");
imageProcessor.processFile("photo.jpg");
}
}
// Abstract class with constructor and instance variables
abstract class Vehicle {
protected String brand;
protected int year;
protected boolean isRunning;
// Abstract class can have constructors
public Vehicle(String brand, int year) {
this.brand = brand;
this.year = year;
this.isRunning = false;
System.out.println("Vehicle constructor: " + brand + " " + year);
}
// Abstract methods
public abstract void start();
public abstract void stop();
public abstract void drive();
// Concrete methods
public void displayInfo() {
System.out.println("Vehicle: " + brand + " (" + year + ")");
System.out.println("Status: " + (isRunning ? "Running" : "Stopped"));
}
public String getBrand() {
return brand;
}
public int getYear() {
return year;
}
// Final method - cannot be overridden
public final void emergencyStop() {
System.out.println("EMERGENCY STOP ACTIVATED!");
stop();
}
}
class Car extends Vehicle {
public Car(String brand, int year) {
super(brand, year);
}
@Override
public void start() {
System.out.println("Car starting... Turning key...");
isRunning = true;
System.out.println("Car started successfully");
}
@Override
public void stop() {
System.out.println("Car stopping... Applying brakes...");
isRunning = false;
System.out.println("Car stopped successfully");
}
@Override
public void drive() {
if (!isRunning) {
System.out.println("Cannot drive - car is not started");
return;
}
System.out.println("Car is driving on the road...");
}
}
class SportsCar extends Car {
public SportsCar(String brand, int year) {
super(brand, year);
}
@Override
public void start() {
System.out.println("Sports car starting... Push button start...");
isRunning = true;
System.out.println("Sports car started with roar!");
}
@Override
public void drive() {
if (!isRunning) {
System.out.println("Cannot drive - sports car is not started");
return;
}
System.out.println("Sports car is speeding on the highway!");
}
// Additional method
public void enableTurbo() {
System.out.println("Turbo mode enabled!");
}
}
// Interface with abstract and default methods
interface Calculator {
// Abstract methods
double add(double a, double b);
double subtract(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);
// Default method (Java 8+)
default void displayType() {
System.out.println("This is a calculator");
}
// Static method
static void showVersion() {
System.out.println("Calculator Interface v1.0");
}
}
class ScientificCalculator implements Calculator {
@Override
public double add(double a, double b) {
return a + b;
}
@Override
public double subtract(double a, double b) {
return a - b;
}
@Override
public double multiply(double a, double b) {
return a * b;
}
@Override
public double divide(double a, double b) {
if (b == 0) {
throw new IllegalArgumentException("Cannot divide by zero");
}
return a / b;
}
@Override
public void displayType() {
System.out.println("This is a SCIENTIFIC calculator");
}
// Additional scientific methods
public double squareRoot(double a) {
return Math.sqrt(a);
}
public double power(double base, double exponent) {
return Math.pow(base, exponent);
}
}
class BasicCalculator implements Calculator {
@Override
public double add(double a, double b) {
System.out.println("Basic addition: " + a + " + " + b);
return a + b;
}
@Override
public double subtract(double a, double b) {
System.out.println("Basic subtraction: " + a + " - " + b);
return a - b;
}
@Override
public double multiply(double a, double b) {
System.out.println("Basic multiplication: " + a + " * " + b);
return a * b;
}
@Override
public double divide(double a, double b) {
if (b == 0) {
throw new IllegalArgumentException("Cannot divide by zero");
}
System.out.println("Basic division: " + a + " / " + b);
return a / b;
}
// Using the default displayType() from interface
}
// Multiple interfaces example
interface Powerable {
void powerOn();
void powerOff();
boolean isPoweredOn();
}
interface Connectable {
void connectToWiFi();
void disconnectFromWiFi();
boolean isConnected();
}
interface Camera {
void takePhoto();
void recordVideo();
default void flash() {
System.out.println("Camera flash activated");
}
}
// Class implementing multiple interfaces
class Smartphone implements Powerable, Connectable, Camera {
private boolean poweredOn = false;
private boolean connected = false;
@Override
public void powerOn() {
System.out.println("Smartphone powering on...");
poweredOn = true;
System.out.println("Smartphone is now ON");
}
@Override
public void powerOff() {
System.out.println("Smartphone powering off...");
poweredOn = false;
connected = false;
System.out.println("Smartphone is now OFF");
}
@Override
public boolean isPoweredOn() {
return poweredOn;
}
@Override
public void connectToWiFi() {
if (!poweredOn) {
System.out.println("Cannot connect - device is powered off");
return;
}
System.out.println("Connecting to WiFi...");
connected = true;
System.out.println("Connected to WiFi successfully");
}
@Override
public void disconnectFromWiFi() {
System.out.println("Disconnecting from WiFi...");
connected = false;
System.out.println("Disconnected from WiFi");
}
@Override
public boolean isConnected() {
return connected;
}
@Override
public void takePhoto() {
if (!poweredOn) {
System.out.println("Cannot take photo - device is powered off");
return;
}
System.out.println("Taking photo with smartphone camera...");
flash();
System.out.println("Photo taken successfully");
}
@Override
public void recordVideo() {
if (!poweredOn) {
System.out.println("Cannot record video - device is powered off");
return;
}
System.out.println("Recording video with smartphone camera...");
System.out.println("Video recording in progress...");
}
}
// Abstract class vs Interface practical example
abstract class FileProcessor {
protected String filename;
protected boolean processed;
// Template method pattern
public final void processFile(String filename) {
this.filename = filename;
System.out.println("Starting file processing: " + filename);
validateFile();
readFile();
processContent();
saveResult();
processed = true;
System.out.println("File processing completed: " + filename);
System.out.println();
}
// Concrete methods
protected void validateFile() {
System.out.println("Validating file: " + filename);
if (filename == null || filename.isEmpty()) {
throw new IllegalArgumentException("Invalid filename");
}
System.out.println("File validation passed");
}
// Abstract methods to be implemented by subclasses
protected abstract void readFile();
protected abstract void processContent();
protected abstract void saveResult();
}
class TextFileProcessor extends FileProcessor {
private String content;
@Override
protected void readFile() {
System.out.println("Reading text file: " + filename);
// Simulate reading text file
content = "This is the content of " + filename;
System.out.println("Text file read successfully");
}
@Override
protected void processContent() {
System.out.println("Processing text content...");
content = content.toUpperCase(); // Simple processing
System.out.println("Text content processed");
}
@Override
protected void saveResult() {
System.out.println("Saving processed text to new file...");
System.out.println("Text file saved: processed_" + filename);
}
}
class ImageFileProcessor extends FileProcessor {
private byte[] imageData;
@Override
protected void readFile() {
System.out.println("Reading image file: " + filename);
// Simulate reading image file
imageData = new byte[1024]; // Mock image data
System.out.println("Image file read successfully");
}
@Override
protected void processContent() {
System.out.println("Processing image...");
System.out.println("Applying filters...");
System.out.println("Resizing image...");
System.out.println("Image processing completed");
}
@Override
protected void saveResult() {
System.out.println("Saving processed image to new file...");
System.out.println("Image file saved: processed_" + filename);
}
}
interface SmartDevice extends Powerable, Connectable {
// Additional abstract methods
void installApp(String appName);
void uninstallApp(String appName);
// Default method
default void showDeviceInfo() {
System.out.println("Smart Device Information");
System.out.println("Powered: " + isPoweredOn());
System.out.println("Connected: " + isConnected());
}
}

Output:

=== ADVANCED ABSTRACT METHOD CONCEPTS ===
=== ABSTRACT CLASS CONSTRUCTORS ===
Vehicle constructor: Ferrari 2023
Vehicle: Ferrari (2023)
Status: Stopped
Sports car starting... Push button start...
Sports car started with roar!
Sports car is speeding on the highway!
=== INTERFACE ABSTRACT METHODS ===
Scientific 10 + 5 = 15.0
Basic addition: 10.0 + 5.0
Basic 10 + 5 = 15.0
This is a SCIENTIFIC calculator
This is a calculator
=== MULTIPLE INHERITANCE ===
Smartphone powering on...
Smartphone is now ON
Connecting to WiFi...
Connected to WiFi successfully
Taking photo with smartphone camera...
Camera flash activated
Photo taken successfully
=== ABSTRACT CLASS VS INTERFACE ===
Starting file processing: document.txt
Validating file: document.txt
File validation passed
Reading text file: document.txt
Text file read successfully
Processing text content...
Text content processed
Saving processed text to new file...
Text file saved: processed_document.txt
File processing completed: document.txt
Starting file processing: photo.jpg
Validating file: photo.jpg
File validation passed
Reading image file: photo.jpg
Image file read successfully
Processing image...
Applying filters...
Resizing image...
Image processing completed
Saving processed image to new file...
Image file saved: processed_photo.jpg
File processing completed: photo.jpg

Example 5: Common Pitfalls and Best Practices

public class AbstractMethodPitfalls {
public static void main(String[] args) {
System.out.println("=== COMMON PITFALLS AND BEST PRACTICES ===");
// Pitfall 1: Forgetting to implement abstract methods
System.out.println("=== PITFALL 1: UNIMPLEMENTED ABSTRACT METHODS ===");
// ConcreteClass concrete = new ConcreteClass(); // Would cause compiler error
// Best practice: Proper implementation
ProperImplementation proper = new ProperImplementation();
proper.abstractMethod();
proper.concreteMethod();
// Pitfall 2: Abstract class instantiation attempt
System.out.println("\n=== PITFALL 2: INSTANTIATING ABSTRACT CLASS ===");
// AbstractClass abs = new AbstractClass(); // COMPILER ERROR!
// Proper usage through concrete subclass
ConcreteSubclass concrete = new ConcreteSubclass();
concrete.abstractMethod();
// Best practices demonstration
System.out.println("\n=== BEST PRACTICES DEMONSTRATION ===");
BestPracticeExample example = new BestPracticeExample();
example.templateMethod();
// Interface best practices
System.out.println("\n=== INTERFACE BEST PRACTICES ===");
GoodInterfaceImplementation goodImpl = new GoodInterfaceImplementation();
goodImpl.abstractMethod();
goodImpl.defaultMethod();
GoodInterface.staticMethod();
// Abstract class design patterns
System.out.println("\n=== TEMPLATE METHOD PATTERN ===");
DataProcessor csvProcessor = new CSVDataProcessor();
DataProcessor jsonProcessor = new JSONDataProcessor();
csvProcessor.processData("data.csv");
jsonProcessor.processData("data.json");
}
}
// ❌ PITFALL: Abstract class with unimplemented abstract methods
abstract class AbstractClass {
public abstract void abstractMethod();
// This class cannot be instantiated until abstractMethod is implemented
}
// ❌ This won't compile - abstract method not implemented
/*
class ConcreteClass extends AbstractClass {
// COMPILER ERROR: Must implement abstract method abstractMethod()
}
*/
// ✅ BEST PRACTICE: Proper implementation
abstract class ProperAbstractClass {
public abstract void abstractMethod();
public void concreteMethod() {
System.out.println("This is a concrete method in abstract class");
}
}
class ProperImplementation extends ProperAbstractClass {
@Override
public void abstractMethod() {
System.out.println("Abstract method properly implemented");
}
}
// Abstract class instantiation pitfall
abstract class CannotInstantiate {
public abstract void abstractMethod();
public void concreteMethod() {
System.out.println("Concrete method");
}
}
class ConcreteSubclass extends CannotInstantiate {
@Override
public void abstractMethod() {
System.out.println("Implemented abstract method in concrete subclass");
}
}
// Best practices for abstract classes
abstract class WellDesignedAbstractClass {
// ✅ Good: Clear, focused abstract methods
public abstract void performAction();
public abstract String getResult();
// ✅ Good: Concrete methods that provide common functionality
public void commonOperation() {
System.out.println("Common operation performed");
preOperation();
performAction();
postOperation();
}
// ✅ Good: Template method pattern
public final void templateMethod() {
initialize();
execute();
cleanup();
}
// ✅ Good: Protected methods for subclasses to override
protected void initialize() {
System.out.println("Default initialization");
}
protected void execute() {
performAction();
}
protected void cleanup() {
System.out.println("Default cleanup");
}
// ✅ Good: Hook methods
protected void preOperation() {
// Default empty implementation - subclasses can override
}
protected void postOperation() {
// Default empty implementation - subclasses can override
}
// ❌ Avoid: Too many abstract methods
// public abstract void method1();
// public abstract void method2();
// public abstract void method3();
// ... too many makes the class hard to implement
}
class BestPracticeExample extends WellDesignedAbstractClass {
@Override
public void performAction() {
System.out.println("Performing specific action");
}
@Override
public String getResult() {
return "Action completed successfully";
}
@Override
protected void initialize() {
System.out.println("Custom initialization for BestPracticeExample");
}
@Override
protected void preOperation() {
System.out.println("Pre-operation hook executed");
}
}
// Interface best practices
interface GoodInterface {
// ✅ Good: Clear, focused abstract methods
void abstractMethod();
// ✅ Good: Default methods for backward compatibility
default void defaultMethod() {
System.out.println("Default implementation in interface");
commonHelper();
}
// ✅ Good: Private methods for helper functionality (Java 9+)
private void commonHelper() {
System.out.println("Common helper method");
}
// ✅ Good: Static methods for utility functions
static void staticMethod() {
System.out.println("Static method in interface");
}
// ❌ Avoid: Too many abstract methods
// void method1();
// void method2();
// void method3();
// ... too many makes the interface hard to implement
}
class GoodInterfaceImplementation implements GoodInterface {
@Override
public void abstractMethod() {
System.out.println("Abstract method implemented properly");
}
// ✅ Can override default method if needed
@Override
public void defaultMethod() {
System.out.println("Custom implementation of default method");
GoodInterface.super.defaultMethod(); // Call interface's default method
}
}
// Template method pattern - best practice
abstract class DataProcessor {
protected String filename;
protected String data;
// ✅ Template method - defines algorithm skeleton
public final void processData(String filename) {
this.filename = filename;
System.out.println("=== Processing " + filename + " ===");
validateFile();
readData();
process();
saveResult();
logCompletion();
System.out.println();
}
// Concrete steps
private void validateFile() {
System.out.println("Validating file: " + filename);
if (filename == null || !filename.contains(".")) {
throw new IllegalArgumentException("Invalid filename: " + filename);
}
}
private void logCompletion() {
System.out.println("Processing completed for: " + filename);
}
// Abstract steps - must be implemented by subclasses
protected abstract void readData();
protected abstract void process();
protected abstract void saveResult();
// Hook methods - subclasses can override
protected void preProcess() {
// Default empty - subclasses can override
}
protected void postProcess() {
// Default empty - subclasses can override
}
}
class CSVDataProcessor extends DataProcessor {
@Override
protected void readData() {
System.out.println("Reading CSV data from: " + filename);
data = "CSV data content";
}
@Override
protected void process() {
System.out.println("Processing CSV data...");
System.out.println("Parsing columns...");
System.out.println("Validating data types...");
data = data.toUpperCase(); // Simple processing
}
@Override
protected void saveResult() {
System.out.println("Saving processed CSV data to database...");
}
@Override
protected void preProcess() {
System.out.println("CSV-specific preprocessing...");
}
}
class JSONDataProcessor extends DataProcessor {
@Override
protected void readData() {
System.out.println("Reading JSON data from: " + filename);
data = "{\"key\": \"value\"}";
}
@Override
protected void process() {
System.out.println("Processing JSON data...");
System.out.println("Validating JSON structure...");
System.out.println("Extracting fields...");
data = data.replace("value", "processed_value");
}
@Override
protected void saveResult() {
System.out.println("Saving processed JSON to file system...");
}
@Override
protected void postProcess() {
System.out.println("JSON-specific postprocessing...");
}
}
// Common pitfalls with access modifiers
abstract class AccessModifierExample {
// ✅ Good: Public abstract methods
public abstract void publicMethod();
// ✅ Good: Protected abstract methods (for internal use)
protected abstract void protectedMethod();
// ❌ Avoid: Private abstract methods (makes no sense)
// private abstract void privateMethod(); // COMPILER ERROR!
// ❌ Avoid: Package-private without reason
// abstract void packagePrivateMethod(); // Use protected instead
}
class AccessImplementation extends AccessModifierExample {
@Override
public void publicMethod() {
System.out.println("Public method implemented");
}
@Override
protected void protectedMethod() {
System.out.println("Protected method implemented");
}
}
// Final abstract method pitfall
abstract class FinalAbstractPitfall {
// ❌ Cannot have final abstract methods
// public final abstract void finalAbstractMethod(); // COMPILER ERROR!
// ✅ But can have final concrete methods
public final void finalConcreteMethod() {
System.out.println("This is final and cannot be overridden");
}
}

Output:

=== COMMON PITFALLS AND BEST PRACTICES ===
=== PITFALL 1: UNIMPLEMENTED ABSTRACT METHODS ===
Abstract method properly implemented
This is a concrete method in abstract class
=== PITFALL 2: INSTANTIATING ABSTRACT CLASS ===
Implemented abstract method in concrete subclass
=== BEST PRACTICES DEMONSTRATION ===
Default initialization
Performing specific action
Default cleanup
=== INTERFACE BEST PRACTICES ===
Abstract method implemented properly
Custom implementation of default method
Default implementation in interface
Common helper method
Static method in interface
=== TEMPLATE METHOD PATTERN ===
=== Processing data.csv ===
Validating file: data.csv
Reading CSV data from: data.csv
CSV-specific preprocessing...
Processing CSV data...
Parsing columns...
Validating data types...
Saving processed CSV data to database...
Processing completed for: data.csv
=== Processing data.json ===
Validating file: data.json
Reading JSON data from: data.json
Processing JSON data...
Validating JSON structure...
Extracting fields...
Saving processed JSON to file system...
JSON-specific postprocessing...
Processing completed for: data.json

Abstract Method Rules Summary

RuleDescriptionExample
No ImplementationOnly declaration, no method bodyabstract void method();
Abstract Class RequiredMust be in abstract class or interfaceabstract class Class { abstract void m(); }
Must Be ImplementedConcrete subclasses must provide implementationclass Child extends Parent { void m() {} }
Cannot Be PrivateCannot have private abstract methodsprivate abstract void m(); // ERROR
Cannot Be FinalCannot have final abstract methodsfinal abstract void m(); // ERROR
Cannot Be StaticCannot have static abstract methodsstatic abstract void m(); // ERROR

@Override Annotation Benefits

  1. Compiler checking: Ensures method actually overrides/implements
  2. Readability: Clearly indicates implementation intent
  3. Maintenance: Prevents method signature errors
  4. Documentation: Shows design decisions clearly

Best Practices

✅ Do:

  • Use abstract methods to define contracts
  • Keep abstract classes focused with clear purpose
  • Use template method pattern for common algorithms
  • Provide default implementations when possible
  • Document abstract method expectations
  • Use @Override annotation consistently

❌ Don't:

  • Create too many abstract methods in one class
  • Use abstract methods for utility functions
  • Forget to implement all abstract methods
  • Make abstract methods too specific
  • Ignore the Liskov Substitution Principle

Common Pitfalls

  1. Forgetting to implement abstract methods in concrete classes
  2. Trying to instantiate abstract classes directly
  3. Creating abstract methods that are too broad or vague
  4. Violating contract in implementations
  5. Overusing abstraction when concrete classes would suffice
  6. Ignoring access modifiers in abstract method design

Design Patterns Using Abstract Methods

  1. Template Method: Define algorithm skeleton with abstract steps
  2. Factory Method: Let subclasses decide object creation
  3. Strategy: Define family of algorithms as abstract methods
  4. Observer: Abstract update methods for observers
  5. Command: Abstract execute method for commands

Performance Considerations

  • Virtual method calls have slight overhead vs final methods
  • JVM optimizations like inline caching help performance
  • Abstract classes vs interfaces have similar performance
  • Template method pattern can improve code reuse and maintenance

Conclusion

Abstract methods are Java's way of defining "what to do" without specifying "how to do it":

  • 🔓 Declaration only: No implementation, just contract
  • 🏗️ Enforced implementation: Subclasses must provide concrete implementation
  • 🎯 Design by contract: Clear API definition
  • 📈 Polymorphism foundation: Enable runtime method resolution
  • 🚫 Restricted usage: Only in abstract classes and interfaces

Key Takeaways:

  • Abstract methods declare behavior without implementation
  • Concrete subclasses must implement all abstract methods
  • Use for defining contracts and APIs
  • Enable polymorphism and flexible designs
  • Follow best practices for maintainable code

Mastering abstract methods is essential for creating flexible, extensible, and well-structured object-oriented designs in Java!

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper