// ===== 1. GRUNDLAGEN: KLASSEN UND OBJEKTE =====
// Einfache Klasse definieren
class Auto {
// Attribute (Eigenschaften)
String marke;
String farbe;
int baujahr;
// Konstruktor
public Auto(String marke, String farbe, int baujahr) {
this.marke = marke;
this.farbe = farbe;
this.baujahr = baujahr;
}
// Methoden (Verhalten)
public void starten() {
System.out.println(marke + " startet den Motor!");
}
public void fahren() {
System.out.println("Das " + farbe + "e " + marke + " fährt los.");
}
}
// Verwendung:
// Auto meinAuto = new Auto("BMW", "blau", 2020);
// meinAuto.starten();
// meinAuto.fahren();
// ===== 2. VERERBUNG (INHERITANCE) =====
// Basisklasse (Superklasse)
class Fahrzeug {
protected String marke;
protected int maxGeschwindigkeit;
public Fahrzeug(String marke, int maxGeschwindigkeit) {
this.marke = marke;
this.maxGeschwindigkeit = maxGeschwindigkeit;
}
public void beschleunigen() {
System.out.println(marke + " beschleunigt!");
}
public void bremsen() {
System.out.println(marke + " bremst!");
}
}
// Abgeleitete Klasse (Subklasse)
class Motorrad extends Fahrzeug {
private boolean hatSeitenwagen;
public Motorrad(String marke, int maxGeschwindigkeit, boolean hatSeitenwagen) {
super(marke, maxGeschwindigkeit); // Aufruf des Superklassen-Konstruktors
this.hatSeitenwagen = hatSeitenwagen;
}
// Eigene Methode
public void wheelie() {
System.out.println(marke + " macht einen Wheelie!");
}
// Methode überschreiben (Override)
@Override
public void beschleunigen() {
System.out.println(marke + "-Motorrad beschleunigt schnell auf " + maxGeschwindigkeit + " km/h!");
}
}
// ===== 3. POLYMORPHISMUS =====
// Abstrakte Basisklasse
abstract class Tier {
protected String name;
public Tier(String name) {
this.name = name;
}
// Abstrakte Methode - muss in Subklassen implementiert werden
public abstract void lautGeben();
// Konkrete Methode
public void schlafen() {
System.out.println(name + " schläft.");
}
}
class Hund extends Tier {
public Hund(String name) {
super(name);
}
@Override
public void lautGeben() {
System.out.println(name + " bellt: Wuff!");
}
}
class Katze extends Tier {
public Katze(String name) {
super(name);
}
@Override
public void lautGeben() {
System.out.println(name + " miaut: Miau!");
}
}
// Polymorphismus in Aktion:
class TierDemo {
public static void tierGeraeusche(Tier[] tiere) {
for (Tier tier : tiere) {
tier.lautGeben(); // Polymorphismus: richtige Methode wird automatisch gewählt
}
}
}
// ===== 4. INTERFACES =====
// Interface definieren
interface Schwimmbar {
void schwimmen(); // implizit public und abstract
// Default-Methode (seit Java 8)
default void tauchen() {
System.out.println("Taucht unter Wasser");
}
}
interface Flugfaehig {
void fliegen();
int getFlughoehe();
}
// Klasse kann mehrere Interfaces implementieren
class Ente extends Tier implements Schwimmbar, Flugfaehig {
public Ente(String name) {
super(name);
}
@Override
public void lautGeben() {
System.out.println(name + " quakt: Quak!");
}
@Override
public void schwimmen() {
System.out.println(name + " schwimmt im Teich");
}
@Override
public void fliegen() {
System.out.println(name + " fliegt durch die Luft");
}
@Override
public int getFlughoehe() {
return 100; // Meter
}
}
// ===== 5. COLLECTIONS =====
import java.util.*;
class CollectionsBeispiele {
public static void arrayListBeispiel() {
// ArrayList - dynamische Array
ArrayList<String> namen = new ArrayList<>();
namen.add("Anna");
namen.add("Bob");
namen.add("Charlie");
System.out.println("Namen: " + namen);
System.out.println("Erster Name: " + namen.get(0));
// Durchlaufen
for (String name : namen) {
System.out.println("Hallo " + name);
}
}
public static void hashMapBeispiel() {
// HashMap - Schlüssel-Wert-Paare
HashMap<String, Integer> alter = new HashMap<>();
alter.put("Anna", 25);
alter.put("Bob", 30);
alter.put("Charlie", 22);
System.out.println("Annas Alter: " + alter.get("Anna"));
// Alle Einträge durchlaufen
for (Map.Entry<String, Integer> eintrag : alter.entrySet()) {
System.out.println(eintrag.getKey() + " ist " + eintrag.getValue() + " Jahre alt");
}
}
public static void hashSetBeispiel() {
// HashSet - eindeutige Elemente
HashSet<String> staedte = new HashSet<>();
staedte.add("Berlin");
staedte.add("München");
staedte.add("Hamburg");
staedte.add("Berlin"); // Duplikat wird ignoriert
System.out.println("Anzahl Städte: " + staedte.size()); // 3, nicht 4
System.out.println("Städte: " + staedte);
}
}
// ===== 6. GENERICS =====
// Generische Klasse
class Box<T> {
private T inhalt;
public void setInhalt(T inhalt) {
this.inhalt = inhalt;
}
public T getInhalt() {
return inhalt;
}
public void zeigTyp() {
System.out.println("Typ: " + inhalt.getClass().getSimpleName());
}
}
// Generische Methode
class GenericsDemo {
public static <T> void vertausche(T[] array, int pos1, int pos2) {
T temp = array[pos1];
array[pos1] = array[pos2];
array[pos2] = temp;
}
// Bounded Type Parameter
public static <T extends Number> double quadrat(T zahl) {
return zahl.doubleValue() * zahl.doubleValue();
}
}
// ===== 7. PRAKTISCHE ANWENDUNG =====
class Bibliothek {
private ArrayList<Buch> buecher;
private HashMap<String, Benutzer> benutzer;
public Bibliothek() {
buecher = new ArrayList<>();
benutzer = new HashMap<>();
}
public void buchHinzufuegen(Buch buch) {
buecher.add(buch);
System.out.println("Buch '" + buch.getTitel() + "' hinzugefügt");
}
public void benutzerRegistrieren(String id, String name) {
benutzer.put(id, new Benutzer(id, name));
System.out.println("Benutzer " + name + " registriert");
}
public void buchAusleihen(String buchTitel, String benutzerId) {
Benutzer nutzer = benutzer.get(benutzerId);
if (nutzer != null) {
for (Buch buch : buecher) {
if (buch.getTitel().equals(buchTitel) && buch.istVerfuegbar()) {
buch.ausleihen();
nutzer.buchAusleihen(buch);
System.out.println(nutzer.getName() + " hat '" + buchTitel + "' ausgeliehen");
return;
}
}
}
System.out.println("Ausleihe nicht möglich");
}
}
class Buch {
private String titel;
private String autor;
private boolean verfuegbar;
public Buch(String titel, String autor) {
this.titel = titel;
this.autor = autor;
this.verfuegbar = true;
}
public String getTitel() { return titel; }
public boolean istVerfuegbar() { return verfuegbar; }
public void ausleihen() { verfuegbar = false; }
public void zurueckgeben() { verfuegbar = true; }
}
class Benutzer {
private String id;
private String name;
private ArrayList<Buch> ausgelieheneBuecher;
public Benutzer(String id, String name) {
this.id = id;
this.name = name;
this.ausgelieheneBuecher = new ArrayList<>();
}
public String getName() { return name; }
public void buchAusleihen(Buch buch) {
ausgelieheneBuecher.add(buch);
}
}
// ===== MAIN-METHODE ZUM TESTEN =====
class Main {
public static void main(String[] args) {
// 1. Einfache Objekte
Auto auto = new Auto("VW", "rot", 2023);
auto.starten();
// 2. Vererbung
Motorrad motorrad = new Motorrad("Harley", 200, false);
motorrad.beschleunigen(); // Überschriebene Methode
motorrad.wheelie(); // Eigene Methode
// 3. Polymorphismus
Tier[] tiere = {new Hund("Bello"), new Katze("Whiskers"), new Ente("Donald")};
for (Tier tier : tiere) {
tier.lautGeben(); // Jedes Tier macht seinen eigenen Laut
}
// 4. Collections
CollectionsBeispiele.arrayListBeispiel();
CollectionsBeispiele.hashMapBeispiel();
// 5. Generics
Box<String> textBox = new Box<>();
textBox.setInhalt("Hallo Welt");
System.out.println(textBox.getInhalt());
Box<Integer> zahlenBox = new Box<>();
zahlenBox.setInhalt(42);
zahlenBox.zeigTyp();
// 6. Praktisches Beispiel
Bibliothek bib = new Bibliothek();
bib.buchHinzufuegen(new Buch("Java Programmierung", "Max Mustermann"));
bib.benutzerRegistrieren("001", "Alice");
bib.buchAusleihen("Java Programmierung", "001");
}
}