Abstraction OOP Fundamentals – Interface, Abstract Class, Composition, Open Closed Principle

This article is a definition of terms on abstraction in OOP – including exam questions and tags.

In a Nutshell

Abstraction reduces complex systems to their essential properties and operations, it defines the what of an interface, the how remains hidden and can be developed independently.

Compact Technical Description

Abstraction is the deliberate exclusion of inessential details to obtain a clear, stable model. In OOP it is realized through interfaces, abstract classes, role models and contracts that establish observable behavior. Good abstractions are minimal, complete, consistent, orthogonal, they support interchangeability and test well via black box procedures. Abstraction works closely with encapsulation and polymorphism; abstraction determines what is visible, encapsulation protects implementation details, polymorphism enables interchangeable implementations.

Exam-Relevant Key Points

• Focus on relevant properties, reduction of visible surface
• Means, interface, abstract class, composition, generics
• Separation of contract and implementation, promotes loose coupling and high cohesion
• IHK relevant, precise distinction from encapsulation and inheritance
• Practice, small, role-based interfaces, interface segregation principle
• Security aspect, clear contracts limit attack surface and prevent unvalidated state manipulation
• Efficiency, stable contracts reduce maintenance and change costs
• Documentation obligation, preconditions, postconditions, exceptions, side effects explicitly described

Core Components

1. Domain model, ubiquitous language, concepts and relationships
2. Contract interface, signatures, semantics, error cases
3. Abstract bases, shared core logic without complete implementation
4. Roles, multiple small interfaces instead of one god interface
5. Composition, has-a relationships for structuring behavior
6. Generic types, parametric abstraction over types
7. Design patterns, strategy, template method, adapter, ports and adapters
8. Architecture boundaries, ports, adapters, bounded contexts
9. Quality rules, high cohesion, low coupling, LSP compliant
10. Test procedures, contract, substitution, property based tests

Practical Example

// Goal: abstract file export
interface Exporter {
byte[] export(Report r)
}

class PdfExporter implements Exporter {
public byte[] export(Report r) { /* PDF rendering, validation, byte stream */ }
}

class CsvExporter implements Exporter {
public byte[] export(Report r) { /* CSV serialization, separation, encoding */ }
}

class ReportService {
private Exporter exporter
public ReportService(Exporter exporter) { this.exporter = exporter }
public byte[] exportReport(Report r) {
if (r == null) throw new IllegalArgumentException("Report required")
return exporter.export(r)
}
}

Explanation: The Exporter interface defines the abstraction of export, concrete formats are interchangeable, the ReportService remains unchanged.

Advantages and Disadvantages

Advantages

• Lower coupling, higher cohesion
• Better testability, clear responsibilities
• Easy extensibility, more stable APIs

Disadvantages

• Initial modeling effort
• Risk of over-abstracted contracts
• Additional indirection with incorrect design

Typical Exam Questions (with Brief Answer)

1. Abstraction vs. Encapsulation? Abstraction determines which relevant aspects are visible, encapsulation hides the implementation of these aspects behind the surface.

2. Interface vs. Abstract Class? Interface for pure contracts and multiple roles, abstract class when shared core logic or state is needed.

3. Supports Open Closed Principle? Contracts remain stable, new variants emerge as new implementations, existing code does not need to change.

4. Criteria for good abstraction? Minimal but complete, consistently named, orthogonal, stable with internal changes, clearly documented.

5. Check quality of an abstraction? Metrics, number of methods per interface, change frequency, reuse, test coverage, number of implementations.

6. Bad abstraction example? God interface with many unrelated methods, violates ISP, hinders interchangeability and tests.

7. Role of generics in abstraction? Parametric abstraction, one algorithm for many types without casts, type safety through compiler.

8. Polymorphism and abstraction work together? Abstraction defines the contract, polymorphism provides interchangeable implementations, dynamic dispatch binds at runtime.

Most Important Sources

1. https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
2. https://de.wikipedia.org/wiki/Abstraktion_(Informatik)
3. https://martinfowler.com/bliki/RoleInterface.html