abstraktes Schlüsselwort in Java

Das Schlüsselwort abstract wird in Java verwendet, um eine Klasse oder eine Methode zu deklarieren, die nicht direkt instanziert werden kann bzw. von Unterklassen implementiert werden muss. Sie ist ein wichtiger Teil des Abstraktionsmechanismus von Java, der es Entwicklern ermöglicht, abstrakte Klassen und Methoden zu definieren, die als Blaupause für andere Klassen dienen.

Verwendung

Abstrakte Klasse

Eine abstrakte Klasse ist eine Klasse, die nicht eigenständig instanziiert werden kann und abstrakte Methoden enthalten kann, die von Unterklassen implementiert werden müssen.

Abstrakte Methode

Eine abstrakte Methode ist eine Methode, die ohne eine Implementierung deklariert wird. Unterklassen der abstrakten Klasse müssen eine Implementierung für diese Methoden bereitstellen.

Syntax

Abstrakte Klasse

abstract class ClassName {
    // Abstract methods
    abstract void methodName();
    
    // Concrete methods
    void concreteMethod() {
        // Method body
    }
}Bereitgestellt von

Abstrakte Methode

abstract void methodName();Bereitgestellt von

Beispiele

Beispiel 1: Abstrakte Klasse und Methode

abstract class Animal {
    // Abstract method
    abstract void makeSound();

    // Concrete method
    void sleep() {
        System.out.println("Sleeping...");
    }
}

class Dog extends Animal {
    // Implementing the abstract method
    void makeSound() {
        System.out.println("Bark");
    }
}

public class AbstractExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // Outputs: Bark
        dog.sleep();     // Outputs: Sleeping...
    }
}Bereitgestellt von

In diesem Beispiel ist Animal eine abstrakte Klasse mit einer abstrakten Methode makeSound() und einer konkreten Methode sleep(). Die Klasse Dog erweitert Animal und bietet eine Implementierung für die Methode makeSound().

Beispiel 2: Mehrere abstrakte Methoden

abstract class Shape {
    abstract void draw();
    abstract double area();
}

class Circle extends Shape {
    private double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    void draw() {
        System.out.println("Drawing Circle");
    }

    double area() {
        return Math.PI * radius * radius;
    }
}

public class ShapeExample {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        circle.draw(); // Outputs: Drawing Circle
        System.out.println("Area: " + circle.area()); // Outputs: Area: 78.53981633974483
    }
}Bereitgestellt von

Hier ist Shape eine abstrakte Klasse mit zwei abstrakten Methoden: draw() und area(). Circle erweitert Shape und bietet Implementierungen für beide abstrakten Methoden.

Tipps und bewährte Praktiken

• Verwende abstrakte Klassen für gemeinsamen Code: Verwende abstrakte Klassen, wenn du gemeinsamen Code hast, der an mehrere Unterklassen vererbt werden soll. Abstrakte Klassen können sowohl abstrakte als auch konkrete Methoden enthalten.
• Obligatorische Umsetzung: Stelle sicher, dass alle abstrakten Methoden in einer abstrakten Klasse von ihren Unterklassen implementiert werden.
• Kann nicht instanziiert werden: Denke daran, dass du keine Instanzen einer abstrakten Klasse direkt erstellen kannst. Du musst eine Instanz einer Unterklasse erstellen, die alle abstrakten Methoden implementiert.
• Verwende abstrakte Methoden für Schnittstellen: Wenn du eine Klasse hast, die als Basis mit Methoden dienen soll, die überschrieben werden müssen, verwende abstrakte Methoden, um diesen Vertrag durchzusetzen.
• Kombinieren mit Interfaces: Abstrakte Klassen können Schnittstellen implementieren und Implementierungen für einige der Methoden bereitstellen, während andere abstrakt bleiben und von Unterklassen implementiert werden können.  

  abstract class Vehicle implements Movable {
      abstract void start();
  }Bereitgestellt von

• Konstruktor in der abstrakten Klasse: Abstrakte Klassen können Konstruktoren haben, die bei der Instanziierung einer Unterklasse aufgerufen werden können.  

  abstract class Base {
      Base() {
          System.out.println("Base Constructor");
      }
  }Bereitgestellt von

• Abstrakte Klassen vs. Interfaces: Verwende abstrakte Klassen, wenn du Code zwischen eng verwandten Klassen austauschen musst, und verwende Schnittstellen, wenn du einen Vertrag definieren musst, der von jeder Klasse implementiert werden kann, unabhängig von ihrer Position in der Klassenhierarchie.
• Statische Methoden und Felder: Abstrakte Klassen können statische Felder und Methoden haben, auf die zugegriffen werden kann, ohne eine Instanz der Klasse zu erstellen.

abstract class Utility {
    static void printMessage() {
        System.out.println("Utility Message");
    }
}Bereitgestellt von