Tutorials Logic, IN +91 8092939553 info@tutorialslogic.com
FAQs Support
Navigation
Home About Us Contact Us Blogs FAQs
Tutorials
All Tutorials
Services
Academic Projects Resume Writing Interview Questions Website Development
Compiler Tutorials

Java Abstraction

Abstract Classes

An abstract class cannot be instantiated directly. It can contain both abstract methods (no body — subclasses must implement them) and concrete methods (with a body). Use it when you want to share code among closely related classes.

Abstract Class
abstract class Animal {
    String name;

    public Animal(String name) {
        this.name = name;
    }

    // Abstract method — no body, must be overridden
    public abstract String sound();

    // Concrete method — shared by all subclasses
    public void breathe() {
        System.out.println(name + " is breathing.");
    }
}

class Cat extends Animal {
    public Cat(String name) { super(name); }

    @Override
    public String sound() { return "Meow"; }
}

class Cow extends Animal {
    public Cow(String name) { super(name); }

    @Override
    public String sound() { return "Moo"; }
}

public class AbstractDemo {
    public static void main(String[] args) {
        // Animal a = new Animal("X");  // ERROR: cannot instantiate abstract class

        Animal cat = new Cat("Whiskers");
        Animal cow = new Cow("Bessie");

        System.out.println(cat.name + " says: " + cat.sound());
        System.out.println(cow.name + " says: " + cow.sound());
        cat.breathe();
    }
}

Interfaces

An interface is a pure contract — it defines what a class must do, not how. A class implements an interface and must provide implementations for all its abstract methods. A class can implement multiple interfaces.

Interface & Default Methods (Java 8+)
interface Drawable {
    void draw();  // abstract by default

    // Default method (Java 8+) — provides a default implementation
    default void describe() {
        System.out.println("I am a drawable shape.");
    }

    // Static method in interface (Java 8+)
    static void info() {
        System.out.println("Drawable interface v1.0");
    }
}

interface Resizable {
    void resize(double factor);
}

// A class can implement multiple interfaces
class Square implements Drawable, Resizable {
    double side;

    public Square(double side) { this.side = side; }

    @Override
    public void draw() {
        System.out.println("Drawing a square with side " + side);
    }

    @Override
    public void resize(double factor) {
        side *= factor;
        System.out.println("Resized to side " + side);
    }
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Square sq = new Square(5.0);
        sq.draw();       // Drawing a square with side 5.0
        sq.describe();   // I am a drawable shape. (default method)
        sq.resize(2.0);  // Resized to side 10.0

        Drawable.info(); // Drawable interface v1.0 (static method)
    }
}

Abstract Class vs Interface

FeatureAbstract ClassInterface
InstantiationNoNo
Multiple inheritanceNo (single extends)Yes (multiple implements)
FieldsAny typepublic static final only
ConstructorsYesNo
Method typesAbstract + concreteAbstract + default + static
Use whenShared code among related classesDefining a contract for unrelated classes

Ready to Level Up Your Skills?

Explore 500+ free tutorials across 20+ languages and frameworks.