Object-georiënteerd programmeren rust op vier kernprincipes — Encapsulation, Inheritance, Polymorphism en Abstraction. Java is gebouwd rond deze principes, en het begrijpen ervan is fundamenteel voor het ontwerpen van Java-programma's.
{
balance;
{
(amount > ) balance += amount;
}
{ balance; }
}
Encapsulation verbergt interne toestand (private) en biedt gecontroleerde toegang (public methods/getters/setters). Dit beschermt invarianten — je kunt niet direct een negatief saldo instellen — en laat je internals wijzigen zonder aanroepers te breken.
class Animal {
void eat() { System.out.println("eating"); }
}
class Dog extends Animal { // Dog IS-A Animal — inherits eat()
void bark() { System.out.println("woof"); }
}
Inheritance laat een subclass het gedrag van een superclass hergebruiken en uitbreiden, waarbij "is-a" relaties worden gemodelleerd en code-duplicatie wordt voorkomen.
Animal a = new Dog(); // a Dog treated as an Animal
a.makeSound(); // calls Dog's overridden version at RUNTIME (dynamic dispatch)
// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
Polymorphism laat je verschillende subclasses uniform behandelen via een gemeenschappelijk type, waarbij de werkelijke methode van het object op runtime wordt aangeroepen — wat flexibele, uitbreidbare code mogelijk maakt.
interface PaymentProcessor {
void pay(double amount); // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
Abstraction (via interfaces/abstract classes) blootlegt een vereenvoudigd contract terwijl het complexe implementatie verbergt — waardoor je implementaties kunt uitwisselen en koppeling kunt verminderen.
De vier pijlers zijn de basis van object-georiënteerd ontwerp en van Java zelf.
Encapsulation beschermt data-integriteit en maakt veilige wijzigingen mogelijk; inheritance bevordert hergebruik; polymorphism biedt flexibiliteit en uitbreidbaarheid (behandel veel types uniform, gedrag wordt op runtime opgelost); abstraction vermindert koppeling en complexiteit.
De betekenis ervan begrijpen is niet alleen terminologie — ze leiden hoe je classes structureert, API's ontwerpt en onderhoudbare, uitbreidbare systemen bouwt.
Ze behoren ook tot de meest voorkomende interviewonderwerpen omdat ze onthullen of een ontwikkelaar in juiste OOP-termen denkt, wat essentieel is voor effectief werken in Java's class-centrische ecosysteem.