Please enable JavaScript.
Coggle requires JavaScript to display documents.
V4 - Entwurf von eigenen Klassen - Coggle Diagram
V4 - Entwurf von eigenen Klassen
Stack
Objekte werden oben hinzugefügt/entfernt
Wichtige Methoden:
push(o) → fügt Objekt oben hinzu
pop() → entfernt und liefert oberstes Objekt
peek() → zeigt oberstes Objekt (ohne Entfernen)
size() → Anzahl der Elemente
isEmpty() → true, wenn leer
LIFO-Prinzip → Last In, First Out
Stack als Array
top = -1 → Stack ist leer
MAX_SIZE = feste maximale Größe
top zeigt auf das oberste Element
push(): top++, Element schreiben
Internes Array stack[] speichert die Daten
pop(): Element lesen, top--
peek(): Wert an stack[top]
Grenzen beachten: Array hat feste Größe!
isEmpty(): top == -1
Idee:
du nimmst ein Array (einfacher Speicherplatz),
aber packst es in eine Klasse mit Methoden, die sich wie ein Stack verhalten.
StaticStack
Klassenvariablen:
stack → Array für Werte
size → maximale Größe
top → Index des obersten Elements
Klassenmethoden:
initStack() → Initialisiert Stack
push(int) → Wert oben drauflegen
pop() → obersten Wert entfernen
size() → aktuelle Größe
Eigenschaften:
Nur int-Werte
Kein Über-/Unterlauf-Check
Feste Größe (nicht dynamisch)
Nur Zugriff auf statische Variablen
Statisch (static)
Stack existiert nur einmal
Methoden & Variablen sind nicht an Objekte gebunden
Verwendung
Innerhalb der Klasse können die Klassenmethoden ohne Klassennamen aufgerufen werden
Außerhalb ist die Angabe des Klassennamens verpflichtend (zugreifbar da public)
wichtig: Code von StaticStack nochmal anschauen in der PDF!!!! (pink markiert)
Objekterzeugung (mit "new")
new-Operator
Syntax: Stack s = new Stack();
Ruft den Konstruktor auf
Speicher wird reserviert
Neues Objekt entsteht im Arbeitsspeicher
Klasse = Bauplan, Objekt = gebautes Ding. Ohne new kein Objekt!
Objekte / Instanzen
Instanz = konkretes Objekt der Klasse
Mehrere Stack-Objekte möglich
Jedes hat eigene Werte & Methoden
Instanz statt statisch
Klasse Stack verwendet Instanzmethoden/-variablen
Kein static → jedes Objekt hat eigene Daten
s hat nun Referenz / Verweis / Zeiger auf Stack-Object
außerdem hat man jetzt zugriff auf alle elemente und methoden des stack-objekts
Information Hiding
Falscher Zugriff (Beispiel)
s1.top++ oder s1.size = 10
Compiler-Fehler: "private access"
Laufzeitfehler (Runtime Errors)
Treten erst während der Programmausführung auf.
Beispiel: stack[100] = 5; obwohl stack.length = 20 → ArrayIndexOutOfBoundsException
Oder: null.print() → NullPointerException
Programm startet, stürzt aber währenddessen ab
Müssen mit Fehlersuche (Debugging) gefunden werden
Compilerfehler (Syntaxfehler)
Werden beim Übersetzen (Kompilieren) erkannt.
Beispiel: s1.top++ obwohl top private ist → „private access“-Fehler
Oder: int 5zahl = 3; → falscher Variablenname
Verhindern, dass dein Programm überhaupt startet
Meist wegen falscher Syntax oder Zugriffsrechte
Logikfehler
Programm läuft ohne Absturz, macht aber nicht das, was du willst
Beispiel: top = top - 1; return stack[top]; in pop() – aber top ist nicht korrekt initialisiert
Oder: falsche Reihenfolge, Vergleiche, Schleifenbedingungen
Schwer zu finden
Nur durch Tests oder genaue Überprüfung erkennbar
Keine Fehlermeldung → falsches Ergebnis
Semantische Fehler (Bedeutungsfehler)
Ähnlich wie Logikfehler – du verwendest zwar korrekte Syntax, aber die Bedeutung ist falsch umgesetzt
z. B. du verwechselst = (Zuweisung) mit == (Vergleich)
Richtiger Zugriff
über öffentliche Methoden (initStack(), push(), print())
kontrollierter Zugriff
verhindert fehlerhafte Manipulation
private
Nur innerhalb der Klasse sichtbar
schützt interne Daten (z. B. top, size)
verhindert direkten Zugriff von außen
Beim Programmieren willst du oft, dass andere Teile des Programms nicht einfach direkt auf die inneren Daten deiner Klasse zugreifen können. Das nennt man "Information Hiding" oder "Datenkapselung".
Warum?
Weil du nicht willst, dass jemand versehentlich oder absichtlich z. B. top++ oder size = 10 direkt schreibt – das könnte den Stack kaputt machen!
Ziel
Sicherheit und Stabilität
klare Trennung: Was darf man von außen tun?
Instanz VS Klassenvariablen
Klassenvariablen (static)
z. B. count
existieren einmal für die ganze Klasse
werden mit static deklariert
gelten für alle Objekte gemeinsam
Information Hiding
Zugriff auf Variablen nur über Methoden
verhindert direkten Zugriff von außen (private)
schützt z. B. count vor Manipulation
Instanzvariablen
top, size, stack
pro Objekt neu angelegt
jedes Objekt hat eigene Daten
kein static
Konstruktoren
Merkmale:
Kein Ergebnistyp (auch nicht void)
Name ist identisch zum Klassennamen
Mehrere Konstruktoren pro Klasse möglich ( überladen von konstruktoren (Bedingung: Parameter müssen sich unterscheiden (Anzahl oder Typ)))
Konstruktor-Auswahl
Erfolgt über die beim Aufruf angegebenen Parameter
Beispiel 1: new Stack() --> ruft Stack() auf
Beispiel 2: new Stack(10) --> ruft Stack(int size) auf
jedoch führt konstruktoren überladen oftmals zu doppeltem Code!
Definition
Methode zur Initialisierung von Objekten
Wird bei Objekterzeugung mit new automatisch aufgerufen
this-Referenz
Verwendung (optional)
Zur Hervorhebung des Zugriffs auf Instanzvariable
Verbessert die Lesbarkeit
Verwendung (nötig)
Wenn Parametername = Instanzvariablenname
Löst "Verdeckung" (Shadowing) auf
Beispiel: this.size = size;
Verweist auf das aktuelle Objekt
Ausgabe von Objekten
Besserer Ansatz: toString()-Methode überschreiben
Konzept: Standardmethode jeder Klasse, die eine textuelle Repräsentation des Objekts liefert
Aufgabe: Gibt einen String zurück (return)..
Vorteile:
Flexibel: Der zurückgegebene String kann beliebig verwendet werden (Konsole, Datei, GUI, ...).
Entkopplung: Die Klasse ist nicht mehr für die Ausgabe selbst verantwortlich.
Wird von System.out.println() automatisch aufgerufen.
Schlechter Ansatz: Eigene print Methode
gibt daten direkt auf die konsole aus (zB System.out.println)
Nachteil: unflexibel, da fest an ein Ausgabemedium (Konsole) gebunden
Implementierungstipp: StringBuilder verwenden, um Strings effizient (besonders in Schleifen) zusammenzubauen.