Objektorientierte Programmierung in Java

© monsit – Shotshop.com

Objektorientierte Programmierung (OOP) ist ein Programmierparadigma, das auf dem Konzept von „Objekten“ basiert, welche Datenstrukturen und Methoden enthalten. Java ist eine objektorientierte Sprache, die vier Hauptprinzipien der OOP unterstützt: Klassen und Objekte, Vererbung, Polymorphie und Kapselung. Lassen Sie uns uns diese Konzepte genauer betrachten.

Klassen und Objekte

In Java definiert eine Klasse ein benutzerdefiniertes Datentyp-Format in Form von Feldern (Daten) und Methoden (Funktionen), die auf diesen Daten operieren. Ein Objekt ist eine Instanz einer Klasse – es hat einen Zustand und ein Verhalten, die durch die Klasse definiert sind. In diesem Beispiel ist Car eine Klasse, die zwei Felder (color und speed) und eine Methode (accelerate) definiert. myCar ist ein Objekt der Klasse Car.

public class Car {
  String color; // Feld
  int speed; // Feld
  void accelerate() { // Methode
    speed += 10;
  }
}

Car myCar = new Car(); // Objekt
myCar.color = "Red";
myCar.speed = 0;
myCar.accelerate();

Vererbung

Die Vererbung ist ein Mechanismus in Java, der es einer Klasse ermöglicht, Felder und Methoden von einer anderen Klasse zu erben. Die Klasse, von der geerbt wird, wird als „Superklasse“ oder „Elternklasse“ bezeichnet, und die Klasse, die erbt, wird als „Unterklasse“ oder „Kindklasse“ bezeichnet.

Grundlagen der Vererbung

In der objektorientierten Programmierung ermöglicht die Vererbung, dass eine Klasse die Eigenschaften (Felder) und Verhaltensweisen (Methoden) einer anderen Klasse wiederverwendet. Die Vererbung fördert die Wiederverwendbarkeit des Codes und kann verwendet werden, um funktionale Beziehungen zwischen Klassen darzustellen.

Beispiel für Vererbung

Ein typisches Beispiel für Vererbung wäre eine allgemeine Klasse Fahrzeug, die von spezifischeren Klassen wie Auto und Motorrad erweitert wird:

In diesem Beispiel erben die Klassen Auto und Motorrad von der Klasse Fahrzeug. Beide Unterklassen haben Zugriff auf die beschleunigen-Methode der Superklasse Fahrzeug.

Vorteile der Vererbung

  • Wiederverwendbarkeit: Gemeinsamer Code kann in einer Superklasse geschrieben und von mehreren Unterklassen wiederverwendet werden.
  • Erweiterbarkeit: Es ist einfacher, den Code zu erweitern und zu modifizieren, da Änderungen in der Superklasse automatisch in allen Unterklassen übernommen werden.
  • Organisation: Die Vererbung hilft dabei, den Code in eine logische Hierarchie zu organisieren, was das Verständnis und die Wartung erleichtert.

Die Vererbung ist ein mächtiges Konzept in der objektorientierten Programmierung und ein Schlüsselprinzip in Java, das hilft, sauberen und effizienten Code zu schreiben.

class Fahrzeug {
  int geschwindigkeit;
  int groesse;
  void beschleunigen() {
    geschwindigkeit += 10;
  }
}

class Auto extends Fahrzeug {
  int raeder = 4;
}

class Motorrad extends Fahrzeug {
  int raeder = 2;
}

public class TestVererbung {
  public static void main(String[] args) {
    Auto meinAuto = new Auto();
    meinAuto.beschleunigen();
    System.out.println("Auto-Geschwindigkeit: " + meinAuto.geschwindigkeit); // Ausgabe: Auto-Geschwindigkeit: 10
    Motorrad meinMotorrad = new Motorrad();
    meinMotorrad.beschleunigen();
    System.out.println("Motorrad-Geschwindigkeit: " + meinMotorrad.geschwindigkeit); // Ausgabe: Motorrad-Geschwindigkeit: 10
  }
}

Polymorphie

Polymorphie ist ein weiteres grundlegendes Prinzip der objektorientierten Programmierung (OOP) in Java. Es bedeutet, dass eine Variable, eine Funktion oder ein Objekt mehrere Formen annehmen kann. Die Polymorphie in Java kann hauptsächlich in zwei Typen unterteilt werden: Compile-Zeit Polymorphie (überladen) und Laufzeit Polymorphie (überschreiben).

Compile-Zeit Polymorphie (Überladen)

Bei der Compile-Zeit Polymorphie kann eine Methode auf verschiedene Weisen definiert werden, indem Anzahl, Typ oder Reihenfolge der Parameter variiert werden. Hier ist ein einfaches Beispiel für das Überladen von Methoden:

class Rechner {
  int addieren(int a, int b) {
    return a + b;
  }
  double addieren(double a, double b) {
    return a + b;
  }
}

public class TestRechner {
  public static void main(String[] args) {
    Rechner calc = new Rechner();
    System.out.println(calc.addieren(2, 3)); // Ausgabe: 5
    System.out.println(calc.addieren(2.5, 3.5)); // Ausgabe: 6.0
  }
}

In diesem Beispiel hat die Klasse Rechner zwei Methoden mit dem Namen addieren, aber mit unterschiedlichen Parametertypen.

Laufzeit Polymorphie (Überschreiben)

Bei der Laufzeit Polymorphie wird eine Methode in der abgeleiteten Klasse überschrieben, sodass während der Laufzeit die Version der Methode der entsprechenden Klasse aufgerufen wird. Ein Beispiel dafür:

class Tier {
  void sound() {
    System.out.println("Das Tier macht einen Sound");
  }
}

class Hund extends Tier {
  void sound() {
    System.out.println("Der Hund bellt");
  }
}

public class TestPolymorphie {
  public static void main(String[] args) {
    Tier myAnimal = new Hund();
    myAnimal.sound(); // Ausgabe: Der Hund bellt
  }
}

In diesem Beispiel überschreibt die Klasse Hund die Methode sound der Klasse Tier, und die Methode der Klasse Hund wird zur Laufzeit aufgerufen.

Die Polymorphie ermöglicht es, Code flexibler und wiederverwendbar zu machen und ist ein Schlüsselkonzept in OOP, das dazu beiträgt, klaren und effizienten Code zu schreiben.

Kapselung

Kapselung ist ein Konzept, das die Details einer Implementierung verbirgt und nur die Funktionalität nach außen sichtbar macht. Sie bindet die Daten (Variablen) und den Code, der auf den Daten (Methoden) manipuliert, zusammen als eine einzelne Einheit.

public class Car {
  private int speed;
  
  public int getSpeed() {
    return speed;
  }
  
  public void setSpeed(int speed) {
    if (speed >= 0) {
      this.speed = speed;
    }
  }
}

In diesem Beispiel ist das speed-Feld privat und es kann nicht direkt darauf zugegriffen werden. Stattdessen bieten wir öffentliche get- und set-Methoden an, die den Zugriff auf das speed-Feld kontrollieren.

Insgesamt bieten diese Prinzipien der objektorientierten Programmierung in Java eine strukturierte Möglichkeit, komplexe Programme zu entwerfen und zu implementieren. Durch ein besseres Verständnis dieser Konzepte können wir effizienten und wiederverwendbaren Code schreiben.

Bis dahin, Happy coding!

← Kontrollstrukturen in Java

Grundlagen des Exception Handling →