Java Abstraction uitgelegd: Code vereenvoudigen & Leesbaarheid verhogen

Wat is Abstraction?

Volgens de woordenboekdefinitie is abstraction de kwaliteit om te maken te hebben met ideeën in plaats van gebeurtenissen. Bijvoorbeeld, als je e-mail overweegt, zijn complexe details zoals wat er gebeurt zodra je een e-mail verstuurt, het protocol dat je e-mailserver gebruikt, verborgen voor de gebruiker. Om een e-mail te sturen, hoef je alleen de inhoud te typen, het adres van de ontvanger te vermelden en op verzenden te klikken.

Op dezelfde manier in object-georiënteerd programmeren is abstraction een proces waarbij de implementatiedetails voor de gebruiker verborgen blijven; alleen de functionaliteit wordt aan de gebruiker geboden. Met andere woorden: de gebruiker weet wat het object doet in plaats van hoe het het doet.

In Java wordt abstraction bereikt met behulp van abstracte klassen en interfaces.

Abstracte Klasse (Abstract Class)

Een klasse die het abstract-sleutelwoord in zijn declaratie bevat, heet een abstracte klasse.

• Abstracte klassen kunnen wel of geen abstracte methodes bevatten, d.w.z. methodes zonder body (public void get();).
• Maar, als een klasse minimaal één abstracte methode heeft, dan moet de klasse abstract gedeclareerd worden.
• Als een klasse abstract is gedeclareerd, kan deze niet geïnstantieerd worden.
• Om een abstracte klasse te gebruiken, moet je deze overerven van een andere klasse en implementaties bieden voor de abstracte methodes erin.
• Als je een abstracte klasse overerft, moet je implementaties bieden voor alle abstracte methodes erin.

Voorbeeld: Abstracte klasse

Om een abstracte klasse te maken, plaats je het abstract-sleutelwoord voor het class-sleutelwoord in de klassedeclaratie.

/* Bestandsnaam: Employee.java */
public abstract class Employee {
    private String name;
    private String address;
    private int number;
    public Employee(String name, String address, int number) {
        System.out.println("Constructing an Employee");
        this.name = name;
        this.address = address;
        this.number = number;
    }
    public double computePay() {
        System.out.println("Inside Employee computePay");
        return 0.0;
    }
    public void mailCheck() {
        System.out.println("Mailing a check to " + this.name + " " + this.address);
    }
    public String toString() { return name + " " + address + " " + number; }
    public String getName() { return name; }
    public String getAddress() { return address; }
    public void setAddress(String newAddress) { address = newAddress; }
    public int getNumber() { return number; }
}

Je ziet dat, behalve abstracte methodes, de Employee-klasse hetzelfde is als een normale klasse in Java. De klasse is nu abstract, maar heeft nog steeds drie velden, zeven methodes en één constructor.

Als je probeert de Employee-klasse te instantiëren:

/* Bestandsnaam: AbstractDemo.java */
public class AbstractDemo {
    public static void main(String[] args) {
        /* Dit is niet toegestaan en zou een fout geven */
        Employee e = new Employee("George W.", "Houston, TX", 43);
        System.out.println("\nCall mailCheck using Employee reference--");
        e.mailCheck();
    }
}

Bij compilatie krijg je deze fout:

Employee.java:46: Employee is abstract; cannot be instantiated
Employee e = new Employee("George W.", "Houston, TX", 43);
^
1 error

De Abstracte Klasse Overerven

We kunnen de eigenschappen van de Employee-klasse overerven net als een concrete klasse:

Voorbeeld: Salary klasse

/* Bestandsnaam: Salary.java */
public class Salary extends Employee {
    private double salary; // Jaarlijks salaris
    public Salary(String name, String address, int number, double salary) {
        super(name, address, number);
        setSalary(salary);
    }
    public void mailCheck() {
        System.out.println("Within mailCheck of Salary class ");
        System.out.println("Mailing check to " + getName() + " with salary " + salary);
    }
    public double getSalary() { return salary; }
    public void setSalary(double newSalary) {
        if (newSalary >= 0.0) { salary = newSalary; }
    }
    public double computePay() {
        System.out.println("Computing salary pay for " + getName());
        return salary / 52;
    }
}

Hier kun je de Employee-klasse niet instantiëren, maar wel de Salary-klasse. Met deze instantie kun je alle drie velden en zeven methodes van de Employee-klasse benaderen.

/* Bestandsnaam: AbstractDemo.java */
public class AbstractDemo {
    public static void main(String[] args) {
        Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
        Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
        System.out.println("Call mailCheck using Salary reference --");
        s.mailCheck();
        System.out.println("\nCall mailCheck using Employee reference--");
        e.mailCheck();
    }
}

Resultaat:

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0
Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

Abstracte Methodes

Als je wilt dat een klasse een bepaalde methode bevat, maar de daadwerkelijke implementatie van die methode door child-klassen bepaald moet worden, kun je de methode in de parent-klasse als abstract declareren.

• abstract sleutelwoord wordt gebruikt om de methode als abstract te declareren.
• Plaats het abstract sleutelwoord vóór de methodenaam in de methode-declaratie.
• Een abstracte methode bevat een methodehandtekening, maar geen methode-body.
• In plaats van accolades heeft een abstracte methode een puntkomma (;) aan het einde.

Voorbeeld: Abstracte methode

public abstract class Employee {
    private String name;
    private String address;
    private int number;
    public abstract double computePay();
    // Rest van de klassedefinitie
}

Het declareren van een methode als abstract heeft twee gevolgen:

• De klasse die het bevat, moet als abstract gedeclareerd worden.
• Elke klasse die de huidige klasse overerft, moet de abstracte methode overschrijven of zichzelf als abstract declareren.

Let op: Uiteindelijk moet een afstammelingsklasse de abstracte methode implementeren; anders zou je een hiërarchie van abstracte klassen hebben die niet geïnstantieerd kunnen worden.

Stel dat de Salary-klasse de Employee-klasse overerft, dan moet deze de computePay()-methode implementeren:

/* Bestandsnaam: Salary.java */
public class Salary extends Employee {
    private double salary; // Jaarlijks salaris
    public double computePay() {
        System.out.println("Computing salary pay for " + getName());
        return salary / 52;
    }
    // Rest van de klassedefinitie
}