OOP-Prinzipien Java: Einfache Codebeispiele

OOP-Prinzipien in Java: Einfache Codebeispiele

Die objektorientierte Programmierung (OOP) in Java basiert auf vier grundlegenden Prinzipien: Vererbung, Polymorphismus, Abstraktion und Kapselung. Diese Prinzipien helfen dir, sauberen, wiederverwendbaren und wartbaren Code zu schreiben. Hier sind einfache Codebeispiele, die dir helfen, diese OOP-Prinzipien Java besser zu verstehen.

Vererbung

Vererbung ermöglicht es dir, eine neue Klasse zu erstellen, die die Eigenschaften und Methoden einer bestehenden Klasse erbt. Dies fördert die Wiederverwendbarkeit von Code.

class Tier {
    void essen() {
        System.out.println("Das Tier isst");
    }
}
class Hund extends Tier {
    void bellen() {
        System.out.println("Der Hund bellt");
    }
}
public class Main {
    public static void main(String[] args) {
        Hund hund = new Hund();
        hund.essen(); // Ausgabe: Das Tier isst
        hund.bellen(); // Ausgabe: Der Hund bellt
    }
}

Polymorphismus

Polymorphismus ermöglicht es dir, eine Methode auf unterschiedliche Weise zu verwenden. Es gibt zwei Arten von Polymorphismus: Compile-Time (Methodenüberladung) und Run-Time (Methodenüberschreibung).

Methodenüberladung

class Mathe {
    int addieren(int a, int b) {
        return a + b;
    }
    double addieren(double a, double b) {
        return a + b;
    }
}
public class Main {
    public static void main(String[] args) {
        Mathe mathe = new Mathe();
        System.out.println(mathe.addieren(5, 3)); // Ausgabe: 8
        System.out.println(mathe.addieren(5.5, 3.3)); // Ausgabe: 8.8
    }
}

Methodenüberschreibung

class Tier {
    void lautGeben() {
        System.out.println("Das Tier macht ein Geräusch");
    }
}
class Katze extends Tier {
    @Override
    void lautGeben() {
        System.out.println("Die Katze miaut");
    }
}
public class Main {
    public static void main(String[] args) {
        Tier meinTier = new Katze();
        meinTier.lautGeben(); // Ausgabe: Die Katze miaut
    }
}

Abstraktion

Abstraktion hilft dir, komplexe Systeme zu vereinfachen, indem du nur die wesentlichen Details zeigst und die unwesentlichen verbirgst. Dies wird oft durch abstrakte Klassen und Schnittstellen erreicht.

abstract class Fahrzeug {
    abstract void fahren();
}
class Auto extends Fahrzeug {
    @Override
    void fahren() {
        System.out.println("Das Auto fährt");
    }
}
public class Main {
    public static void main(String[] args) {
        Fahrzeug meinAuto = new Auto();
        meinAuto.fahren(); // Ausgabe: Das Auto fährt
    }
}

Kapselung

Kapselung schützt die Daten einer Klasse, indem du den Zugriff auf diese Daten kontrollierst. Dies wird durch private Variablen und öffentliche Getter- und Setter-Methoden erreicht.

class Person {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("Max");
        System.out.println(person.getName()); // Ausgabe: Max
    }
}

Zusammenfassung

Die OOP-Prinzipien Java – Vererbung, Polymorphismus, Abstraktion und Kapselung – sind grundlegende Konzepte, die dir helfen, robusten und wartbaren Code zu schreiben. Die obigen Beispiele sollen dir einen einfachen Einstieg in diese Prinzipien bieten. Experimentiere mit diesen Beispielen und erweitere sie, um ein tieferes Verständnis zu erlangen.

Letztes Update vor 72 Tagen