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 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 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
| Feature | Abstract Class | Interface |
|---|---|---|
| Instantiation | No | No |
| Multiple inheritance | No (single extends) | Yes (multiple implements) |
| Fields | Any type | public static final only |
| Constructors | Yes | No |
| Method types | Abstract + concrete | Abstract + default + static |
| Use when | Shared code among related classes | Defining a contract for unrelated classes |
Ready to Level Up Your Skills?
Explore 500+ free tutorials across 20+ languages and frameworks.