Java Abstraktion erklärt: Code vereinfachen & Lesbarkeit steigern

Was ist Abstraktion?

Laut Wörterbuch ist Abstraktion die Eigenschaft, sich mit Ideen statt mit Ereignissen zu befassen. Zum Beispiel, wenn Sie den Fall von E-Mail betrachten, sind komplexe Details wie das, was passiert, sobald Sie eine E-Mail senden, das Protokoll, das Ihr E-Mail-Server verwendet, vor dem Benutzer verborgen. Daher müssen Sie zum Senden einer E-Mail nur den Inhalt eingeben, die Empfängeradresse angeben und auf Senden klicken.

Ebenso ist in der objektorientierten Programmierung Abstraktion ein Prozess, die Implementierungsdetails vor dem Benutzer zu verbergen; nur die Funktionalität wird dem Benutzer bereitgestellt. Mit anderen Worten: Der Benutzer hat die Information, was das Objekt tut, statt wie es es tut.

In Java wird Abstraktion mithilfe von abstrakten Klassen und Interfaces erreicht.

Abstrakte Klasse (Abstract Class)

Eine Klasse, die das Schlüsselwort abstract in ihrer Deklaration enthält, ist als abstrakte Klasse bekannt.

• Abstrakte Klassen können abstract methods enthalten (Methoden ohne Body, z. B. public void get();), müssen aber nicht.
• Wenn eine Klasse jedoch mindestens eine abstrakte Methode hat, muss die Klasse als abstract deklariert werden.
• Wenn eine Klasse als abstract deklariert ist, kann sie nicht instanziiert werden.
• Um eine abstrakte Klasse zu verwenden, müssen Sie sie von einer anderen Klasse erben und Implementierungen für die abstrakten Methoden darin bereitstellen.
• Wenn Sie eine abstrakte Klasse erben, müssen Sie Implementierungen für alle abstrakten Methoden darin bereitstellen.

Beispiel: Abstrakte Klasse erstellen

Um eine abstrakte Klasse zu erstellen, verwenden Sie einfach das abstract-Schlüsselwort vor dem Klassen-Schlüsselwort in der Klassendeklaration.

/* Dateiname: 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; }
}

Sie können beobachten, dass die Employee-Klasse abgesehen von abstrakten Methoden wie eine normale Klasse in Java ist. Die Klasse ist jetzt abstrakt, hat aber immer noch drei Felder, sieben Methoden und einen Konstruktor.

Versuchen Sie nun, die Employee-Klasse wie folgt zu instanziieren:

/* Dateiname: AbstractDemo.java */
public class AbstractDemo {
    public static void main(String[] args) {
        /* Folgendes ist nicht erlaubt und würde einen Fehler erzeugen */
        Employee e = new Employee("George W.", "Houston, TX", 43);
        System.out.println("\nCall mailCheck using Employee reference--");
        e.mailCheck();
    }
}

Beim Kompilieren der obigen Klasse erhalten Sie folgenden Fehler:

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

Abstrakte Klasse erben

Wir können die Eigenschaften der Employee-Klasse genau wie eine konkrete Klasse erben:

Beispiel

/* Dateiname: Salary.java */
public class Salary extends Employee {
    private double salary; // Jährliches Gehalt

    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 können Sie die Employee-Klasse nicht instanziieren, aber Sie können die Salary-Klasse instanziieren, und mit dieser Instanz können Sie auf alle drei Felder und sieben Methoden der Employee-Klasse zugreifen, wie unten gezeigt:

/* Dateiname: 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();
    }
}

Ausgabe:

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

Abstrakte Methoden (Abstract Methods)

Wenn Sie möchten, dass eine Klasse eine bestimmte Methode enthält, die tatsächliche Implementierung dieser Methode jedoch von den Kindklassen bestimmt werden soll, können Sie die Methode in der Elternklasse als abstrakt deklarieren.

• Das abstract-Schlüsselwort wird verwendet, um die Methode als abstrakt zu deklarieren.
• Sie müssen das abstract-Schlüsselwort vor dem Methodennamen in der Methodendeklaration platzieren.
• Eine abstrakte Methode enthält eine Methodensignatur, aber keinen Methodenrumpf.
• Statt geschweifter Klammern hat eine abstrakte Methode am Ende einen Strichpunkt (;).

Beispiel

public abstract class Employee {
    private String name;
    private String address;
    private int number;

    public abstract double computePay();
    // Rest der Klassendefinition
}

Eine Methode als abstrakt zu deklarieren, hat zwei Konsequenzen:

• Die Klasse, die sie enthält, muss als abstrakt deklariert werden.
• Jede Klasse, die die aktuelle Klasse erbt, muss entweder die abstrakte Methode überschreiben oder sich selbst als abstrakt deklarieren.

Hinweis – Letztendlich muss eine Nachkommenklasse die abstrakte Methode implementieren; andernfalls hätten Sie eine Hierarchie abstrakter Klassen, die nicht instanziiert werden können.

Angenommen, die Salary-Klasse erbt die Employee-Klasse, dann sollte sie die computePay()-Methode wie unten gezeigt implementieren:

/* Dateiname: Salary.java */
public class Salary extends Employee {
    private double salary; // Jährliches Gehalt

    public double computePay() {
        System.out.println("Computing salary pay for " + getName());
        return salary / 52;
    }
    // Rest der Klassendefinition
}