SibiWiki - Benutzerbeiträge [de]

SQL

2026-03-21T14:42:55Z

Akaibel: /* Fachbegriffe */

[[Kategorie:Datenbanken]]
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Informatik]]

'''''Diese Seite ist für die Oberstufe (Jahrgang 11-13). Für SQL in der 10. Klasse hier klicken: [[SQL-09]]'''''

Hier finden sich Erläuterungen zu allen SQL-Techniken, die für das Zentralabitur wichtig sind.

Zu diesen Techniken gibt es auch '''[[SQL-Aufgaben|Aufgaben]]''', die man zur Übung selber bearbeiten kann.

=Erklärvideos=
* [https://youtu.be/J425xx6PVxs Abfragen mit GROUP BY (06:15min)]

* [https://youtu.be/ZPna0CmGuQg Abfragen über mehrere Tabellen]

* [https://youtu.be/rUkVjvlX2Eg Abfragen mit NOT IN bzw. mit IN]

* [https://youtu.be/TZjt6gvRfl8 Abfrage über selbstdefinierte Tabellen]

* [https://youtu.be/GohWF9SnhWM ChatGPT nutzen, um SQL zu schreiben]

=Fachbegriffe=
Vereinigung, Differenz, kartesisches Produkt, Abgleich der Tabellen über..., geschachtelte Abfrage, äußere Abfrage, innere Abfrage 

Außerdem die SQL-Sprachelemente (s.u.)

==SQL-Sprachelemente im Zentralabitur==

Informationen des Zentralabiturs (PDF): [[Datei:Datenbanken-Abi-2012.pdf]]

'''Die folgenden SQL-Befehle muss man im Zentralabitur beherrschen:'''

''Sie werden hier systematisch aufgeführt, wie man sie sich am besten merkt.''
* Befehle:
** SELECT, SELECT DISTINCT ... AS
** FROM
** JOIN ... ON, LEFT JOIN ... ON, RIGHT JOIN ... ON
** WHERE (... z.B. mit IS NULL)
** GROUP BY
** ORDER BY ... ASC (bzw. DESC)
** UNION
** Tabellen selbst definieren mit AS
* Vergleichsoperatoren:
** =, !=, >, <, >=, <=,
** LIKE (in Verbindung mit dem %-Joker)
** BETWEEN ... AND
** IN (SELECT ...)
** NOT IN (SELECT ...)
** IS NULL
* Arithmetische Operatoren: +, -, *, /, (...)
* Logische Operatoren: AND, OR, NOT
* Funktionen: COUNT, SUM, MAX, MIN, AVG
* sonstiges: Die Joker % (in Kombination mit LIKE) und * (z.B. SELECT * oder SELECT COUNT(*) )

'''Was man noch können muss:'''
* '''[[SQL#Abfragen_über_mehrere_Tabellen|Abfragen über mehrere Tabellen]]''' formulieren:
** mit '''[[SQL#Kartesisches_Produkt|kartesischem Produkt]]''' und '''[[SQL#Abgleich_zwischen_mehreren_Tabellen|Abgleich]]'''
** mit '''[[SQL#Join|JOIN]]''' bzw. '''LEFT JOIN''' und '''RIGHT JOIN'''
** mit '''[[SQL#Differenz_(NOT_IN)|Differenz (NOT IN)]]'''
* '''[[SQL#Geschachtelte_SQL-Ausdrücke|Geschachtelte SQL-Ausdrücke]]'''
* '''[[SQL#SQL_analysieren|SQL analysieren]]''': Häufig sind das geschachtelte SQL-Abfragen.

==Beispieldatenbank Schule==
* An der Beispieldatenbank Schule können alle möglichen Datenbankabfragen durchprobiert werden.
* Die Beispieldatenbank ist mit Absicht sehr schmal gehalten, damit man die Ergebnisse von SQL-Abfragen noch überprüfen kann.
* Testen kann man SQL-Abfragen auf der Datenbank Schule: '''[http://sibiwiki.de/sql/ hier klicken]'''. Die Zugangsdaten gibt's bei Herrn Kaibel
* ''Wer nicht am SIBI ist, hat folgende Möglichkeiten:''
** ''Die Beispieldatenbank Schule als SQL-Lite Datenbank herunterladen: [[Datei:Schule.sqlite.zip]] Zum Öffnen braucht man [https://sqlitebrowser.org/ DB Browser für SQLite]''
** ''Einen SQL-Dump der Beispieldatenbank Schule herunterladen: [[Datei:Beispieldatenbank-schule.zip]] und z.B. mit phpmyadmin in eine eigene Datenbank importieren.''

[[Datei:Beispieldatenbank-schule.jpg]]
 
===relationales Datenmodell der Datenbank Schule===
<code>
schueler(id,↑klasse_id,name,vorname)
klasse(id,↑klassenlehrer_id,name)
lehrer(id,name,vorname)
unterricht(id,↑klasse_id,↑lehrer_id,↑raum_id,fach,stunden)
raum(id,nummer,etage,plaetze)
ag(id,↑lehrer_id,name)
teilnahme(↑schueler_id,↑ag_id)
</code>

==Aufbau von SQL-Abfragen==
Für den Aufbau von SQL-Abfragen gilt folgende Reihenfolge:
<code>
'''SELECT ...'''
'''FROM ...'''
WHERE ...
GROUP BY ...
ORDER BY ...
LIMIT ...
</code>

<code>SELECT</code> und <code>FROM</code> müssen auf jeden Fall dabei sein, die anderen Teile sind optional.

=Abfragen über eine Tabelle =
''Begriffsklärung: Relation: (hier:) Tabelle''

Bei Datenbanken versteht man unter einer '''Relationenalgebra''' eine formale Sprache, mit der sich Abfragen über eine oder mehrere Tabellen (=Relationen) formulieren lassen. Sie erlaubt es, Tabellen miteinander zu verknüpfen, zu reduzieren oder komplexere Informationen daraus herzuleiten.

===Projektion (SELECT) ===
Unter Projektion versteht man die Reduktion der Informationen in dem Ergebnis auf ein oder mehrere Attribute (=Spalten). 
In unserem Beispiel werden zusätzlich doppelte Zeilen werden entfernt. Dafür braucht man das Schlüsselwort <code>DISTINCT</code>, das hat aber mit der eigentlichen Projektion auf einzelne Spalten nichts zu tun.

'''Beispiel:'''

Formuliere für die Tabelle <code>raum</code> eine Projektionsabfrage, die die Etagen mit Projektion wiedergibt.

<code>
'''SELECT''' DISTINCT r.etage
FROM raum r
</code>

''Beachte: Entscheidend für die Projektion ist es, dass man bei <code>SELECT</code> einzelne Attribute angibt.''

===Selektion (WHERE)===
Selektion bedeutet, dass Datensätze (=Zeilen) ausgewählt werden, die eine bestimmte Bedingung erfüllen.

Formuliere eine Selektionsabfrage, die alle Nummern der Räume mit mindestens 30 Plätzen zurückgibt.

<code>
SELECT r.nummer
FROM raum r
'''WHERE''' r.plaetze >= 30
</code>

''Beachte: Das entscheidende Schlüsselwort für die Selektion ist <code>WHERE</code>, denn hier wird die Bedingung festgelegt.''

Formuliere eine Selektionsabfrage, die alle Informationen zu Räumen mit mindestens 30 Plätzen zurückgibt.

<code>
SELECT *
FROM raum r
'''WHERE''' r.plaetze >= 30
</code>

''Beachte: Mit dem Joker * im SELECT-Teil der Abfrage werden alle Attribute ausgewählt.''

=Erläuterung einzelner SQL-Befehle=
Im folgenden werden einzelne SQL-Befehle jeweils am Beispiel erläutert.

== Aggregat-Funktionen (COUNT, MAX, MIN, SUM, AVG) ==
Mit den sog. Aggregat-Funktionen kann man Attributwerte aus mehreren Zeilen zusammenfassen.

=== Kurze Erklärung ===
* '''COUNT''': zählt
* '''SUM''': addiert
* '''AVG''': berechnet den Durchschnitt (average)
* '''MAX''': bestimmt das Maximum
* '''MIN''': bestimmt das Minimum

===Beispiele===

'''Beispiel 1:'''

Mit der folgenden Abfrage kann man ermitteln, wie viele Schüler es gibt. 
Man zählt die Zeilen; deswegen braucht man COUNT (und nicht SUM).

<code>
SELECT '''COUNT(*)'''
FROM schueler s
</code>

Hinweis: 
COUNT(*) übersetzt sich am einfachsten als "Zähle die Zeilen". 
Wenn man stattdessen COUNT(s.name) nehmen würde, dann würden nur die Zeilen gezählt, wo beim Namen ein Eintrag vorhanden ist. (Das sind hier aber alle).

'''Beispiel 2:'''

Mit der folgenden Abfrage kann man ermitteln, wie viele Stunden Sport unterrichtet werden. 
Hier muss man die Attributwerte <code>stunden</code> addieren, deswegen braucht man SUM.

<code>
SELECT '''SUM(u.stunden)'''
FROM unterricht u
WHERE u.fach = 'Sport'
</code>

'''Beispiel 3:'''

Mit der folgenden Abfrage ermittelt man...
* die maximale Zahl der Plätze in einem Raum,
* die minimale Zahl der Plätze in einem Raum,
* die durchschnittliche Zahl der Plätze in allen Räumen.

<code>
SELECT '''MAX(r.plaetze)''', '''MIN(r.plaetze)''', '''AVG(r.plaetze)'''
FROM raum r
</code>

=== Wann braucht man COUNT(...) und wann braucht man SUM(...) ?! ===
COUNT und SUM werden leicht verwechselt!

Als Faustregel kann man sagen:
* COUNT, wenn gezählt wird,
* SUM, wenn addiert wird.

Das ist aus der Aufgabenstellung nicht immer offensichtlich!

Beispiel 1: 
Man hätte gerne die Anzahl der Plätze in allen Räumen.

Beispiel 2: 
Man hätte gerne die Anzahl der Räume.

Lösung:
* in Beispiel 1 wird die Anzahl der Plätze (im Attribut plaetze) addiert, deswegen SUM(r.plaetze)
* in Beispiel 2 wird die Anzahl der Räume gezählt, deswegen COUNT(r.id) oder COUNT(*)

===COUNT(DISTINCT ...)===
'''Beispiel:''' 
Wie viele Fächer gibt es?
<code>
SELECT COUNT(DISTINCT u.fach)
FROM unterrricht u
</code>

Durch DISTINCT wird jedes Fach nur einmal berücksichtigt!

==LIKE und der %-Joker==
Der %-Joker kann in einer Abfrage beliebige Zeichen ersetzen.

Den %-Joker darf man nicht mit dem exakten Vergleich (=) einsetzen; stattdessen nimmt man für den Vergleich das Schlüsselwort '''<code>LIKE</code>'''.

'''Beispiel:'''

Eine Liste aller Schüler, die ein Doppel-n ('nn') im Vornamen haben.

<code>
SELECT s.vorname AS vorname, s.name AS name
FROM schueler s
WHERE s.vorname LIKE '%nn%'
</code>

''Beachte: Vor und hinter dem nn steht ein %-Joker, d.h. hier können beliebige Buchstaben stehen. "Beliebig" kann auch heißen: Kein Buchstabe! D.h. "Johann" wäre auch ein akzeptierter Vorname.

==GROUP BY==
Mit <code>GROUP BY</code> kann man Zeilen, die einen gemeinsamen Attributwert aufweisen, zusammenfassen.

'''Beispiel:'''

Mit der folgenden Abfrage erhält man eine Liste der Etagen, und für jede Etage wird notiert, wie viele Plätze in ihr insgesamt enthalten sind.

<code>
SELECT r.etage, SUM(plaetze)
FROM raum r
'''GROUP BY''' r.etage
</code>

''Beachte: Durch <code>GROUP BY r.etage</code> werden alle Zeilen, die bei <code>r.etage</code> den Wert 'unten' haben, in einer Zeile zusammengefasst. Genauso alle Zeilen, die bei <code>r.etage</code> den Wert 'Mitte' (bzw. 'oben') haben.''

''Dadurch, dass man so zusammenfasst, kann jetzt für jede Etage die Summe der Plätze berechnet werden.''

[https://youtu.be/J425xx6PVxs Erklärvideo zu GROUP BY (06:15min)]


==Umbenennung (AS)==
Attribute können umbenannt werden.

'''Beispiel 1:'''

Formuliere eine Abfrage über die Attribute klasse_id, lehrer_id, raum_id, fach und stunden der Tabelle unterricht. Dabei soll klasse_id in klassen-nr, lehrer_id in lehrer_nr und raum_id in raum-nr umbenannt werden.

<code>
SELECT u.klasse_id '''AS''' klassennr,u.lehrer_id '''AS''' Lehrernr,u.raum_id '''AS''' Raumnr,u.fach,u.stunden '''AS''' stunden
FROM unterricht u
</code>

'''Beispiel 2:'''

Formuliere eine Abfrage, die eine Liste der Etagen zurückgibt. Für jede Etage soll angegeben werden, wie viele Plätze es in der Etage gibt.
Die Liste soll nach der Anzahl der Plätze sortiert sein.

<code>
SELECT r.etage, SUM(plaetze) AS PlaetzeInEtage
FROM raum r
GROUP BY r.etage
ORDER BY PlaetzeInEtage
</code>

''Beachte: Für <code>SUM(plaetze)</code> wird ein Alias (<code>PlaetzeInEtage</code>) vergeben. Mithilfe des Alias kann man am Ende nach der Anzahl der Plätze sortieren!''

==Mehrere Bedingungen: AND, OR, BETWEEN==
In SQL-Abfragen kann man mehrere Bedingungen kombinieren. Dafür gibt es die Schlüsselwörter AND, OR und BETWEEN

===AND / OR===
Mit AND / OR kann man zwei Bedingungen verknüpfen.

'''Beispiel:'''

<code>
SELECT r.nummer, r.plaetze
FROM raum r
WHERE r.etage = 'unten' '''OR''' r.etage = 'Mitte'
</code>

===BETWEEN===
Mit BETWEEN ... AND kann man Intervalle angeben.

'''Beispiel:'''

<code>
SELECT r.nummer, r.plaetze
FROM raum r
WHERE r.plaetze '''BETWEEN''' 30 '''AND''' 50
</code>

===LIMIT===
Mit LIMIT kann man angeben, wie viele Zeilen ausgegeben werden.

'''Beispiel:'''
Die folgende SQL-Anweisung gibt den Raum (Nummer, Platzanzahl) mit den meisten Plätzen aus.

Es wird eine Liste von allen Räumen erstellt, aber nur die erste Zeile der Liste
(d.h. der Raum mit den meisten Plätzen) wird ausgegeben.

<code>
SELECT r.nummer, r.plaetze
FROM raum r
ORDER BY r.plaetze DESC
'''LIMIT 1'''
</code>

=Abfragen über mehrere Tabellen=

===Vereinigung (UNION)===
Vereinigung bedeutet, dass die Ergebnis-Datensätze von zwei Abfragen zu einem Ergebnis zusammengefügt werden. Voraussetzung dafür ist, dass beide Abfragen gleich viele Attribute abfragen.

Formuliere eine Abfrage, die Name und Vorname von allen Lehrern UND Schülern wiedergibt.

<code>
SELECT l.name, l.vorname
FROM lehrer l
'''UNION'''
SELECT s.name, s.vorname
FROM schueler s
</code>

===Differenz (NOT IN) ===
Differenz bedeutet, dass die Ergebnis-Datensätze einer Abfrage a1 von den Ergebnis-Datensätzen einer Abfrage a0 abgezogen werden - es bleibt dann ein Rest übrig.

Formuliere eine Abfrage, die alle Klassen ausgibt, die KEIN Mathematik haben.

Idee: Die Klassen, die Mathematik haben, von allen Klassen abziehen.

<code>
SELECT k.name
FROM klasse k
WHERE k.id '''NOT IN'''
(
SELECT u.klasse_id
FROM unterricht u
WHERE u.fach='Mathe'
)
</code>

===IN===
Das logische Gegenteil zu NOT IN ist entsprechend IN.
Dieses Schlüsselwort kann man u.a. verwenden, wenn man in einer Abfrage zwei Datensätze einer Entitätsmenge hat.
Beispiel: Welche Schüler sind in der selben Klasse wie Anne Ebert?

Idee: In der äußeren Abfrage werden die Schüler gesucht; mit IN kann man dann die klasse_id von Anne Ebert angeben.

<code>
SELECT s.name, s.vorname
FROM schueler s
WHERE s.klasse_id '''IN'''
(
SELECT s2.klasse_id
FROM schueler s2
WHERE s2.name = 'Ebert'
)
</code>

===Kartesisches Produkt===
In der Mathematik bezeichnet man als kartesisches Produkt (nach René Descartes) zweier Mengen A und B die Menge aller geordneten Paare (a,b), wobei a aus A und b aus B ist. (Kombination: „Jedes mit jedem“.) Geschrieben wird es als '''A x B''' gelesen als A kreuz B.

''Kurz: Jeder mit jedem''.

Formuliere eine Abfrage für das kartesische Produkt von den Tabellen klasse und schueler.

<code>
SELECT *
FROM '''klasse k, schueler s'''
</code>

Diese Abfrage liefert als Ergebnis "Jeder mit jedem". Inhaltlich ist das nicht sinnvoll.

Damit das kartesische Produkt sinnvoll wird, braucht man einen Abgleich zwischen den Tabellen; vgl. [[SQL#SQL-Abfrage über mehrere verknüpfte Tabellen|SQL-Abfrage über mehrere verknüpfte Tabellen]]

===Abgleich zwischen mehreren Tabellen===
Formuliere eine Abfrage, die angibt, in welchen Räumen die Klasse 8a unterrichtet wird.
Die Abfrage läuft über die Tabellen klasse, unterricht und raum.

<code>
SELECT r.nummer
FROM klasse k, unterricht u, raum r
'''WHERE r.id=u.raum_id'''
'''AND u.klasse_id=k.id'''
AND k.name = '8a'
</code>

'''Wichtig:''' bei Abfragen über mehrere Tabellen braucht man einen Abgleich weniger als man Tabellen abfragt.

Im Beispiel werden drei Tabellen abgefragt; deswegen braucht man zwei Abgleiche.

===JOIN / INNER JOIN===
Join ist die Bildung eines [[SQL#Kartesisches_Produkt|kartesischen Produktes]] gefolgt von einer Selektion, die den (richtigen) Abgleich zwischen den beiden Tabellen leistet.

Beispiel: Eine Liste der Schüler, in der für jeden Schüler vermerkt wird, in welcher Klasse er ist.

<code>
SELECT s.name AS schuelername, k.name AS klassename
FROM schueler s '''JOIN''' klasse k
'''ON''' s.klasse_id = k.id
</code>

Mit einem JOIN werden nur VOLLSTÄNDIGE Datensätze angezeigt. D.h. im Beispiel fallen Schüler, die keine Klasse haben, und Klassen, die keine Schüler haben, raus.

Der Join entspricht der [[SQL#SQL-Abfrage über mehrere verknüpfte Tabellen|SQL-Abfrage über mehrere verknüpfte Tabellen]]

Statt <code>JOIN</code> kann man auch ausführlicher <code>INNER JOIN</code> schreiben. Dies wird in den Analyseaufgaben der Abiturklausuren häufig verwendet.

===LEFT JOIN===
Beim '''Left''' Join werden auch die Zeilen der '''linken''' Tabelle aufgeführt, die keinen Partner in der rechten Tabelle haben. In der rechten Tabelle wird ggf. mit ''NULL'' aufgefüllt.

Formuliere eine Abfrage, die einen Left-Join zwischen den Tabellen klasse und schueler durchführt.
Bewerte das Ergebnis inhaltlich: In welchen Zusammenhängen braucht man Left-Join?

<code>
SELECT s.name AS schuelername, k.name AS klassename
FROM schueler s '''LEFT JOIN''' klasse k
'''ON''' s.klasse_id = k.id
</code>

Beim LEFT JOIN werden ALLE Daten der LINKEN Entitätsmenge angezeigt. Im Beispiel werden also auch die Schüler angezeigt, die keine Klasse haben.

===RIGHT JOIN===
Beim '''Right''' Join werden auch die Zeilen der '''rechten''' Tabelle aufgeführt, die keinen Partner in der linken Tabelle haben. In der linken Tabelle wird ggf. mit ''NULL'' aufgefüllt.

Formuliere eine Abfrage, die einen Right-Join zwischen den Tabellen klasse und schueler durchführt.

<code>
SELECT s.name AS schuelername, k.name AS klassename
FROM schueler s '''RIGHT JOIN''' klasse k
'''ON''' s.klasse_id = k.id
</code>

Beim RIGHT JOIN werden ALLE Daten der RECHTEN Entitätsmenge angezeigt. Im Beispiel werden also auch die Klassen angezeigt, die keine Schüler haben.

===LEFT JOIN (bzw. RIGHT JOIN) über 3 oder mehr Tabellen ===
Wenn man einen LEFT JOIN über insgesamt 3 Tabellen machen will, verwendet man am einfachsten zwei LEFT JOIN. 

Beispiel: Eine Liste aller Schüler, in der steht, welche AGs sie belegen.
<code>
SELECT s.name as schueler, a.name as ag
FROM schueler s
LEFT JOIN teilnahme t
ON s.id = t.schueler_id
LEFT JOIN ag a
ON t.ag_id = a.id
</code>

===IS NULL===
Formuliere eine Abfrage, die alle Schüler zurückgibt, die keine Klasse haben.

<code>
SELECT s.name AS schuelername, k.name AS klassename
FROM schueler s LEFT JOIN klasse k
ON s.klasse_id = k.id
WHERE k.id '''IS NULL'''
</code>

Beim LEFT JOIN werden ALLE Daten der LINKEN Entitätsmenge angezeigt, also auch die Schüler, die keine Klasse haben.
Diese Schüler werden durch <code>k.id IS NULL ausgewählt</code>.

===Abfragen, bei denen man mehrere Variablen einer Entitätsmenge braucht===
Formuliere eine Abfrage, die alle Räume wiedergibt, die mehr Plätze haben als Raum R203.

''Idee: ''
* ''Man hat den bekannten Raum r1 mit der Nummer "R203".''
* ''Außerdem hat man den gesuchten Raum r2, der mehr Plätze hat als Raum r1.''

<code>
SELECT r2.nummer
FROM '''raum r1''', '''raum r2'''
WHERE r1.nummer = "R203"
AND r2.plaetze > r1.plaetze
</code>

=Abfragen über selbstdefinierte Tabellen=

'''Man kann die Tabellen, die man bei FROM angibt, durch eigene SELECT-Anfrage selber definieren.'''

Die selbstdefinierten Tabellen müssen mit einem Alias benannt und durch ein Komma voneinander getrennt werden. Dann können sie wie "normale" Tabellen genutzt werden.

'''Beispiel:'''
''Eine Liste der Klassen, in der steht, wieviel Prozent Sportunterricht sie haben.''

<code>
SELECT gesamtstunden.klasse AS klasse, sportstunden.stunden/gesamtstunden.stunden * 100 AS prozent
FROM
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden
FROM klasse k LEFT JOIN unterricht u
ON k.id = u.klasse_id
GROUP BY k.name
) AS gesamtstunden
'''LEFT JOIN'''
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden
FROM klasse k, unterricht u
WHERE k.id = u.klasse_id
AND u.fach = 'Sport'
GROUP BY k.name
) AS sportstunden'''
'''ON sportstunden.klasse = gesamtstunden.klasse'''
</code>

'''Erläuterung:'''

* In FROM werden zwei Tabellen definiert: Die Tabelle '''gesamtstunden''' und die Tabelle '''sportstunden'''.
* Diese Tabellen werden mit einem '''LEFT JOIN ... ON''' verknüpft.
* Außerdem erhalten sie mithilfe von AS Aliasnamen: '''AS gesamtstunden''' (bzw. '''AS sportstunden''').
* Mithilfe dieser Aliasnamen kann die äußere Abfrage auf die beiden Tabellen zugreifen.

'''WICHTIG:'''
Man muss jeder inneren SELECT-Abfrage mithilfe von '''AS''' einen '''Namen''' geben - nur dann ist sie in der äußeren SELECT-Abfrage ansprechbar!

=SQL analysieren=
In Klausuren (auch im Abi) muss SQL analysiert werden.

Meistens muss man dabei ein SQL-Statement auf vorliegende Tabellen anwenden; es kann aber auch vorkommen, dass man ein SQL-Statement erläutern muss.

Dafür wird hier ein '''Beispiel''' gegeben.

'''SQL-Statement:'''

<code>
SELECT gesamtstunden.klasse AS klasse, sportstunden.stunden/gesamtstunden.stunden * 100 AS prozent
FROM
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden
FROM klasse k LEFT JOIN unterricht u
ON k.id = u.klasse_id
GROUP BY k.name
) AS gesamtstunden
'''LEFT JOIN'''
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden
FROM klasse k, unterricht u
WHERE k.id = u.klasse_id
AND u.fach = 'Sport'
GROUP BY k.name
) AS sportstunden'''
'''ON sportstunden.klasse = gesamtstunden.klasse'''
</code>

'''Aufgaben:'''
# Erläutern Sie die '''Funktionsweise''' dieser SQL-Abfrage.
# Erläutern Sie, welchem '''Zweck''' diese SQL-Abfrage dient.

Folgendermaßen könnte eine Bearbeitung aussehen; wichtige Schlüsselwörter und Passagen sind unterstrichen.

'''Funktionsweise:'''

Die SQL-Abfrage besteht aus einer äußeren Abfrage, die auf zwei selbstdefinierte Tabellen zugreift.
Der ersten selbstdefinierten Tabelle wurde mit "AS gesamtstunden" der Name <code>gesamtstunden</code> gegeben, der zweiten selbstdefinierten Tabelle der Name <code>sportstunden</code>.

In der Tabelle <code>gesamtstunden</code> wird mithilfe von GROUP BY eine Liste der Klassen-Namen erstellt, in der für jede Klasse die Gesamtzahl der unterrichteten Stunden angegeben wird. In der Tabelle <code>sportstunden</code> geschieht dasselbe für die Sportstunden.

In der äußeren Abfrage werden diese beiden selbstdefinierten Tabellen mithilfe eines LEFT JOIN über die Spalten sportstunden.klasse = gesamtstunden.klasse verknüpft.

So werden in der Ergebnistabellen alle Zeilen der Tabelle <code>gesamtstunden</code> berücksichtigt, aber nicht unbedingt alle Zeilen der Tabelle <code>sportstunden</code>.

Die äußere Abfrage übernimmt im SELECT die Spalte <code>klasse</code> aus der Tabelle <code>gesamtstunden</code> und berechnet dann aus <code>sportstunden.stunden</code> und <code>gesamtstunden.stunden</code>, wie viel Prozent Sport erteilt wird.

'''Zweck:'''

Die SQL-Abfrage gibt eine Liste aller Klassen zurück, die Unterricht haben. Für jede Klasse wird angegeben, wie viel Prozent ihrer Unterrichtsstunden Sportstunden sind. Die 8D hat zwar keinen Unterricht, durch die (zweifache) Verwendung von LEFT JOIN wird sie dennoch angezeigt, in der rechten Spalte steht dann NULL statt einer Prozentzahl.

=HAVING=
'''Nicht abiturrelevant, aber sehr nützlich!'''

Manchmal hat man eine Zahl gerade erst mit einer Aggregatfunktion (z.B. <code>SUM</code>) ermittelt und möchte für diese Zahl direkt eine Bedingung festlegen.

Das kann man mit <code>WHERE</code> nicht tun, denn <code>WHERE</code> funktioniert nur für "fest" definierte Zahlen!

Für diesen Fall wurde das Schlüsselwort <code>HAVING</code> entwickelt.

'''Beispiel:'''
Eine Liste der Fächer, in der die Gesamtzahl der Stunden vermerkt ist, die sie unterrichtet werden. Es sollen nur Fächer aufgeführt werden, die mehr als 7 Stunden unterrichtet werden.

''Beachte: Die Gesamtzahl der Stunden muss mit einer Aggregatfunktion (SUM) ermittelt werden. Deswegen kann man für die Gesamtzahl keine <code>WHERE</code>-Bedingung formulieren - das würde zu einem Syntax-Fehler führen.''

''Lösen lässt sich das mit <code>HAVING</code>:

<code>
SELECT u.fach, SUM(u.stunden) AS stunden
FROM unterricht u
GROUP BY u.fach
HAVING stunden > 7
ORDER BY stunden DESC
</code>

=Mit Java auf eine SQL-Datenbank zugreifen=
Das wird hier erklärt: [[Java-SQL]]

=ChatGPT nutzen um SQL zu schreiben=

''Last not least wollen wir nicht verheimlichen, dass ChatGPT ein großartiges Hilfsmittel ist, um SQL zu schreiben!''

==Erklärvideo==
[https://youtu.be/GohWF9SnhWM ChatGPT nutzen, um SQL zu schreiben]

==Best practices==
* ''ChatGPT kann extrem cool SQL programmieren!! Es verfügt über einen SQL-Wortschatz, von dem selbst die Informatik-Lehrer noch nie gehört haben!''
* '''''ABER:''' ChatGPT ist ziemlich begriffsstutzig! Man muss sehr genau erklären, was man will.''

'''Empfehlungen:'''

# Zu Anfang: '''Kontext herstellen!''' (-> Datenbankschema!)
# '''Genau''' mitteilen, was man will, mit '''Fachbegriffen'''.
# '''Testen''': Natürlich macht ChatGPT auch beim Programmieren Fehler. Der große Vorteil ist aber, dass man das - mit gut gewählten Beispielen - direkt überprüfen kann! Und wenn der SQL-Code einen Fehler hat, dann hilft nur...
# '''„Nachkarten“:''' ''Das ist sehr wichtig! Denn mit etwas Hartnäckigkeit kann man ChatGPT dazu bringen, das Richtige zu tun!'' Für das "Nachkarten" empfiehlt sich:
## '''Fehlermeldungen''' von SQL an ChatGPT weiter geben.
## '''Fachbegriffe''' verwenden
## '''Beziehungen klären''' z.B.: "Die Tabelle schueler ist über die Tabelle klasse mit der Tabelle unterricht verknüpft." z.B.: "Fach ist ein Attribut der Tabelle unterricht."
## '''Das Datenbankmodell nochmal mit Copy&Paste eintragen.''' Informationen "verblassen" im Laufe der Zeit.
## Gegebenenfalls '''SQL-Schlüsselwörter vorgeben''': z.B. "Verwende NOT IN"
# Wenn alles nichts hilft:
## eine '''neue Unterhaltung anfangen''', d.h. einfach nochmal von vorne. ''Die Antworten von ChatGPT beruhen auf Wahrscheinlichkeiten, d.h. es kann gut sein, dass man bei genau der selben Anfrage eine andere Lösung bekommt.''
## '''Auf Englisch fragen.''' ''ChatGPT wurde mit wesentlich mehr englischen Daten trainiert, d.h. die Erfolgschancen sind auf Englisch größer.''

==Vorteile==
* ChatGPT steht ein sehr breites SQL-Vokabular zur Verfügung! Da sind Schlüsselwörter dabei, die man selber höchstens zum "passiven" Wortschatz zählen würde.
* ChatGPT kann (wenn alles gut geht) SQL-Statements von ziemlicher Eleganz entwickeln.
* Wenn man das Datenbankschema mitteilt und die Tabellen und Attribute verständlich benannt hat, dann kann sich ChatGPT auf einen beliebigen Kontext einstellen.
* Außerdem geht es natürlich extrem schnell.

==Datenbankschema für den Test==
''Das Datenbankschema muss man direkt am Anfang mitteilen!''
<code>
schueler(id,↑klasse_id,name,vorname)
klasse(id,↑klassenlehrer_id,name)
lehrer(id,name,vorname)
unterricht(id,↑klasse_id,↑lehrer_id,↑raum_id,fach,stunden)
raum(id,nummer,etage,plaetze)
ag(id,↑lehrer_id,name)
teilnahme(↑schueler_id,↑ag_id)
</code>

Testen kann man wie üblich hier:

[https://sibiwiki.de/sql/ sibiwiki.de/sql]

(Zugangsdaten beim Informatik-Lehrer am SIBI.)

Wer nicht am SIBI ist, kann sich einen Dump der Datenbank Schule hier herunterladen: [[Datei:Beispieldatenbank-schule.zip]]

SQL

2026-03-21T14:39:49Z

Akaibel: /* SQL-Sprachelemente im Zentralabitur */

[[Kategorie:Datenbanken]]
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Informatik]]

'''''Diese Seite ist für die Oberstufe (Jahrgang 11-13). Für SQL in der 10. Klasse hier klicken: [[SQL-09]]'''''

Hier finden sich Erläuterungen zu allen SQL-Techniken, die für das Zentralabitur wichtig sind.

Zu diesen Techniken gibt es auch '''[[SQL-Aufgaben|Aufgaben]]''', die man zur Übung selber bearbeiten kann.

=Erklärvideos=
* [https://youtu.be/J425xx6PVxs Abfragen mit GROUP BY (06:15min)]

* [https://youtu.be/ZPna0CmGuQg Abfragen über mehrere Tabellen]

* [https://youtu.be/rUkVjvlX2Eg Abfragen mit NOT IN bzw. mit IN]

* [https://youtu.be/TZjt6gvRfl8 Abfrage über selbstdefinierte Tabellen]

* [https://youtu.be/GohWF9SnhWM ChatGPT nutzen, um SQL zu schreiben]

=Fachbegriffe=
Vereinigung, Differenz, kartesisches Produkt, Abgleich der Tabellen über..., geschachtelte Abfrage, äußere Abfrage, innere Abfrage 

Außerdem die SQL-Sprachelemente (s.u.)

==SQL-Sprachelemente im Zentralabitur==

Informationen des Zentralabiturs (PDF): [[Datei:Datenbanken-Abi-2012.pdf]]

'''Die folgenden SQL-Befehle muss man im Zentralabitur beherrschen:'''

''Sie werden hier systematisch aufgeführt, wie man sie sich am besten merkt.''
* Befehle:
** SELECT, SELECT DISTINCT ... AS
** FROM
** JOIN ... ON, LEFT JOIN ... ON, RIGHT JOIN ... ON
** WHERE (... z.B. mit IS NULL)
** GROUP BY
** ORDER BY ... ASC (bzw. DESC)
** UNION
** Tabellen selbst definieren mit AS
* Vergleichsoperatoren:
** =, !=, >, <, >=, <=,
** LIKE (in Verbindung mit dem %-Joker)
** BETWEEN ... AND
** IN (SELECT ...)
** NOT IN (SELECT ...)
** IS NULL
* Arithmetische Operatoren: +, -, *, /, (...)
* Logische Operatoren: AND, OR, NOT
* Funktionen: COUNT, SUM, MAX, MIN, AVG
* sonstiges: Die Joker % (in Kombination mit LIK) und * (z.B. SELECT * oder SELECT COUNT(*) )

'''Was man noch können muss:'''
* '''[[SQL#Abfragen_über_mehrere_Tabellen|Abfragen über mehrere Tabellen]]''' formulieren:
** mit '''[[SQL#Kartesisches_Produkt|kartesischem Produkt]]''' und '''[[SQL#Abgleich_zwischen_mehreren_Tabellen|Abgleich]]'''
** mit '''[[SQL#Join|JOIN]]''' bzw. '''LEFT JOIN''' und '''RIGHT JOIN'''
** mit '''[[SQL#Differenz_(NOT_IN)|Differenz (NOT IN)]]'''
* '''[[SQL#Geschachtelte_SQL-Ausdrücke|Geschachtelte SQL-Ausdrücke]]'''
* '''[[SQL#SQL_analysieren|SQL analysieren]]''': Häufig sind das geschachtelte SQL-Abfragen.

==Beispieldatenbank Schule==
* An der Beispieldatenbank Schule können alle möglichen Datenbankabfragen durchprobiert werden.
* Die Beispieldatenbank ist mit Absicht sehr schmal gehalten, damit man die Ergebnisse von SQL-Abfragen noch überprüfen kann.
* Testen kann man SQL-Abfragen auf der Datenbank Schule: '''[http://sibiwiki.de/sql/ hier klicken]'''. Die Zugangsdaten gibt's bei Herrn Kaibel
* ''Wer nicht am SIBI ist, hat folgende Möglichkeiten:''
** ''Die Beispieldatenbank Schule als SQL-Lite Datenbank herunterladen: [[Datei:Schule.sqlite.zip]] Zum Öffnen braucht man [https://sqlitebrowser.org/ DB Browser für SQLite]''
** ''Einen SQL-Dump der Beispieldatenbank Schule herunterladen: [[Datei:Beispieldatenbank-schule.zip]] und z.B. mit phpmyadmin in eine eigene Datenbank importieren.''

[[Datei:Beispieldatenbank-schule.jpg]]
 
===relationales Datenmodell der Datenbank Schule===
<code>
schueler(id,↑klasse_id,name,vorname)
klasse(id,↑klassenlehrer_id,name)
lehrer(id,name,vorname)
unterricht(id,↑klasse_id,↑lehrer_id,↑raum_id,fach,stunden)
raum(id,nummer,etage,plaetze)
ag(id,↑lehrer_id,name)
teilnahme(↑schueler_id,↑ag_id)
</code>

==Aufbau von SQL-Abfragen==
Für den Aufbau von SQL-Abfragen gilt folgende Reihenfolge:
<code>
'''SELECT ...'''
'''FROM ...'''
WHERE ...
GROUP BY ...
ORDER BY ...
LIMIT ...
</code>

<code>SELECT</code> und <code>FROM</code> müssen auf jeden Fall dabei sein, die anderen Teile sind optional.

=Abfragen über eine Tabelle =
''Begriffsklärung: Relation: (hier:) Tabelle''

Bei Datenbanken versteht man unter einer '''Relationenalgebra''' eine formale Sprache, mit der sich Abfragen über eine oder mehrere Tabellen (=Relationen) formulieren lassen. Sie erlaubt es, Tabellen miteinander zu verknüpfen, zu reduzieren oder komplexere Informationen daraus herzuleiten.

===Projektion (SELECT) ===
Unter Projektion versteht man die Reduktion der Informationen in dem Ergebnis auf ein oder mehrere Attribute (=Spalten). 
In unserem Beispiel werden zusätzlich doppelte Zeilen werden entfernt. Dafür braucht man das Schlüsselwort <code>DISTINCT</code>, das hat aber mit der eigentlichen Projektion auf einzelne Spalten nichts zu tun.

'''Beispiel:'''

Formuliere für die Tabelle <code>raum</code> eine Projektionsabfrage, die die Etagen mit Projektion wiedergibt.

<code>
'''SELECT''' DISTINCT r.etage
FROM raum r
</code>

''Beachte: Entscheidend für die Projektion ist es, dass man bei <code>SELECT</code> einzelne Attribute angibt.''

===Selektion (WHERE)===
Selektion bedeutet, dass Datensätze (=Zeilen) ausgewählt werden, die eine bestimmte Bedingung erfüllen.

Formuliere eine Selektionsabfrage, die alle Nummern der Räume mit mindestens 30 Plätzen zurückgibt.

<code>
SELECT r.nummer
FROM raum r
'''WHERE''' r.plaetze >= 30
</code>

''Beachte: Das entscheidende Schlüsselwort für die Selektion ist <code>WHERE</code>, denn hier wird die Bedingung festgelegt.''

Formuliere eine Selektionsabfrage, die alle Informationen zu Räumen mit mindestens 30 Plätzen zurückgibt.

<code>
SELECT *
FROM raum r
'''WHERE''' r.plaetze >= 30
</code>

''Beachte: Mit dem Joker * im SELECT-Teil der Abfrage werden alle Attribute ausgewählt.''

=Erläuterung einzelner SQL-Befehle=
Im folgenden werden einzelne SQL-Befehle jeweils am Beispiel erläutert.

== Aggregat-Funktionen (COUNT, MAX, MIN, SUM, AVG) ==
Mit den sog. Aggregat-Funktionen kann man Attributwerte aus mehreren Zeilen zusammenfassen.

=== Kurze Erklärung ===
* '''COUNT''': zählt
* '''SUM''': addiert
* '''AVG''': berechnet den Durchschnitt (average)
* '''MAX''': bestimmt das Maximum
* '''MIN''': bestimmt das Minimum

===Beispiele===

'''Beispiel 1:'''

Mit der folgenden Abfrage kann man ermitteln, wie viele Schüler es gibt. 
Man zählt die Zeilen; deswegen braucht man COUNT (und nicht SUM).

<code>
SELECT '''COUNT(*)'''
FROM schueler s
</code>

Hinweis: 
COUNT(*) übersetzt sich am einfachsten als "Zähle die Zeilen". 
Wenn man stattdessen COUNT(s.name) nehmen würde, dann würden nur die Zeilen gezählt, wo beim Namen ein Eintrag vorhanden ist. (Das sind hier aber alle).

'''Beispiel 2:'''

Mit der folgenden Abfrage kann man ermitteln, wie viele Stunden Sport unterrichtet werden. 
Hier muss man die Attributwerte <code>stunden</code> addieren, deswegen braucht man SUM.

<code>
SELECT '''SUM(u.stunden)'''
FROM unterricht u
WHERE u.fach = 'Sport'
</code>

'''Beispiel 3:'''

Mit der folgenden Abfrage ermittelt man...
* die maximale Zahl der Plätze in einem Raum,
* die minimale Zahl der Plätze in einem Raum,
* die durchschnittliche Zahl der Plätze in allen Räumen.

<code>
SELECT '''MAX(r.plaetze)''', '''MIN(r.plaetze)''', '''AVG(r.plaetze)'''
FROM raum r
</code>

=== Wann braucht man COUNT(...) und wann braucht man SUM(...) ?! ===
COUNT und SUM werden leicht verwechselt!

Als Faustregel kann man sagen:
* COUNT, wenn gezählt wird,
* SUM, wenn addiert wird.

Das ist aus der Aufgabenstellung nicht immer offensichtlich!

Beispiel 1: 
Man hätte gerne die Anzahl der Plätze in allen Räumen.

Beispiel 2: 
Man hätte gerne die Anzahl der Räume.

Lösung:
* in Beispiel 1 wird die Anzahl der Plätze (im Attribut plaetze) addiert, deswegen SUM(r.plaetze)
* in Beispiel 2 wird die Anzahl der Räume gezählt, deswegen COUNT(r.id) oder COUNT(*)

===COUNT(DISTINCT ...)===
'''Beispiel:''' 
Wie viele Fächer gibt es?
<code>
SELECT COUNT(DISTINCT u.fach)
FROM unterrricht u
</code>

Durch DISTINCT wird jedes Fach nur einmal berücksichtigt!

==LIKE und der %-Joker==
Der %-Joker kann in einer Abfrage beliebige Zeichen ersetzen.

Den %-Joker darf man nicht mit dem exakten Vergleich (=) einsetzen; stattdessen nimmt man für den Vergleich das Schlüsselwort '''<code>LIKE</code>'''.

'''Beispiel:'''

Eine Liste aller Schüler, die ein Doppel-n ('nn') im Vornamen haben.

<code>
SELECT s.vorname AS vorname, s.name AS name
FROM schueler s
WHERE s.vorname LIKE '%nn%'
</code>

''Beachte: Vor und hinter dem nn steht ein %-Joker, d.h. hier können beliebige Buchstaben stehen. "Beliebig" kann auch heißen: Kein Buchstabe! D.h. "Johann" wäre auch ein akzeptierter Vorname.

==GROUP BY==
Mit <code>GROUP BY</code> kann man Zeilen, die einen gemeinsamen Attributwert aufweisen, zusammenfassen.

'''Beispiel:'''

Mit der folgenden Abfrage erhält man eine Liste der Etagen, und für jede Etage wird notiert, wie viele Plätze in ihr insgesamt enthalten sind.

<code>
SELECT r.etage, SUM(plaetze)
FROM raum r
'''GROUP BY''' r.etage
</code>

''Beachte: Durch <code>GROUP BY r.etage</code> werden alle Zeilen, die bei <code>r.etage</code> den Wert 'unten' haben, in einer Zeile zusammengefasst. Genauso alle Zeilen, die bei <code>r.etage</code> den Wert 'Mitte' (bzw. 'oben') haben.''

''Dadurch, dass man so zusammenfasst, kann jetzt für jede Etage die Summe der Plätze berechnet werden.''

[https://youtu.be/J425xx6PVxs Erklärvideo zu GROUP BY (06:15min)]


==Umbenennung (AS)==
Attribute können umbenannt werden.

'''Beispiel 1:'''

Formuliere eine Abfrage über die Attribute klasse_id, lehrer_id, raum_id, fach und stunden der Tabelle unterricht. Dabei soll klasse_id in klassen-nr, lehrer_id in lehrer_nr und raum_id in raum-nr umbenannt werden.

<code>
SELECT u.klasse_id '''AS''' klassennr,u.lehrer_id '''AS''' Lehrernr,u.raum_id '''AS''' Raumnr,u.fach,u.stunden '''AS''' stunden
FROM unterricht u
</code>

'''Beispiel 2:'''

Formuliere eine Abfrage, die eine Liste der Etagen zurückgibt. Für jede Etage soll angegeben werden, wie viele Plätze es in der Etage gibt.
Die Liste soll nach der Anzahl der Plätze sortiert sein.

<code>
SELECT r.etage, SUM(plaetze) AS PlaetzeInEtage
FROM raum r
GROUP BY r.etage
ORDER BY PlaetzeInEtage
</code>

''Beachte: Für <code>SUM(plaetze)</code> wird ein Alias (<code>PlaetzeInEtage</code>) vergeben. Mithilfe des Alias kann man am Ende nach der Anzahl der Plätze sortieren!''

==Mehrere Bedingungen: AND, OR, BETWEEN==
In SQL-Abfragen kann man mehrere Bedingungen kombinieren. Dafür gibt es die Schlüsselwörter AND, OR und BETWEEN

===AND / OR===
Mit AND / OR kann man zwei Bedingungen verknüpfen.

'''Beispiel:'''

<code>
SELECT r.nummer, r.plaetze
FROM raum r
WHERE r.etage = 'unten' '''OR''' r.etage = 'Mitte'
</code>

===BETWEEN===
Mit BETWEEN ... AND kann man Intervalle angeben.

'''Beispiel:'''

<code>
SELECT r.nummer, r.plaetze
FROM raum r
WHERE r.plaetze '''BETWEEN''' 30 '''AND''' 50
</code>

===LIMIT===
Mit LIMIT kann man angeben, wie viele Zeilen ausgegeben werden.

'''Beispiel:'''
Die folgende SQL-Anweisung gibt den Raum (Nummer, Platzanzahl) mit den meisten Plätzen aus.

Es wird eine Liste von allen Räumen erstellt, aber nur die erste Zeile der Liste
(d.h. der Raum mit den meisten Plätzen) wird ausgegeben.

<code>
SELECT r.nummer, r.plaetze
FROM raum r
ORDER BY r.plaetze DESC
'''LIMIT 1'''
</code>

=Abfragen über mehrere Tabellen=

===Vereinigung (UNION)===
Vereinigung bedeutet, dass die Ergebnis-Datensätze von zwei Abfragen zu einem Ergebnis zusammengefügt werden. Voraussetzung dafür ist, dass beide Abfragen gleich viele Attribute abfragen.

Formuliere eine Abfrage, die Name und Vorname von allen Lehrern UND Schülern wiedergibt.

<code>
SELECT l.name, l.vorname
FROM lehrer l
'''UNION'''
SELECT s.name, s.vorname
FROM schueler s
</code>

===Differenz (NOT IN) ===
Differenz bedeutet, dass die Ergebnis-Datensätze einer Abfrage a1 von den Ergebnis-Datensätzen einer Abfrage a0 abgezogen werden - es bleibt dann ein Rest übrig.

Formuliere eine Abfrage, die alle Klassen ausgibt, die KEIN Mathematik haben.

Idee: Die Klassen, die Mathematik haben, von allen Klassen abziehen.

<code>
SELECT k.name
FROM klasse k
WHERE k.id '''NOT IN'''
(
SELECT u.klasse_id
FROM unterricht u
WHERE u.fach='Mathe'
)
</code>

===IN===
Das logische Gegenteil zu NOT IN ist entsprechend IN.
Dieses Schlüsselwort kann man u.a. verwenden, wenn man in einer Abfrage zwei Datensätze einer Entitätsmenge hat.
Beispiel: Welche Schüler sind in der selben Klasse wie Anne Ebert?

Idee: In der äußeren Abfrage werden die Schüler gesucht; mit IN kann man dann die klasse_id von Anne Ebert angeben.

<code>
SELECT s.name, s.vorname
FROM schueler s
WHERE s.klasse_id '''IN'''
(
SELECT s2.klasse_id
FROM schueler s2
WHERE s2.name = 'Ebert'
)
</code>

===Kartesisches Produkt===
In der Mathematik bezeichnet man als kartesisches Produkt (nach René Descartes) zweier Mengen A und B die Menge aller geordneten Paare (a,b), wobei a aus A und b aus B ist. (Kombination: „Jedes mit jedem“.) Geschrieben wird es als '''A x B''' gelesen als A kreuz B.

''Kurz: Jeder mit jedem''.

Formuliere eine Abfrage für das kartesische Produkt von den Tabellen klasse und schueler.

<code>
SELECT *
FROM '''klasse k, schueler s'''
</code>

Diese Abfrage liefert als Ergebnis "Jeder mit jedem". Inhaltlich ist das nicht sinnvoll.

Damit das kartesische Produkt sinnvoll wird, braucht man einen Abgleich zwischen den Tabellen; vgl. [[SQL#SQL-Abfrage über mehrere verknüpfte Tabellen|SQL-Abfrage über mehrere verknüpfte Tabellen]]

===Abgleich zwischen mehreren Tabellen===
Formuliere eine Abfrage, die angibt, in welchen Räumen die Klasse 8a unterrichtet wird.
Die Abfrage läuft über die Tabellen klasse, unterricht und raum.

<code>
SELECT r.nummer
FROM klasse k, unterricht u, raum r
'''WHERE r.id=u.raum_id'''
'''AND u.klasse_id=k.id'''
AND k.name = '8a'
</code>

'''Wichtig:''' bei Abfragen über mehrere Tabellen braucht man einen Abgleich weniger als man Tabellen abfragt.

Im Beispiel werden drei Tabellen abgefragt; deswegen braucht man zwei Abgleiche.

===JOIN / INNER JOIN===
Join ist die Bildung eines [[SQL#Kartesisches_Produkt|kartesischen Produktes]] gefolgt von einer Selektion, die den (richtigen) Abgleich zwischen den beiden Tabellen leistet.

Beispiel: Eine Liste der Schüler, in der für jeden Schüler vermerkt wird, in welcher Klasse er ist.

<code>
SELECT s.name AS schuelername, k.name AS klassename
FROM schueler s '''JOIN''' klasse k
'''ON''' s.klasse_id = k.id
</code>

Mit einem JOIN werden nur VOLLSTÄNDIGE Datensätze angezeigt. D.h. im Beispiel fallen Schüler, die keine Klasse haben, und Klassen, die keine Schüler haben, raus.

Der Join entspricht der [[SQL#SQL-Abfrage über mehrere verknüpfte Tabellen|SQL-Abfrage über mehrere verknüpfte Tabellen]]

Statt <code>JOIN</code> kann man auch ausführlicher <code>INNER JOIN</code> schreiben. Dies wird in den Analyseaufgaben der Abiturklausuren häufig verwendet.

===LEFT JOIN===
Beim '''Left''' Join werden auch die Zeilen der '''linken''' Tabelle aufgeführt, die keinen Partner in der rechten Tabelle haben. In der rechten Tabelle wird ggf. mit ''NULL'' aufgefüllt.

Formuliere eine Abfrage, die einen Left-Join zwischen den Tabellen klasse und schueler durchführt.
Bewerte das Ergebnis inhaltlich: In welchen Zusammenhängen braucht man Left-Join?

<code>
SELECT s.name AS schuelername, k.name AS klassename
FROM schueler s '''LEFT JOIN''' klasse k
'''ON''' s.klasse_id = k.id
</code>

Beim LEFT JOIN werden ALLE Daten der LINKEN Entitätsmenge angezeigt. Im Beispiel werden also auch die Schüler angezeigt, die keine Klasse haben.

===RIGHT JOIN===
Beim '''Right''' Join werden auch die Zeilen der '''rechten''' Tabelle aufgeführt, die keinen Partner in der linken Tabelle haben. In der linken Tabelle wird ggf. mit ''NULL'' aufgefüllt.

Formuliere eine Abfrage, die einen Right-Join zwischen den Tabellen klasse und schueler durchführt.

<code>
SELECT s.name AS schuelername, k.name AS klassename
FROM schueler s '''RIGHT JOIN''' klasse k
'''ON''' s.klasse_id = k.id
</code>

Beim RIGHT JOIN werden ALLE Daten der RECHTEN Entitätsmenge angezeigt. Im Beispiel werden also auch die Klassen angezeigt, die keine Schüler haben.

===LEFT JOIN (bzw. RIGHT JOIN) über 3 oder mehr Tabellen ===
Wenn man einen LEFT JOIN über insgesamt 3 Tabellen machen will, verwendet man am einfachsten zwei LEFT JOIN. 

Beispiel: Eine Liste aller Schüler, in der steht, welche AGs sie belegen.
<code>
SELECT s.name as schueler, a.name as ag
FROM schueler s
LEFT JOIN teilnahme t
ON s.id = t.schueler_id
LEFT JOIN ag a
ON t.ag_id = a.id
</code>

===IS NULL===
Formuliere eine Abfrage, die alle Schüler zurückgibt, die keine Klasse haben.

<code>
SELECT s.name AS schuelername, k.name AS klassename
FROM schueler s LEFT JOIN klasse k
ON s.klasse_id = k.id
WHERE k.id '''IS NULL'''
</code>

Beim LEFT JOIN werden ALLE Daten der LINKEN Entitätsmenge angezeigt, also auch die Schüler, die keine Klasse haben.
Diese Schüler werden durch <code>k.id IS NULL ausgewählt</code>.

===Abfragen, bei denen man mehrere Variablen einer Entitätsmenge braucht===
Formuliere eine Abfrage, die alle Räume wiedergibt, die mehr Plätze haben als Raum R203.

''Idee: ''
* ''Man hat den bekannten Raum r1 mit der Nummer "R203".''
* ''Außerdem hat man den gesuchten Raum r2, der mehr Plätze hat als Raum r1.''

<code>
SELECT r2.nummer
FROM '''raum r1''', '''raum r2'''
WHERE r1.nummer = "R203"
AND r2.plaetze > r1.plaetze
</code>

=Abfragen über selbstdefinierte Tabellen=

'''Man kann die Tabellen, die man bei FROM angibt, durch eigene SELECT-Anfrage selber definieren.'''

Die selbstdefinierten Tabellen müssen mit einem Alias benannt und durch ein Komma voneinander getrennt werden. Dann können sie wie "normale" Tabellen genutzt werden.

'''Beispiel:'''
''Eine Liste der Klassen, in der steht, wieviel Prozent Sportunterricht sie haben.''

<code>
SELECT gesamtstunden.klasse AS klasse, sportstunden.stunden/gesamtstunden.stunden * 100 AS prozent
FROM
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden
FROM klasse k LEFT JOIN unterricht u
ON k.id = u.klasse_id
GROUP BY k.name
) AS gesamtstunden
'''LEFT JOIN'''
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden
FROM klasse k, unterricht u
WHERE k.id = u.klasse_id
AND u.fach = 'Sport'
GROUP BY k.name
) AS sportstunden'''
'''ON sportstunden.klasse = gesamtstunden.klasse'''
</code>

'''Erläuterung:'''

* In FROM werden zwei Tabellen definiert: Die Tabelle '''gesamtstunden''' und die Tabelle '''sportstunden'''.
* Diese Tabellen werden mit einem '''LEFT JOIN ... ON''' verknüpft.
* Außerdem erhalten sie mithilfe von AS Aliasnamen: '''AS gesamtstunden''' (bzw. '''AS sportstunden''').
* Mithilfe dieser Aliasnamen kann die äußere Abfrage auf die beiden Tabellen zugreifen.

'''WICHTIG:'''
Man muss jeder inneren SELECT-Abfrage mithilfe von '''AS''' einen '''Namen''' geben - nur dann ist sie in der äußeren SELECT-Abfrage ansprechbar!

=SQL analysieren=
In Klausuren (auch im Abi) muss SQL analysiert werden.

Meistens muss man dabei ein SQL-Statement auf vorliegende Tabellen anwenden; es kann aber auch vorkommen, dass man ein SQL-Statement erläutern muss.

Dafür wird hier ein '''Beispiel''' gegeben.

'''SQL-Statement:'''

<code>
SELECT gesamtstunden.klasse AS klasse, sportstunden.stunden/gesamtstunden.stunden * 100 AS prozent
FROM
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden
FROM klasse k LEFT JOIN unterricht u
ON k.id = u.klasse_id
GROUP BY k.name
) AS gesamtstunden
'''LEFT JOIN'''
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden
FROM klasse k, unterricht u
WHERE k.id = u.klasse_id
AND u.fach = 'Sport'
GROUP BY k.name
) AS sportstunden'''
'''ON sportstunden.klasse = gesamtstunden.klasse'''
</code>

'''Aufgaben:'''
# Erläutern Sie die '''Funktionsweise''' dieser SQL-Abfrage.
# Erläutern Sie, welchem '''Zweck''' diese SQL-Abfrage dient.

Folgendermaßen könnte eine Bearbeitung aussehen; wichtige Schlüsselwörter und Passagen sind unterstrichen.

'''Funktionsweise:'''

Die SQL-Abfrage besteht aus einer äußeren Abfrage, die auf zwei selbstdefinierte Tabellen zugreift.
Der ersten selbstdefinierten Tabelle wurde mit "AS gesamtstunden" der Name <code>gesamtstunden</code> gegeben, der zweiten selbstdefinierten Tabelle der Name <code>sportstunden</code>.

In der Tabelle <code>gesamtstunden</code> wird mithilfe von GROUP BY eine Liste der Klassen-Namen erstellt, in der für jede Klasse die Gesamtzahl der unterrichteten Stunden angegeben wird. In der Tabelle <code>sportstunden</code> geschieht dasselbe für die Sportstunden.

In der äußeren Abfrage werden diese beiden selbstdefinierten Tabellen mithilfe eines LEFT JOIN über die Spalten sportstunden.klasse = gesamtstunden.klasse verknüpft.

So werden in der Ergebnistabellen alle Zeilen der Tabelle <code>gesamtstunden</code> berücksichtigt, aber nicht unbedingt alle Zeilen der Tabelle <code>sportstunden</code>.

Die äußere Abfrage übernimmt im SELECT die Spalte <code>klasse</code> aus der Tabelle <code>gesamtstunden</code> und berechnet dann aus <code>sportstunden.stunden</code> und <code>gesamtstunden.stunden</code>, wie viel Prozent Sport erteilt wird.

'''Zweck:'''

Die SQL-Abfrage gibt eine Liste aller Klassen zurück, die Unterricht haben. Für jede Klasse wird angegeben, wie viel Prozent ihrer Unterrichtsstunden Sportstunden sind. Die 8D hat zwar keinen Unterricht, durch die (zweifache) Verwendung von LEFT JOIN wird sie dennoch angezeigt, in der rechten Spalte steht dann NULL statt einer Prozentzahl.

=HAVING=
'''Nicht abiturrelevant, aber sehr nützlich!'''

Manchmal hat man eine Zahl gerade erst mit einer Aggregatfunktion (z.B. <code>SUM</code>) ermittelt und möchte für diese Zahl direkt eine Bedingung festlegen.

Das kann man mit <code>WHERE</code> nicht tun, denn <code>WHERE</code> funktioniert nur für "fest" definierte Zahlen!

Für diesen Fall wurde das Schlüsselwort <code>HAVING</code> entwickelt.

'''Beispiel:'''
Eine Liste der Fächer, in der die Gesamtzahl der Stunden vermerkt ist, die sie unterrichtet werden. Es sollen nur Fächer aufgeführt werden, die mehr als 7 Stunden unterrichtet werden.

''Beachte: Die Gesamtzahl der Stunden muss mit einer Aggregatfunktion (SUM) ermittelt werden. Deswegen kann man für die Gesamtzahl keine <code>WHERE</code>-Bedingung formulieren - das würde zu einem Syntax-Fehler führen.''

''Lösen lässt sich das mit <code>HAVING</code>:

<code>
SELECT u.fach, SUM(u.stunden) AS stunden
FROM unterricht u
GROUP BY u.fach
HAVING stunden > 7
ORDER BY stunden DESC
</code>

=Mit Java auf eine SQL-Datenbank zugreifen=
Das wird hier erklärt: [[Java-SQL]]

=ChatGPT nutzen um SQL zu schreiben=

''Last not least wollen wir nicht verheimlichen, dass ChatGPT ein großartiges Hilfsmittel ist, um SQL zu schreiben!''

==Erklärvideo==
[https://youtu.be/GohWF9SnhWM ChatGPT nutzen, um SQL zu schreiben]

==Best practices==
* ''ChatGPT kann extrem cool SQL programmieren!! Es verfügt über einen SQL-Wortschatz, von dem selbst die Informatik-Lehrer noch nie gehört haben!''
* '''''ABER:''' ChatGPT ist ziemlich begriffsstutzig! Man muss sehr genau erklären, was man will.''

'''Empfehlungen:'''

# Zu Anfang: '''Kontext herstellen!''' (-> Datenbankschema!)
# '''Genau''' mitteilen, was man will, mit '''Fachbegriffen'''.
# '''Testen''': Natürlich macht ChatGPT auch beim Programmieren Fehler. Der große Vorteil ist aber, dass man das - mit gut gewählten Beispielen - direkt überprüfen kann! Und wenn der SQL-Code einen Fehler hat, dann hilft nur...
# '''„Nachkarten“:''' ''Das ist sehr wichtig! Denn mit etwas Hartnäckigkeit kann man ChatGPT dazu bringen, das Richtige zu tun!'' Für das "Nachkarten" empfiehlt sich:
## '''Fehlermeldungen''' von SQL an ChatGPT weiter geben.
## '''Fachbegriffe''' verwenden
## '''Beziehungen klären''' z.B.: "Die Tabelle schueler ist über die Tabelle klasse mit der Tabelle unterricht verknüpft." z.B.: "Fach ist ein Attribut der Tabelle unterricht."
## '''Das Datenbankmodell nochmal mit Copy&Paste eintragen.''' Informationen "verblassen" im Laufe der Zeit.
## Gegebenenfalls '''SQL-Schlüsselwörter vorgeben''': z.B. "Verwende NOT IN"
# Wenn alles nichts hilft:
## eine '''neue Unterhaltung anfangen''', d.h. einfach nochmal von vorne. ''Die Antworten von ChatGPT beruhen auf Wahrscheinlichkeiten, d.h. es kann gut sein, dass man bei genau der selben Anfrage eine andere Lösung bekommt.''
## '''Auf Englisch fragen.''' ''ChatGPT wurde mit wesentlich mehr englischen Daten trainiert, d.h. die Erfolgschancen sind auf Englisch größer.''

==Vorteile==
* ChatGPT steht ein sehr breites SQL-Vokabular zur Verfügung! Da sind Schlüsselwörter dabei, die man selber höchstens zum "passiven" Wortschatz zählen würde.
* ChatGPT kann (wenn alles gut geht) SQL-Statements von ziemlicher Eleganz entwickeln.
* Wenn man das Datenbankschema mitteilt und die Tabellen und Attribute verständlich benannt hat, dann kann sich ChatGPT auf einen beliebigen Kontext einstellen.
* Außerdem geht es natürlich extrem schnell.

==Datenbankschema für den Test==
''Das Datenbankschema muss man direkt am Anfang mitteilen!''
<code>
schueler(id,↑klasse_id,name,vorname)
klasse(id,↑klassenlehrer_id,name)
lehrer(id,name,vorname)
unterricht(id,↑klasse_id,↑lehrer_id,↑raum_id,fach,stunden)
raum(id,nummer,etage,plaetze)
ag(id,↑lehrer_id,name)
teilnahme(↑schueler_id,↑ag_id)
</code>

Testen kann man wie üblich hier:

[https://sibiwiki.de/sql/ sibiwiki.de/sql]

(Zugangsdaten beim Informatik-Lehrer am SIBI.)

Wer nicht am SIBI ist, kann sich einen Dump der Datenbank Schule hier herunterladen: [[Datei:Beispieldatenbank-schule.zip]]

Binärbaum (Methoden)

2026-01-23T20:46:25Z

Akaibel: /* Implementierung */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Datenstrukturen(IF)]]

Hier werden die '''Standard-Strategien''' für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] vorgestellt:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung
Außerdem wird erklärt, was eine '''Rahmenmethode''' ist und wie man sie implementiert.

Für das '''Suchen''' und '''Löschen''' von Elementen: siehe [[binärer Suchbaum ab Abi 2017]]

=Erklärvideos=
* [https://youtu.be/to2supzEiO4 rekursive Methoden für Binärbäume implementieren (Youtube)]
* [https://youtu.be/SjniaclqvFs Prinzip und Implementierung der Levelorder-Traversierung (Youtube)]
* [https://youtu.be/UGrrFuV3zjY Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

=Fachbegriffe=
Rekursion, Abbruchbedingung, rekursiver Aufruf, Sachlogik, Rahmenmethode, Pfaddurchlauf, Linearisierung, Baumliste

=Standard-Strategien=
Für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] gibt es drei Standard-Strategien:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung

==Rekursion==
Binärbäume sind '''rekursive Datenstrukturen''', denn jeder Binärbaum hat zwei Teilbäume - und die sind selber wieder Binärbäume.

Deswegen bietet es sich an, Binärbäume '''rekursiv''' zu durchlaufen.

===Strategie===
Bei der Implementierung einer rekursiven Methode für Binärbäume wird der gesamte Baum nur sehr grob betrachtet: Er besteht aus
* der Wurzel,
* dem linken Teilbaum (für den die Methode rekursiv aufgerufen wird)
* dem rechten Teilbaum (für den die Methode nochmal rekursiv aufgerufen wird).

In der '''Sachlogik''' muss man folgende Frage beantworten:

'''''Wie setzt sich das Gesamtergebnis aus der Wurzel, dem Ergebnis des linken Teilbaumes und dem Ergebnis des rechten Teilbaumes zusammen?'''''


[https://www.youtube.com/watch?v=HDCVf1LXrP0 Erklärvideo zum Vorgehen bei rekursiven Methoden (11:23min)]


<div style="margin:0; margin-right:10px; border:1px dotted #000008; padding: 0em 1em 1em 1em; background-color:#F9F9F9;text-align:left">

'''Bestandteile einer rekursiven Methode für Binärbäume:'''
* Die rekursive Methode braucht als einen '''Parameter einen Binärbaum''', damit man rekursiv für den linken bzw. rechten Teilbaum aufrufen kann.
** Die rekursive Methode wird häufig aus einer '''Rahmenmethode''' aufgerufen.
* eine '''Abbruchbedingung''' oder mehrere Abbruchbedingungen. Diese hängen vom Sachzusammenhang ab - in der Regel braucht man mindestens eine Abbruchbedingung für einen leeren Binärbaum.
* '''Wurzel auslesen''' ''(=Wurzelbehandlung)''
* '''rekursive Aufrufe''': Die Methode ruft sich selber auf.
** Meistens braucht man '''zwei rekursive Aufrufe''': einen für den linken Teilbaum und einen für den rechten Teilbaum.
** Bei Methoden, die etwas zurückgeben, muss man sich für den Rückgabewert interessieren!
* '''Sachlogik''': Hier werden die Wurzel und die Ergebnisse der rekursiven Aufrufe behandelt.
</div>

===Implementierung===
Das rekursive Vorgehen wird hier beispielhaft an der Methode <code>public int summe(BinaryTree<Integer> pTree)</code> aufgezeigt:

<code>
//ein Beispiel-Attribut
private BinaryTree<Integer> suchbaum;

'''//Rahmenmethode'''
public int summe(){
// die Rahmenmethode '''delegiert''' die Aufgabe an die rekursive Methode.
// dabei übergibt sie den zu behandelnden Baum.
return summe(suchbaum);
}

'''//rekursive Methode'''
'''//Parameter vom Typ BinaryTree''' ist notwendig für rekursive Aufrufe!
private int summe(BinaryTree<Integer> pTree){
int ergebnis = 0;

'''//Abbruchbedingung'''
if(pTree.isEmpty()){
return ergebnis;
}

'''//Wurzel auslesen'''
int wurzel = pTree.getContent();

'''//rekursive Aufrufe'''
int summeLinks = summe(pTree.getLeftTree());
int summeRechts = summe(pTree.getRightTree());

'''//Sachlogik'''
ergebnis += wurzel;
ergebnis += summeLinks;
ergebnis += summeRechts;

return ergebnis;
}
</code>

==Durchlaufen eines Pfades==
In manchen Situationen, vor allem in Bäumen mit Suchbaumstruktur, reicht es, wenn man einen '''Pfad von der Wurzel bis zu einem Blatt durchläuft'''. Das lässt sich mit einer <code>while</code>-Schleife realisieren, d.h. Rekursion ist hier nicht nötig.

===Strategie===
Um einen Pfad in dem Binärbaum <code>pTree</code> von der Wurzel zu einem Blatt zu durchlaufen, geht man wie folgt vor:
* Es wird eine <code>while</code>-Schleife geöffnet, die so lange läuft, bis <code>pTree</code> leer ist.
* In der <code>while</code>-Schleife wird - abhängig von der Sachlogik - nach links oder nach rechts abgebogen. Das realisiert man, indem man <code>pTree</code> durch seinen linken oder rechten Teilbaum updated.
* Nach Beendigung der <code>while</code>-Schleife ist man dann bei einem leeren Knoten unterhalb eines Blattes angekommen.

===Implementierung===
Als Beispiel wird die Methode '''einfuegen''' für einen mit Zahlen gefüllten Suchbaum implementiert.

[https://youtu.be/UGrrFuV3zjY Erklärvideo: Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

<code>
//Beispiel-Attribut
private BinaryTree<Integer> suchbaum;

public void einfuegen(int pZahl) {
//Hilfsbaum definieren, damit man pTree nicht "zersägt":
'''BinaryTree<Integer> b = suchbaum;'''
'''while(!b.isEmpty()){'''
int wurzel = b.getContent();
'''// UPDATE von pTree'''
if(pZahl < wurzel){
// "links abbiegen"
'''b = b.getLeftTree();'''
}
else{
// "rechts abbiegen"
'''b = b.getRightTree();'''
}
}
// jetzt ist man beim richtigen leeren Knoten angekommen!
b.setContent(pZahl);
}
</code>

==Linearisierung==
'''nur relevant für den Leistungskurs!'''

[https://youtu.be/SjniaclqvFs Erklärvideo: Prinzip und Implementierung der Levelorder-Traversierung]

'''Linearisierung''' ist eine Strategie, wie man rekursive Strukturen (z.B. einen Binärbaum) komplett durchlaufen kann, '''''OHNE eine rekursive Methode zu verwenden'''''.

===Vorgehensweise===
Die Vorgehensweise wird hier am Beispiel '''Levelorder''' aufgezeigt.
In Levelorder wird der Binärbaum "schichtenweise" von oben nach unten durchlaufen, d.h. es handelt sich hier um eine '''Breitensuche'''.

Die Idee der Linarisierung ist die folgende:

'''Linearisierung: Baumliste erstellen'''
# eine Hilfsliste <code>baumListe</code> wird angelegt; in diese Hilfsliste kommen nur Bäume!
# der ganze Baum wird in <code>baumListe</code> gepackt, d.h. <code>baumListe</code> hat jetzt ein Element.
# dann wird <code>baumListe</code> mit einer Schleife von vorne bis zum Ende durchlaufen; dabei wird <code>baumListe</code> '''ständig ergänzt!'''
## bei jedem Schleifen-Durchlauf wird das aktuelle Element (=ein Baum) aus <code>baumListe</code> entnommen.
## die beiden Teilbäume (wenn sie nicht leer sind) werden hinten an <code>baumListe</code> angehängt.
# Jetzt hat man in <code>baumListe</code> eine Liste aller Teilbäume von <code>pTree</code>.
## Diese Liste kann jetzt für die Sachlogik verwendet werden.
'''Sachlogik: Ergebnisliste erstellen'''
# eine Ergebnisliste <code>ergebnisListe</code> wird angelegt; in <code>ergebnisListe</code> kommen die Knoten in der Levelorder-Reihenfolge.
# <code>baumListe</code> wird mit einer Schleife durchlaufen. Bei jedem Schleifendurchlauf wird...
## der aktuelle Baum aus <code>baumListe</code> ausgelesen.
## die Wurzel des aktuellen Baumes in <code>ergebnisListe</code> eingefügt.

===Implementierung===
''am Beispiel eines Baumes, der Personen enthält''
<code>
public List<Person> levelorder(BinaryTree<Person> pTree){
'''//Linearisierung'''
List<BinaryTree<Person>> baumListe = new List<>();
baumListe.append(pTree);
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Person> aktuell = baumListe.getContent();
if(!aktuell.getLeftTree().isEmpty()){
baumListe.append(aktuell.getLeftTree());
}
if(!aktuell.getRightTree().isEmpty()){
baumListe.append(aktuell.getRightTree());
}
baumListe.next();
}
'''// Sachlogik:'''
// die baumListe durchlaufen,
// von jedem Element (Typ: BinaryTree!)
// die Wurzel auslesen und an ergebnisListe anhaengen
List<Person> ergebnisListe = new List<>();
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Person> aktuellerBaum = baumListe.getContent();
Person aktuelleWurzel = aktuellerBaum.getContent();
ergebnisListe.append(aktuelleWurzel);
baumListe.next();
}
return ergebnisListe;
}
</code>

=Rahmenmethode=
siehe [[Binärbaum#Rahmenmethode|Rahmenmethode]] im Artikel [[Binärbaum]].

=weitere beispielhafte Methoden=
==Tiefe==
<code>
public int tiefe(BinaryTree pTree) {
int ergebnis = -1;
if (pTree.isEmpty()) {
// leere Teilbaeume haben Tiefe -1
// denn Baeume, die nur aus einem Blatt bestehen,
// haben Tiefe 0!
return ergebnis;
}
int tiefeLinks = tiefe(pTree.getLeftTree());
int tiefeRechts = tiefe(pTree.getRightTree());
ergebnis = tiefeLinks;
if (ergebnis < tiefeRechts) {
ergebnis = tiefeRechts;
}
// der gesamte Baum ist um eins tiefer, wegen der Wurzel
ergebnis++;
return ergebnis;
}
</code>

==Knotenzahl==
<code>
public int knotenzahl(BinaryTree pTree) {
int ergebnis = 0;
if (pTree.isEmpty()) {
return ergebnis;
}
ergebnis += 1; // die Wurzel zaehlen!
int knotenLinks = knotenzahl(pTree.getLeftTree());
int knotenRechts = knotenzahl(pTree.getRightTree());
ergebnis += knotenLinks;
ergebnis += knotenRechts;
return ergebnis;
}
</code>

==Blätter==
Diese Methode gibt alle Blätter eines Baumes in einer Liste zurück.

Die Methode funktioniert rekursiv.

Man braucht zwei Abbruchbedingungen:
* für einen leeren Baum -> eine leere Liste zurückgeben
* für ein Blatt -> eine Liste mit nur einem Blatt drin zurückgeben

<code>
public List blaetter(BinaryTree<Object> pTree) {
List<Object> ergebnis = new List<>();

if (pTree.isEmpty()) {
return ergebnis;
}

if (pTree.getLeftTree().isEmpty() && pTree.getRightTree().isEmpty()){
// pTree ist ein Blatt!
ergebnis.append(pTree.getContent());
return ergebnis;
}

List<Object> linkesErgebnis = blaetter(pTree.getLeftTree());
List<Object> rechtesErgebnis = blaetter(pTree.getRightTree());

ergebnis.concat(linkesErgebnis);
ergebnis.concat(rechtesErgebnis);

return ergebnis;
}
</code>

==Berechnen==
[[File:Strukturbaum.jpg|thumb|Binärer Strukturbaum (12/4)+(2*3) |300px]]
Diese Methode berechnet das Ergebnis eines Strukturbaumes aus den Rechenzeichen +, -, *, / und Zahlen.

<code>
public double berechnen(BinaryTree<String> b) {
double ergebnis = 0;
if (b.isEmpty()) {
return ergebnis;
}
String wurzelString = b.getContent();
if ( !wurzelString.equals("+") &&
!wurzelString.equals("-") &&
!wurzelString.equals("*") &&
!wurzelString.equals("/")
)
{
double wurzelDouble = Double.parseDouble(wurzelString);
ergebnis = wurzelDouble;
return ergebnis;
}

double ergebnisLinks = berechnen(b.getLeftTree());
double ergebnisRechts = berechnen(b.getRightTree());

if(wurzelString.equals("+")){
ergebnis = ergebnisLinks + ergebnisRechts;
}
else if((wurzelString.equals("-")){
ergebnis = ergebnisLinks - ergebnisRechts;
}
else if((wurzelString.equals("*")){
ergebnis = ergebnisLinks * ergebnisRechts;
}
else if((wurzelString.equals("/")){
ergebnis = ergebnisLinks / ergebnisRechts;
}
else{
System.err.println("unbekanntes Rechenzeichen!");
ergebnis = 0;
}
return ergebnis;
}
</code>

Binärbaum (Methoden)

2026-01-23T20:42:03Z

Akaibel: /* Vorgehensweise */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Datenstrukturen(IF)]]

Hier werden die '''Standard-Strategien''' für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] vorgestellt:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung
Außerdem wird erklärt, was eine '''Rahmenmethode''' ist und wie man sie implementiert.

Für das '''Suchen''' und '''Löschen''' von Elementen: siehe [[binärer Suchbaum ab Abi 2017]]

=Erklärvideos=
* [https://youtu.be/to2supzEiO4 rekursive Methoden für Binärbäume implementieren (Youtube)]
* [https://youtu.be/SjniaclqvFs Prinzip und Implementierung der Levelorder-Traversierung (Youtube)]
* [https://youtu.be/UGrrFuV3zjY Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

=Fachbegriffe=
Rekursion, Abbruchbedingung, rekursiver Aufruf, Sachlogik, Rahmenmethode, Pfaddurchlauf, Linearisierung, Baumliste

=Standard-Strategien=
Für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] gibt es drei Standard-Strategien:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung

==Rekursion==
Binärbäume sind '''rekursive Datenstrukturen''', denn jeder Binärbaum hat zwei Teilbäume - und die sind selber wieder Binärbäume.

Deswegen bietet es sich an, Binärbäume '''rekursiv''' zu durchlaufen.

===Strategie===
Bei der Implementierung einer rekursiven Methode für Binärbäume wird der gesamte Baum nur sehr grob betrachtet: Er besteht aus
* der Wurzel,
* dem linken Teilbaum (für den die Methode rekursiv aufgerufen wird)
* dem rechten Teilbaum (für den die Methode nochmal rekursiv aufgerufen wird).

In der '''Sachlogik''' muss man folgende Frage beantworten:

'''''Wie setzt sich das Gesamtergebnis aus der Wurzel, dem Ergebnis des linken Teilbaumes und dem Ergebnis des rechten Teilbaumes zusammen?'''''


[https://www.youtube.com/watch?v=HDCVf1LXrP0 Erklärvideo zum Vorgehen bei rekursiven Methoden (11:23min)]


<div style="margin:0; margin-right:10px; border:1px dotted #000008; padding: 0em 1em 1em 1em; background-color:#F9F9F9;text-align:left">

'''Bestandteile einer rekursiven Methode für Binärbäume:'''
* Die rekursive Methode braucht als einen '''Parameter einen Binärbaum''', damit man rekursiv für den linken bzw. rechten Teilbaum aufrufen kann.
** Die rekursive Methode wird häufig aus einer '''Rahmenmethode''' aufgerufen.
* eine '''Abbruchbedingung''' oder mehrere Abbruchbedingungen. Diese hängen vom Sachzusammenhang ab - in der Regel braucht man mindestens eine Abbruchbedingung für einen leeren Binärbaum.
* '''Wurzel auslesen''' ''(=Wurzelbehandlung)''
* '''rekursive Aufrufe''': Die Methode ruft sich selber auf.
** Meistens braucht man '''zwei rekursive Aufrufe''': einen für den linken Teilbaum und einen für den rechten Teilbaum.
** Bei Methoden, die etwas zurückgeben, muss man sich für den Rückgabewert interessieren!
* '''Sachlogik''': Hier werden die Wurzel und die Ergebnisse der rekursiven Aufrufe behandelt.
</div>

===Implementierung===
Das rekursive Vorgehen wird hier beispielhaft an der Methode <code>public int summe(BinaryTree<Integer> pTree)</code> aufgezeigt:

<code>
//ein Beispiel-Attribut
private BinaryTree<Integer> suchbaum;

'''//Rahmenmethode'''
public int summe(){
// die Rahmenmethode '''delegiert''' die Aufgabe an die rekursive Methode.
// dabei übergibt sie den zu behandelnden Baum.
return summe(suchbaum);
}

'''//rekursive Methode'''
'''//Parameter vom Typ BinaryTree''' ist notwendig für rekursive Aufrufe!
private int summe(BinaryTree<Integer> pTree){
int ergebnis = 0;

'''//Abbruchbedingung'''
if(pTree.isEmpty()){
return ergebnis;
}

'''//Wurzel auslesen'''
int wurzel = pTree.getContent();

'''//rekursive Aufrufe'''
int summeLinks = summe(pTree.getLeftTree());
int summeRechts = summe(pTree.getRightTree());

'''//Sachlogik'''
ergebnis += wurzel;
ergebnis += summeLinks;
ergebnis += summeRechts;

return ergebnis;
}
</code>

==Durchlaufen eines Pfades==
In manchen Situationen, vor allem in Bäumen mit Suchbaumstruktur, reicht es, wenn man einen '''Pfad von der Wurzel bis zu einem Blatt durchläuft'''. Das lässt sich mit einer <code>while</code>-Schleife realisieren, d.h. Rekursion ist hier nicht nötig.

===Strategie===
Um einen Pfad in dem Binärbaum <code>pTree</code> von der Wurzel zu einem Blatt zu durchlaufen, geht man wie folgt vor:
* Es wird eine <code>while</code>-Schleife geöffnet, die so lange läuft, bis <code>pTree</code> leer ist.
* In der <code>while</code>-Schleife wird - abhängig von der Sachlogik - nach links oder nach rechts abgebogen. Das realisiert man, indem man <code>pTree</code> durch seinen linken oder rechten Teilbaum updated.
* Nach Beendigung der <code>while</code>-Schleife ist man dann bei einem leeren Knoten unterhalb eines Blattes angekommen.

===Implementierung===
Als Beispiel wird die Methode '''einfuegen''' für einen mit Zahlen gefüllten Suchbaum implementiert.

[https://youtu.be/UGrrFuV3zjY Erklärvideo: Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

<code>
//Beispiel-Attribut
private BinaryTree<Integer> suchbaum;

public void einfuegen(int pZahl) {
//Hilfsbaum definieren, damit man pTree nicht "zersägt":
'''BinaryTree<Integer> b = suchbaum;'''
'''while(!b.isEmpty()){'''
int wurzel = b.getContent();
'''// UPDATE von pTree'''
if(pZahl < wurzel){
// "links abbiegen"
'''b = b.getLeftTree();'''
}
else{
// "rechts abbiegen"
'''b = b.getRightTree();'''
}
}
// jetzt ist man beim richtigen leeren Knoten angekommen!
b.setContent(pZahl);
}
</code>

==Linearisierung==
'''nur relevant für den Leistungskurs!'''

[https://youtu.be/SjniaclqvFs Erklärvideo: Prinzip und Implementierung der Levelorder-Traversierung]

'''Linearisierung''' ist eine Strategie, wie man rekursive Strukturen (z.B. einen Binärbaum) komplett durchlaufen kann, '''''OHNE eine rekursive Methode zu verwenden'''''.

===Vorgehensweise===
Die Vorgehensweise wird hier am Beispiel '''Levelorder''' aufgezeigt.
In Levelorder wird der Binärbaum "schichtenweise" von oben nach unten durchlaufen, d.h. es handelt sich hier um eine '''Breitensuche'''.

Die Idee der Linarisierung ist die folgende:

'''Linearisierung: Baumliste erstellen'''
# eine Hilfsliste <code>baumListe</code> wird angelegt; in diese Hilfsliste kommen nur Bäume!
# der ganze Baum wird in <code>baumListe</code> gepackt, d.h. <code>baumListe</code> hat jetzt ein Element.
# dann wird <code>baumListe</code> mit einer Schleife von vorne bis zum Ende durchlaufen; dabei wird <code>baumListe</code> '''ständig ergänzt!'''
## bei jedem Schleifen-Durchlauf wird das aktuelle Element (=ein Baum) aus <code>baumListe</code> entnommen.
## die beiden Teilbäume (wenn sie nicht leer sind) werden hinten an <code>baumListe</code> angehängt.
# Jetzt hat man in <code>baumListe</code> eine Liste aller Teilbäume von <code>pTree</code>.
## Diese Liste kann jetzt für die Sachlogik verwendet werden.
'''Sachlogik: Ergebnisliste erstellen'''
# eine Ergebnisliste <code>ergebnisListe</code> wird angelegt; in <code>ergebnisListe</code> kommen die Knoten in der Levelorder-Reihenfolge.
# <code>baumListe</code> wird mit einer Schleife durchlaufen. Bei jedem Schleifendurchlauf wird...
## der aktuelle Baum aus <code>baumListe</code> ausgelesen.
## die Wurzel des aktuellen Baumes in <code>ergebnisListe</code> eingefügt.

===Implementierung===

<code>
public List<Object> levelorder(BinaryTree<Object> pTree){
'''//Linearisierung'''
List<BinaryTree<Object>> baumListe = new List<>();
baumListe.append(pTree);
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Object> aktuell = baumListe.getContent();
if(!aktuell.getLeftTree().isEmpty()){
baumListe.append(aktuell.getLeftTree());
}
if(!aktuell.getRightTree().isEmpty()){
baumListe.append(aktuell.getRightTree());
}
baumListe.next();
}
'''// Sachlogik:'''
// die baumListe durchlaufen,
// von jedem Element (Typ: BinaryTree!)
// die Wurzel auslesen und an ergebnisListe anhaengen
List<Object> ergebnisListe = new List<>();
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Object> aktuellerBaum = baumListe.getContent();
Object aktuelleWurzel = aktuellerBaum.getContent();
ergebnisListe.append(aktuelleWurzel);
baumListe.next();
}
return ergebnisListe;
}
</code>

=Rahmenmethode=
siehe [[Binärbaum#Rahmenmethode|Rahmenmethode]] im Artikel [[Binärbaum]].

=weitere beispielhafte Methoden=
==Tiefe==
<code>
public int tiefe(BinaryTree pTree) {
int ergebnis = -1;
if (pTree.isEmpty()) {
// leere Teilbaeume haben Tiefe -1
// denn Baeume, die nur aus einem Blatt bestehen,
// haben Tiefe 0!
return ergebnis;
}
int tiefeLinks = tiefe(pTree.getLeftTree());
int tiefeRechts = tiefe(pTree.getRightTree());
ergebnis = tiefeLinks;
if (ergebnis < tiefeRechts) {
ergebnis = tiefeRechts;
}
// der gesamte Baum ist um eins tiefer, wegen der Wurzel
ergebnis++;
return ergebnis;
}
</code>

==Knotenzahl==
<code>
public int knotenzahl(BinaryTree pTree) {
int ergebnis = 0;
if (pTree.isEmpty()) {
return ergebnis;
}
ergebnis += 1; // die Wurzel zaehlen!
int knotenLinks = knotenzahl(pTree.getLeftTree());
int knotenRechts = knotenzahl(pTree.getRightTree());
ergebnis += knotenLinks;
ergebnis += knotenRechts;
return ergebnis;
}
</code>

==Blätter==
Diese Methode gibt alle Blätter eines Baumes in einer Liste zurück.

Die Methode funktioniert rekursiv.

Man braucht zwei Abbruchbedingungen:
* für einen leeren Baum -> eine leere Liste zurückgeben
* für ein Blatt -> eine Liste mit nur einem Blatt drin zurückgeben

<code>
public List blaetter(BinaryTree<Object> pTree) {
List<Object> ergebnis = new List<>();

if (pTree.isEmpty()) {
return ergebnis;
}

if (pTree.getLeftTree().isEmpty() && pTree.getRightTree().isEmpty()){
// pTree ist ein Blatt!
ergebnis.append(pTree.getContent());
return ergebnis;
}

List<Object> linkesErgebnis = blaetter(pTree.getLeftTree());
List<Object> rechtesErgebnis = blaetter(pTree.getRightTree());

ergebnis.concat(linkesErgebnis);
ergebnis.concat(rechtesErgebnis);

return ergebnis;
}
</code>

==Berechnen==
[[File:Strukturbaum.jpg|thumb|Binärer Strukturbaum (12/4)+(2*3) |300px]]
Diese Methode berechnet das Ergebnis eines Strukturbaumes aus den Rechenzeichen +, -, *, / und Zahlen.

<code>
public double berechnen(BinaryTree<String> b) {
double ergebnis = 0;
if (b.isEmpty()) {
return ergebnis;
}
String wurzelString = b.getContent();
if ( !wurzelString.equals("+") &&
!wurzelString.equals("-") &&
!wurzelString.equals("*") &&
!wurzelString.equals("/")
)
{
double wurzelDouble = Double.parseDouble(wurzelString);
ergebnis = wurzelDouble;
return ergebnis;
}

double ergebnisLinks = berechnen(b.getLeftTree());
double ergebnisRechts = berechnen(b.getRightTree());

if(wurzelString.equals("+")){
ergebnis = ergebnisLinks + ergebnisRechts;
}
else if((wurzelString.equals("-")){
ergebnis = ergebnisLinks - ergebnisRechts;
}
else if((wurzelString.equals("*")){
ergebnis = ergebnisLinks * ergebnisRechts;
}
else if((wurzelString.equals("/")){
ergebnis = ergebnisLinks / ergebnisRechts;
}
else{
System.err.println("unbekanntes Rechenzeichen!");
ergebnis = 0;
}
return ergebnis;
}
</code>

Binärbaum (Methoden)

2026-01-18T18:18:24Z

Akaibel: /* Implementierung */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Datenstrukturen(IF)]]

Hier werden die '''Standard-Strategien''' für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] vorgestellt:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung
Außerdem wird erklärt, was eine '''Rahmenmethode''' ist und wie man sie implementiert.

Für das '''Suchen''' und '''Löschen''' von Elementen: siehe [[binärer Suchbaum ab Abi 2017]]

=Erklärvideos=
* [https://youtu.be/to2supzEiO4 rekursive Methoden für Binärbäume implementieren (Youtube)]
* [https://youtu.be/SjniaclqvFs Prinzip und Implementierung der Levelorder-Traversierung (Youtube)]
* [https://youtu.be/UGrrFuV3zjY Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

=Fachbegriffe=
Rekursion, Abbruchbedingung, rekursiver Aufruf, Sachlogik, Rahmenmethode, Pfaddurchlauf, Linearisierung, Baumliste

=Standard-Strategien=
Für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] gibt es drei Standard-Strategien:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung

==Rekursion==
Binärbäume sind '''rekursive Datenstrukturen''', denn jeder Binärbaum hat zwei Teilbäume - und die sind selber wieder Binärbäume.

Deswegen bietet es sich an, Binärbäume '''rekursiv''' zu durchlaufen.

===Strategie===
Bei der Implementierung einer rekursiven Methode für Binärbäume wird der gesamte Baum nur sehr grob betrachtet: Er besteht aus
* der Wurzel,
* dem linken Teilbaum (für den die Methode rekursiv aufgerufen wird)
* dem rechten Teilbaum (für den die Methode nochmal rekursiv aufgerufen wird).

In der '''Sachlogik''' muss man folgende Frage beantworten:

'''''Wie setzt sich das Gesamtergebnis aus der Wurzel, dem Ergebnis des linken Teilbaumes und dem Ergebnis des rechten Teilbaumes zusammen?'''''


[https://www.youtube.com/watch?v=HDCVf1LXrP0 Erklärvideo zum Vorgehen bei rekursiven Methoden (11:23min)]


<div style="margin:0; margin-right:10px; border:1px dotted #000008; padding: 0em 1em 1em 1em; background-color:#F9F9F9;text-align:left">

'''Bestandteile einer rekursiven Methode für Binärbäume:'''
* Die rekursive Methode braucht als einen '''Parameter einen Binärbaum''', damit man rekursiv für den linken bzw. rechten Teilbaum aufrufen kann.
** Die rekursive Methode wird häufig aus einer '''Rahmenmethode''' aufgerufen.
* eine '''Abbruchbedingung''' oder mehrere Abbruchbedingungen. Diese hängen vom Sachzusammenhang ab - in der Regel braucht man mindestens eine Abbruchbedingung für einen leeren Binärbaum.
* '''Wurzel auslesen''' ''(=Wurzelbehandlung)''
* '''rekursive Aufrufe''': Die Methode ruft sich selber auf.
** Meistens braucht man '''zwei rekursive Aufrufe''': einen für den linken Teilbaum und einen für den rechten Teilbaum.
** Bei Methoden, die etwas zurückgeben, muss man sich für den Rückgabewert interessieren!
* '''Sachlogik''': Hier werden die Wurzel und die Ergebnisse der rekursiven Aufrufe behandelt.
</div>

===Implementierung===
Das rekursive Vorgehen wird hier beispielhaft an der Methode <code>public int summe(BinaryTree<Integer> pTree)</code> aufgezeigt:

<code>
//ein Beispiel-Attribut
private BinaryTree<Integer> suchbaum;

'''//Rahmenmethode'''
public int summe(){
// die Rahmenmethode '''delegiert''' die Aufgabe an die rekursive Methode.
// dabei übergibt sie den zu behandelnden Baum.
return summe(suchbaum);
}

'''//rekursive Methode'''
'''//Parameter vom Typ BinaryTree''' ist notwendig für rekursive Aufrufe!
private int summe(BinaryTree<Integer> pTree){
int ergebnis = 0;

'''//Abbruchbedingung'''
if(pTree.isEmpty()){
return ergebnis;
}

'''//Wurzel auslesen'''
int wurzel = pTree.getContent();

'''//rekursive Aufrufe'''
int summeLinks = summe(pTree.getLeftTree());
int summeRechts = summe(pTree.getRightTree());

'''//Sachlogik'''
ergebnis += wurzel;
ergebnis += summeLinks;
ergebnis += summeRechts;

return ergebnis;
}
</code>

==Durchlaufen eines Pfades==
In manchen Situationen, vor allem in Bäumen mit Suchbaumstruktur, reicht es, wenn man einen '''Pfad von der Wurzel bis zu einem Blatt durchläuft'''. Das lässt sich mit einer <code>while</code>-Schleife realisieren, d.h. Rekursion ist hier nicht nötig.

===Strategie===
Um einen Pfad in dem Binärbaum <code>pTree</code> von der Wurzel zu einem Blatt zu durchlaufen, geht man wie folgt vor:
* Es wird eine <code>while</code>-Schleife geöffnet, die so lange läuft, bis <code>pTree</code> leer ist.
* In der <code>while</code>-Schleife wird - abhängig von der Sachlogik - nach links oder nach rechts abgebogen. Das realisiert man, indem man <code>pTree</code> durch seinen linken oder rechten Teilbaum updated.
* Nach Beendigung der <code>while</code>-Schleife ist man dann bei einem leeren Knoten unterhalb eines Blattes angekommen.

===Implementierung===
Als Beispiel wird die Methode '''einfuegen''' für einen mit Zahlen gefüllten Suchbaum implementiert.

[https://youtu.be/UGrrFuV3zjY Erklärvideo: Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

<code>
//Beispiel-Attribut
private BinaryTree<Integer> suchbaum;

public void einfuegen(int pZahl) {
//Hilfsbaum definieren, damit man pTree nicht "zersägt":
'''BinaryTree<Integer> b = suchbaum;'''
'''while(!b.isEmpty()){'''
int wurzel = b.getContent();
'''// UPDATE von pTree'''
if(pZahl < wurzel){
// "links abbiegen"
'''b = b.getLeftTree();'''
}
else{
// "rechts abbiegen"
'''b = b.getRightTree();'''
}
}
// jetzt ist man beim richtigen leeren Knoten angekommen!
b.setContent(pZahl);
}
</code>

==Linearisierung==
'''nur relevant für den Leistungskurs!'''

[https://youtu.be/SjniaclqvFs Erklärvideo: Prinzip und Implementierung der Levelorder-Traversierung]

'''Linearisierung''' ist eine Strategie, wie man rekursive Strukturen (z.B. einen Binärbaum) komplett durchlaufen kann, '''''OHNE eine rekursive Methode zu verwenden'''''.

===Vorgehensweise===
Die Vorgehensweise wird hier am Beispiel '''Levelorder''' aufgezeigt.
In Levelorder wird der Binärbaum "schichtenweise" von oben nach unten durchlaufen, d.h. es handelt sich hier um eine '''Breitensuche'''.

Die Idee der Linarisierung ist die folgende:

'''Linearisierung:'''
# eine Hilfsliste <code>baumListe</code> wird angelegt; in diese Hilfsliste kommen nur Bäume!
# der ganze Baum wird in <code>baumListe</code> gepackt, d.h. <code>baumListe</code> hat jetzt ein Element.
# dann wird <code>baumListe</code> mit einer Schleife von vorne bis zum Ende durchlaufen; dabei wird <code>baumListe</code> '''ständig ergänzt!'''
## bei jedem Schleifen-Durchlauf wird das aktuelle Element (=ein Baum) aus <code>baumListe</code> entnommen.
## die beiden Teilbäume (wenn sie nicht leer sind) werden hinten an <code>baumListe</code> angehängt.
# Jetzt hat man in <code>baumListe</code> eine Liste aller Teilbäume von <code>pTree</code>.
## Diese Liste kann jetzt für die Sachlogik verwendet werden.
'''Sachlogik:'''
# eine Ergebnisliste <code>ergebnisListe</code> wird angelegt; in <code>ergebnisListe</code> kommen die Knoten in der Levelorder-Reihenfolge.
# <code>baumListe</code> wird mit einer Schleife durchlaufen. Bei jedem Schleifendurchlauf wird...
## der aktuelle Baum aus <code>baumListe</code> ausgelesen.
## die Wurzel des aktuellen Baumes in <code>ergebnisListe</code> eingefügt.

===Implementierung===

<code>
public List<Object> levelorder(BinaryTree<Object> pTree){
'''//Linearisierung'''
List<BinaryTree<Object>> baumListe = new List<>();
baumListe.append(pTree);
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Object> aktuell = baumListe.getContent();
if(!aktuell.getLeftTree().isEmpty()){
baumListe.append(aktuell.getLeftTree());
}
if(!aktuell.getRightTree().isEmpty()){
baumListe.append(aktuell.getRightTree());
}
baumListe.next();
}
'''// Sachlogik:'''
// die baumListe durchlaufen,
// von jedem Element (Typ: BinaryTree!)
// die Wurzel auslesen und an ergebnisListe anhaengen
List<Object> ergebnisListe = new List<>();
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Object> aktuellerBaum = baumListe.getContent();
Object aktuelleWurzel = aktuellerBaum.getContent();
ergebnisListe.append(aktuelleWurzel);
baumListe.next();
}
return ergebnisListe;
}
</code>

=Rahmenmethode=
siehe [[Binärbaum#Rahmenmethode|Rahmenmethode]] im Artikel [[Binärbaum]].

=weitere beispielhafte Methoden=
==Tiefe==
<code>
public int tiefe(BinaryTree pTree) {
int ergebnis = -1;
if (pTree.isEmpty()) {
// leere Teilbaeume haben Tiefe -1
// denn Baeume, die nur aus einem Blatt bestehen,
// haben Tiefe 0!
return ergebnis;
}
int tiefeLinks = tiefe(pTree.getLeftTree());
int tiefeRechts = tiefe(pTree.getRightTree());
ergebnis = tiefeLinks;
if (ergebnis < tiefeRechts) {
ergebnis = tiefeRechts;
}
// der gesamte Baum ist um eins tiefer, wegen der Wurzel
ergebnis++;
return ergebnis;
}
</code>

==Knotenzahl==
<code>
public int knotenzahl(BinaryTree pTree) {
int ergebnis = 0;
if (pTree.isEmpty()) {
return ergebnis;
}
ergebnis += 1; // die Wurzel zaehlen!
int knotenLinks = knotenzahl(pTree.getLeftTree());
int knotenRechts = knotenzahl(pTree.getRightTree());
ergebnis += knotenLinks;
ergebnis += knotenRechts;
return ergebnis;
}
</code>

==Blätter==
Diese Methode gibt alle Blätter eines Baumes in einer Liste zurück.

Die Methode funktioniert rekursiv.

Man braucht zwei Abbruchbedingungen:
* für einen leeren Baum -> eine leere Liste zurückgeben
* für ein Blatt -> eine Liste mit nur einem Blatt drin zurückgeben

<code>
public List blaetter(BinaryTree<Object> pTree) {
List<Object> ergebnis = new List<>();

if (pTree.isEmpty()) {
return ergebnis;
}

if (pTree.getLeftTree().isEmpty() && pTree.getRightTree().isEmpty()){
// pTree ist ein Blatt!
ergebnis.append(pTree.getContent());
return ergebnis;
}

List<Object> linkesErgebnis = blaetter(pTree.getLeftTree());
List<Object> rechtesErgebnis = blaetter(pTree.getRightTree());

ergebnis.concat(linkesErgebnis);
ergebnis.concat(rechtesErgebnis);

return ergebnis;
}
</code>

==Berechnen==
[[File:Strukturbaum.jpg|thumb|Binärer Strukturbaum (12/4)+(2*3) |300px]]
Diese Methode berechnet das Ergebnis eines Strukturbaumes aus den Rechenzeichen +, -, *, / und Zahlen.

<code>
public double berechnen(BinaryTree<String> b) {
double ergebnis = 0;
if (b.isEmpty()) {
return ergebnis;
}
String wurzelString = b.getContent();
if ( !wurzelString.equals("+") &&
!wurzelString.equals("-") &&
!wurzelString.equals("*") &&
!wurzelString.equals("/")
)
{
double wurzelDouble = Double.parseDouble(wurzelString);
ergebnis = wurzelDouble;
return ergebnis;
}

double ergebnisLinks = berechnen(b.getLeftTree());
double ergebnisRechts = berechnen(b.getRightTree());

if(wurzelString.equals("+")){
ergebnis = ergebnisLinks + ergebnisRechts;
}
else if((wurzelString.equals("-")){
ergebnis = ergebnisLinks - ergebnisRechts;
}
else if((wurzelString.equals("*")){
ergebnis = ergebnisLinks * ergebnisRechts;
}
else if((wurzelString.equals("/")){
ergebnis = ergebnisLinks / ergebnisRechts;
}
else{
System.err.println("unbekanntes Rechenzeichen!");
ergebnis = 0;
}
return ergebnis;
}
</code>

Binärbaum (Methoden)

2026-01-18T18:14:51Z

Akaibel: /* Implementierung */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Datenstrukturen(IF)]]

Hier werden die '''Standard-Strategien''' für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] vorgestellt:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung
Außerdem wird erklärt, was eine '''Rahmenmethode''' ist und wie man sie implementiert.

Für das '''Suchen''' und '''Löschen''' von Elementen: siehe [[binärer Suchbaum ab Abi 2017]]

=Erklärvideos=
* [https://youtu.be/to2supzEiO4 rekursive Methoden für Binärbäume implementieren (Youtube)]
* [https://youtu.be/SjniaclqvFs Prinzip und Implementierung der Levelorder-Traversierung (Youtube)]
* [https://youtu.be/UGrrFuV3zjY Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

=Fachbegriffe=
Rekursion, Abbruchbedingung, rekursiver Aufruf, Sachlogik, Rahmenmethode, Pfaddurchlauf, Linearisierung, Baumliste

=Standard-Strategien=
Für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] gibt es drei Standard-Strategien:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung

==Rekursion==
Binärbäume sind '''rekursive Datenstrukturen''', denn jeder Binärbaum hat zwei Teilbäume - und die sind selber wieder Binärbäume.

Deswegen bietet es sich an, Binärbäume '''rekursiv''' zu durchlaufen.

===Strategie===
Bei der Implementierung einer rekursiven Methode für Binärbäume wird der gesamte Baum nur sehr grob betrachtet: Er besteht aus
* der Wurzel,
* dem linken Teilbaum (für den die Methode rekursiv aufgerufen wird)
* dem rechten Teilbaum (für den die Methode nochmal rekursiv aufgerufen wird).

In der '''Sachlogik''' muss man folgende Frage beantworten:

'''''Wie setzt sich das Gesamtergebnis aus der Wurzel, dem Ergebnis des linken Teilbaumes und dem Ergebnis des rechten Teilbaumes zusammen?'''''


[https://www.youtube.com/watch?v=HDCVf1LXrP0 Erklärvideo zum Vorgehen bei rekursiven Methoden (11:23min)]


<div style="margin:0; margin-right:10px; border:1px dotted #000008; padding: 0em 1em 1em 1em; background-color:#F9F9F9;text-align:left">

'''Bestandteile einer rekursiven Methode für Binärbäume:'''
* Die rekursive Methode braucht als einen '''Parameter einen Binärbaum''', damit man rekursiv für den linken bzw. rechten Teilbaum aufrufen kann.
** Die rekursive Methode wird häufig aus einer '''Rahmenmethode''' aufgerufen.
* eine '''Abbruchbedingung''' oder mehrere Abbruchbedingungen. Diese hängen vom Sachzusammenhang ab - in der Regel braucht man mindestens eine Abbruchbedingung für einen leeren Binärbaum.
* '''Wurzel auslesen''' ''(=Wurzelbehandlung)''
* '''rekursive Aufrufe''': Die Methode ruft sich selber auf.
** Meistens braucht man '''zwei rekursive Aufrufe''': einen für den linken Teilbaum und einen für den rechten Teilbaum.
** Bei Methoden, die etwas zurückgeben, muss man sich für den Rückgabewert interessieren!
* '''Sachlogik''': Hier werden die Wurzel und die Ergebnisse der rekursiven Aufrufe behandelt.
</div>

===Implementierung===
Das rekursive Vorgehen wird hier beispielhaft an der Methode <code>public int summe(BinaryTree<Integer> pTree)</code> aufgezeigt:

<code>
//ein Beispiel-Attribut
private BinaryTree<Integer> suchbaum;

'''//Rahmenmethode'''
public int summe(){
// die Rahmenmethode '''delegiert''' die Aufgabe an die rekursive Methode.
// dabei übergibt sie den zu behandelnden Baum.
return summe(suchbaum);
}

'''//rekursive Methode'''
'''//Parameter vom Typ BinaryTree''' ist notwendig für rekursive Aufrufe!
private int summe(BinaryTree<Integer> pTree){
int ergebnis = 0;

'''//Abbruchbedingung'''
if(pTree.isEmpty()){
return ergebnis;
}

'''//Wurzel auslesen'''
int wurzel = pTree.getContent();

'''//rekursive Aufrufe'''
int summeLinks = summe(pTree.getLeftTree());
int summeRechts = summe(pTree.getRightTree());

'''//Sachlogik'''
ergebnis += wurzel;
ergebnis += summeLinks;
ergebnis += summeRechts;

return ergebnis;
}
</code>

==Durchlaufen eines Pfades==
In manchen Situationen, vor allem in Bäumen mit Suchbaumstruktur, reicht es, wenn man einen '''Pfad von der Wurzel bis zu einem Blatt durchläuft'''. Das lässt sich mit einer <code>while</code>-Schleife realisieren, d.h. Rekursion ist hier nicht nötig.

===Strategie===
Um einen Pfad in dem Binärbaum <code>pTree</code> von der Wurzel zu einem Blatt zu durchlaufen, geht man wie folgt vor:
* Es wird eine <code>while</code>-Schleife geöffnet, die so lange läuft, bis <code>pTree</code> leer ist.
* In der <code>while</code>-Schleife wird - abhängig von der Sachlogik - nach links oder nach rechts abgebogen. Das realisiert man, indem man <code>pTree</code> durch seinen linken oder rechten Teilbaum updated.
* Nach Beendigung der <code>while</code>-Schleife ist man dann bei einem leeren Knoten unterhalb eines Blattes angekommen.

===Implementierung===
Als Beispiel wird die Methode '''einfuegen''' für einen mit Zahlen gefüllten Suchbaum implementiert.

[https://youtu.be/UGrrFuV3zjY Erklärvideo: Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

<code>
public void einfuegen(BinaryTree<Integer> pTree, int pZahl) {
//Hilfsbaum definieren, damit man pTree nicht "zersägt":
'''BinaryTree<Integer> b = pTree;'''
'''while(!b.isEmpty()){'''
int wurzel = b.getContent();
'''// UPDATE von pTree'''
if(pZahl < wurzel){
'''b = b.getLeftTree();'''
}
else{
'''b = b.getRightTree();'''
}
}
// jetzt ist man beim richtigen leeren Knoten angekommen!
b.setContent(pZahl);
}
</code>

==Linearisierung==
'''nur relevant für den Leistungskurs!'''

[https://youtu.be/SjniaclqvFs Erklärvideo: Prinzip und Implementierung der Levelorder-Traversierung]

'''Linearisierung''' ist eine Strategie, wie man rekursive Strukturen (z.B. einen Binärbaum) komplett durchlaufen kann, '''''OHNE eine rekursive Methode zu verwenden'''''.

===Vorgehensweise===
Die Vorgehensweise wird hier am Beispiel '''Levelorder''' aufgezeigt.
In Levelorder wird der Binärbaum "schichtenweise" von oben nach unten durchlaufen, d.h. es handelt sich hier um eine '''Breitensuche'''.

Die Idee der Linarisierung ist die folgende:

'''Linearisierung:'''
# eine Hilfsliste <code>baumListe</code> wird angelegt; in diese Hilfsliste kommen nur Bäume!
# der ganze Baum wird in <code>baumListe</code> gepackt, d.h. <code>baumListe</code> hat jetzt ein Element.
# dann wird <code>baumListe</code> mit einer Schleife von vorne bis zum Ende durchlaufen; dabei wird <code>baumListe</code> '''ständig ergänzt!'''
## bei jedem Schleifen-Durchlauf wird das aktuelle Element (=ein Baum) aus <code>baumListe</code> entnommen.
## die beiden Teilbäume (wenn sie nicht leer sind) werden hinten an <code>baumListe</code> angehängt.
# Jetzt hat man in <code>baumListe</code> eine Liste aller Teilbäume von <code>pTree</code>.
## Diese Liste kann jetzt für die Sachlogik verwendet werden.
'''Sachlogik:'''
# eine Ergebnisliste <code>ergebnisListe</code> wird angelegt; in <code>ergebnisListe</code> kommen die Knoten in der Levelorder-Reihenfolge.
# <code>baumListe</code> wird mit einer Schleife durchlaufen. Bei jedem Schleifendurchlauf wird...
## der aktuelle Baum aus <code>baumListe</code> ausgelesen.
## die Wurzel des aktuellen Baumes in <code>ergebnisListe</code> eingefügt.

===Implementierung===

<code>
public List<Object> levelorder(BinaryTree<Object> pTree){
'''//Linearisierung'''
List<BinaryTree<Object>> baumListe = new List<>();
baumListe.append(pTree);
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Object> aktuell = baumListe.getContent();
if(!aktuell.getLeftTree().isEmpty()){
baumListe.append(aktuell.getLeftTree());
}
if(!aktuell.getRightTree().isEmpty()){
baumListe.append(aktuell.getRightTree());
}
baumListe.next();
}
'''// Sachlogik:'''
// die baumListe durchlaufen,
// von jedem Element (Typ: BinaryTree!)
// die Wurzel auslesen und an ergebnisListe anhaengen
List<Object> ergebnisListe = new List<>();
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Object> aktuellerBaum = baumListe.getContent();
Object aktuelleWurzel = aktuellerBaum.getContent();
ergebnisListe.append(aktuelleWurzel);
baumListe.next();
}
return ergebnisListe;
}
</code>

=Rahmenmethode=
siehe [[Binärbaum#Rahmenmethode|Rahmenmethode]] im Artikel [[Binärbaum]].

=weitere beispielhafte Methoden=
==Tiefe==
<code>
public int tiefe(BinaryTree pTree) {
int ergebnis = -1;
if (pTree.isEmpty()) {
// leere Teilbaeume haben Tiefe -1
// denn Baeume, die nur aus einem Blatt bestehen,
// haben Tiefe 0!
return ergebnis;
}
int tiefeLinks = tiefe(pTree.getLeftTree());
int tiefeRechts = tiefe(pTree.getRightTree());
ergebnis = tiefeLinks;
if (ergebnis < tiefeRechts) {
ergebnis = tiefeRechts;
}
// der gesamte Baum ist um eins tiefer, wegen der Wurzel
ergebnis++;
return ergebnis;
}
</code>

==Knotenzahl==
<code>
public int knotenzahl(BinaryTree pTree) {
int ergebnis = 0;
if (pTree.isEmpty()) {
return ergebnis;
}
ergebnis += 1; // die Wurzel zaehlen!
int knotenLinks = knotenzahl(pTree.getLeftTree());
int knotenRechts = knotenzahl(pTree.getRightTree());
ergebnis += knotenLinks;
ergebnis += knotenRechts;
return ergebnis;
}
</code>

==Blätter==
Diese Methode gibt alle Blätter eines Baumes in einer Liste zurück.

Die Methode funktioniert rekursiv.

Man braucht zwei Abbruchbedingungen:
* für einen leeren Baum -> eine leere Liste zurückgeben
* für ein Blatt -> eine Liste mit nur einem Blatt drin zurückgeben

<code>
public List blaetter(BinaryTree<Object> pTree) {
List<Object> ergebnis = new List<>();

if (pTree.isEmpty()) {
return ergebnis;
}

if (pTree.getLeftTree().isEmpty() && pTree.getRightTree().isEmpty()){
// pTree ist ein Blatt!
ergebnis.append(pTree.getContent());
return ergebnis;
}

List<Object> linkesErgebnis = blaetter(pTree.getLeftTree());
List<Object> rechtesErgebnis = blaetter(pTree.getRightTree());

ergebnis.concat(linkesErgebnis);
ergebnis.concat(rechtesErgebnis);

return ergebnis;
}
</code>

==Berechnen==
[[File:Strukturbaum.jpg|thumb|Binärer Strukturbaum (12/4)+(2*3) |300px]]
Diese Methode berechnet das Ergebnis eines Strukturbaumes aus den Rechenzeichen +, -, *, / und Zahlen.

<code>
public double berechnen(BinaryTree<String> b) {
double ergebnis = 0;
if (b.isEmpty()) {
return ergebnis;
}
String wurzelString = b.getContent();
if ( !wurzelString.equals("+") &&
!wurzelString.equals("-") &&
!wurzelString.equals("*") &&
!wurzelString.equals("/")
)
{
double wurzelDouble = Double.parseDouble(wurzelString);
ergebnis = wurzelDouble;
return ergebnis;
}

double ergebnisLinks = berechnen(b.getLeftTree());
double ergebnisRechts = berechnen(b.getRightTree());

if(wurzelString.equals("+")){
ergebnis = ergebnisLinks + ergebnisRechts;
}
else if((wurzelString.equals("-")){
ergebnis = ergebnisLinks - ergebnisRechts;
}
else if((wurzelString.equals("*")){
ergebnis = ergebnisLinks * ergebnisRechts;
}
else if((wurzelString.equals("/")){
ergebnis = ergebnisLinks / ergebnisRechts;
}
else{
System.err.println("unbekanntes Rechenzeichen!");
ergebnis = 0;
}
return ergebnis;
}
</code>

Binärbaum (Methoden)

2026-01-18T18:14:26Z

Akaibel: /* Rekursion */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Abitur]]
[[Kategorie:Datenstrukturen(IF)]]

Hier werden die '''Standard-Strategien''' für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] vorgestellt:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung
Außerdem wird erklärt, was eine '''Rahmenmethode''' ist und wie man sie implementiert.

Für das '''Suchen''' und '''Löschen''' von Elementen: siehe [[binärer Suchbaum ab Abi 2017]]

=Erklärvideos=
* [https://youtu.be/to2supzEiO4 rekursive Methoden für Binärbäume implementieren (Youtube)]
* [https://youtu.be/SjniaclqvFs Prinzip und Implementierung der Levelorder-Traversierung (Youtube)]
* [https://youtu.be/UGrrFuV3zjY Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

=Fachbegriffe=
Rekursion, Abbruchbedingung, rekursiver Aufruf, Sachlogik, Rahmenmethode, Pfaddurchlauf, Linearisierung, Baumliste

=Standard-Strategien=
Für das Durchlaufen von [[allgemeiner Binärbaum ab Abi 2017|Binärbäumen]] gibt es drei Standard-Strategien:
* Rekursion
* Durchlaufen eines Pfades mit einer <code>while</code>-Schleife
* Linearisierung

==Rekursion==
Binärbäume sind '''rekursive Datenstrukturen''', denn jeder Binärbaum hat zwei Teilbäume - und die sind selber wieder Binärbäume.

Deswegen bietet es sich an, Binärbäume '''rekursiv''' zu durchlaufen.

===Strategie===
Bei der Implementierung einer rekursiven Methode für Binärbäume wird der gesamte Baum nur sehr grob betrachtet: Er besteht aus
* der Wurzel,
* dem linken Teilbaum (für den die Methode rekursiv aufgerufen wird)
* dem rechten Teilbaum (für den die Methode nochmal rekursiv aufgerufen wird).

In der '''Sachlogik''' muss man folgende Frage beantworten:

'''''Wie setzt sich das Gesamtergebnis aus der Wurzel, dem Ergebnis des linken Teilbaumes und dem Ergebnis des rechten Teilbaumes zusammen?'''''


[https://www.youtube.com/watch?v=HDCVf1LXrP0 Erklärvideo zum Vorgehen bei rekursiven Methoden (11:23min)]


<div style="margin:0; margin-right:10px; border:1px dotted #000008; padding: 0em 1em 1em 1em; background-color:#F9F9F9;text-align:left">

'''Bestandteile einer rekursiven Methode für Binärbäume:'''
* Die rekursive Methode braucht als einen '''Parameter einen Binärbaum''', damit man rekursiv für den linken bzw. rechten Teilbaum aufrufen kann.
** Die rekursive Methode wird häufig aus einer '''Rahmenmethode''' aufgerufen.
* eine '''Abbruchbedingung''' oder mehrere Abbruchbedingungen. Diese hängen vom Sachzusammenhang ab - in der Regel braucht man mindestens eine Abbruchbedingung für einen leeren Binärbaum.
* '''Wurzel auslesen''' ''(=Wurzelbehandlung)''
* '''rekursive Aufrufe''': Die Methode ruft sich selber auf.
** Meistens braucht man '''zwei rekursive Aufrufe''': einen für den linken Teilbaum und einen für den rechten Teilbaum.
** Bei Methoden, die etwas zurückgeben, muss man sich für den Rückgabewert interessieren!
* '''Sachlogik''': Hier werden die Wurzel und die Ergebnisse der rekursiven Aufrufe behandelt.
</div>

===Implementierung===
Das rekursive Vorgehen wird hier beispielhaft an der Methode <code>public int summe(BinaryTree<Integer> pTree)</code> aufgezeigt:

<code>
//ein Beispiel-Attribut
private BinaryTree<Integer> suchbaum;

'''//Rahmenmethode'''
public int summe(){
// die Rahmenmethode '''delegiert''' die Aufgabe an die rekursive Methode.
// dabei übergibt sie den zu behandelnden Baum.
return summe(suchbaum);
}

'''//rekursive Methode'''
'''//Parameter vom Typ BinaryTree''' ist notwendig für rekursive Aufrufe!
public int summe(BinaryTree<Integer> pTree){
int ergebnis = 0;

'''//Abbruchbedingung'''
if(pTree.isEmpty()){
return ergebnis;
}

'''//Wurzel auslesen'''
int wurzel = pTree.getContent();

'''//rekursive Aufrufe'''
int summeLinks = summe(pTree.getLeftTree());
int summeRechts = summe(pTree.getRightTree());

'''//Sachlogik'''
ergebnis += wurzel;
ergebnis += summeLinks;
ergebnis += summeRechts;

return ergebnis;
}
</code>

==Durchlaufen eines Pfades==
In manchen Situationen, vor allem in Bäumen mit Suchbaumstruktur, reicht es, wenn man einen '''Pfad von der Wurzel bis zu einem Blatt durchläuft'''. Das lässt sich mit einer <code>while</code>-Schleife realisieren, d.h. Rekursion ist hier nicht nötig.

===Strategie===
Um einen Pfad in dem Binärbaum <code>pTree</code> von der Wurzel zu einem Blatt zu durchlaufen, geht man wie folgt vor:
* Es wird eine <code>while</code>-Schleife geöffnet, die so lange läuft, bis <code>pTree</code> leer ist.
* In der <code>while</code>-Schleife wird - abhängig von der Sachlogik - nach links oder nach rechts abgebogen. Das realisiert man, indem man <code>pTree</code> durch seinen linken oder rechten Teilbaum updated.
* Nach Beendigung der <code>while</code>-Schleife ist man dann bei einem leeren Knoten unterhalb eines Blattes angekommen.

===Implementierung===
Als Beispiel wird die Methode '''einfuegen''' für einen mit Zahlen gefüllten Suchbaum implementiert.

[https://youtu.be/UGrrFuV3zjY Erklärvideo: Pfaddurchlauf durch einen Binärbaum implementieren (Youtube)]

<code>
public void einfuegen(BinaryTree<Integer> pTree, int pZahl) {
//Hilfsbaum definieren, damit man pTree nicht "zersägt":
'''BinaryTree<Integer> b = pTree;'''
'''while(!b.isEmpty()){'''
int wurzel = b.getContent();
'''// UPDATE von pTree'''
if(pZahl < wurzel){
'''b = b.getLeftTree();'''
}
else{
'''b = b.getRightTree();'''
}
}
// jetzt ist man beim richtigen leeren Knoten angekommen!
b.setContent(pZahl);
}
</code>

==Linearisierung==
'''nur relevant für den Leistungskurs!'''

[https://youtu.be/SjniaclqvFs Erklärvideo: Prinzip und Implementierung der Levelorder-Traversierung]

'''Linearisierung''' ist eine Strategie, wie man rekursive Strukturen (z.B. einen Binärbaum) komplett durchlaufen kann, '''''OHNE eine rekursive Methode zu verwenden'''''.

===Vorgehensweise===
Die Vorgehensweise wird hier am Beispiel '''Levelorder''' aufgezeigt.
In Levelorder wird der Binärbaum "schichtenweise" von oben nach unten durchlaufen, d.h. es handelt sich hier um eine '''Breitensuche'''.

Die Idee der Linarisierung ist die folgende:

'''Linearisierung:'''
# eine Hilfsliste <code>baumListe</code> wird angelegt; in diese Hilfsliste kommen nur Bäume!
# der ganze Baum wird in <code>baumListe</code> gepackt, d.h. <code>baumListe</code> hat jetzt ein Element.
# dann wird <code>baumListe</code> mit einer Schleife von vorne bis zum Ende durchlaufen; dabei wird <code>baumListe</code> '''ständig ergänzt!'''
## bei jedem Schleifen-Durchlauf wird das aktuelle Element (=ein Baum) aus <code>baumListe</code> entnommen.
## die beiden Teilbäume (wenn sie nicht leer sind) werden hinten an <code>baumListe</code> angehängt.
# Jetzt hat man in <code>baumListe</code> eine Liste aller Teilbäume von <code>pTree</code>.
## Diese Liste kann jetzt für die Sachlogik verwendet werden.
'''Sachlogik:'''
# eine Ergebnisliste <code>ergebnisListe</code> wird angelegt; in <code>ergebnisListe</code> kommen die Knoten in der Levelorder-Reihenfolge.
# <code>baumListe</code> wird mit einer Schleife durchlaufen. Bei jedem Schleifendurchlauf wird...
## der aktuelle Baum aus <code>baumListe</code> ausgelesen.
## die Wurzel des aktuellen Baumes in <code>ergebnisListe</code> eingefügt.

===Implementierung===

<code>
public List<Object> levelorder(BinaryTree<Object> pTree){
'''//Linearisierung'''
List<BinaryTree<Object>> baumListe = new List<>();
baumListe.append(pTree);
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Object> aktuell = baumListe.getContent();
if(!aktuell.getLeftTree().isEmpty()){
baumListe.append(aktuell.getLeftTree());
}
if(!aktuell.getRightTree().isEmpty()){
baumListe.append(aktuell.getRightTree());
}
baumListe.next();
}
'''// Sachlogik:'''
// die baumListe durchlaufen,
// von jedem Element (Typ: BinaryTree!)
// die Wurzel auslesen und an ergebnisListe anhaengen
List<Object> ergebnisListe = new List<>();
baumListe.toFirst();
while(baumListe.hasAccess()){
BinaryTree<Object> aktuellerBaum = baumListe.getContent();
Object aktuelleWurzel = aktuellerBaum.getContent();
ergebnisListe.append(aktuelleWurzel);
baumListe.next();
}
return ergebnisListe;
}
</code>

=Rahmenmethode=
siehe [[Binärbaum#Rahmenmethode|Rahmenmethode]] im Artikel [[Binärbaum]].

=weitere beispielhafte Methoden=
==Tiefe==
<code>
public int tiefe(BinaryTree pTree) {
int ergebnis = -1;
if (pTree.isEmpty()) {
// leere Teilbaeume haben Tiefe -1
// denn Baeume, die nur aus einem Blatt bestehen,
// haben Tiefe 0!
return ergebnis;
}
int tiefeLinks = tiefe(pTree.getLeftTree());
int tiefeRechts = tiefe(pTree.getRightTree());
ergebnis = tiefeLinks;
if (ergebnis < tiefeRechts) {
ergebnis = tiefeRechts;
}
// der gesamte Baum ist um eins tiefer, wegen der Wurzel
ergebnis++;
return ergebnis;
}
</code>

==Knotenzahl==
<code>
public int knotenzahl(BinaryTree pTree) {
int ergebnis = 0;
if (pTree.isEmpty()) {
return ergebnis;
}
ergebnis += 1; // die Wurzel zaehlen!
int knotenLinks = knotenzahl(pTree.getLeftTree());
int knotenRechts = knotenzahl(pTree.getRightTree());
ergebnis += knotenLinks;
ergebnis += knotenRechts;
return ergebnis;
}
</code>

==Blätter==
Diese Methode gibt alle Blätter eines Baumes in einer Liste zurück.

Die Methode funktioniert rekursiv.

Man braucht zwei Abbruchbedingungen:
* für einen leeren Baum -> eine leere Liste zurückgeben
* für ein Blatt -> eine Liste mit nur einem Blatt drin zurückgeben

<code>
public List blaetter(BinaryTree<Object> pTree) {
List<Object> ergebnis = new List<>();

if (pTree.isEmpty()) {
return ergebnis;
}

if (pTree.getLeftTree().isEmpty() && pTree.getRightTree().isEmpty()){
// pTree ist ein Blatt!
ergebnis.append(pTree.getContent());
return ergebnis;
}

List<Object> linkesErgebnis = blaetter(pTree.getLeftTree());
List<Object> rechtesErgebnis = blaetter(pTree.getRightTree());

ergebnis.concat(linkesErgebnis);
ergebnis.concat(rechtesErgebnis);

return ergebnis;
}
</code>

==Berechnen==
[[File:Strukturbaum.jpg|thumb|Binärer Strukturbaum (12/4)+(2*3) |300px]]
Diese Methode berechnet das Ergebnis eines Strukturbaumes aus den Rechenzeichen +, -, *, / und Zahlen.

<code>
public double berechnen(BinaryTree<String> b) {
double ergebnis = 0;
if (b.isEmpty()) {
return ergebnis;
}
String wurzelString = b.getContent();
if ( !wurzelString.equals("+") &&
!wurzelString.equals("-") &&
!wurzelString.equals("*") &&
!wurzelString.equals("/")
)
{
double wurzelDouble = Double.parseDouble(wurzelString);
ergebnis = wurzelDouble;
return ergebnis;
}

double ergebnisLinks = berechnen(b.getLeftTree());
double ergebnisRechts = berechnen(b.getRightTree());

if(wurzelString.equals("+")){
ergebnis = ergebnisLinks + ergebnisRechts;
}
else if((wurzelString.equals("-")){
ergebnis = ergebnisLinks - ergebnisRechts;
}
else if((wurzelString.equals("*")){
ergebnis = ergebnisLinks * ergebnisRechts;
}
else if((wurzelString.equals("/")){
ergebnis = ergebnisLinks / ergebnisRechts;
}
else{
System.err.println("unbekanntes Rechenzeichen!");
ergebnis = 0;
}
return ergebnis;
}
</code>

List

2025-12-01T13:17:42Z

Akaibel: Rückgabetyp der Methode korrigiert.

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Datenstrukturen(IF)]]
[[Kategorie:Informatik-Abitur]]
'''Diese Seite entspricht dem Abi 17 (und folgenden)'''
=Erklärvideo=
Wie durchläuft man standardmäßig Listen?

Das wird hier anhand der Methode <code>public int gesamtVermoegen()</code> erklärt.

[https://youtu.be/W3-JBKnl7xk Erklärvideo: Liste durchlaufen am Beispiel "public int gesamtVermoegen()"]

=Fachbegriffe=

Liste, Zeiger, an den Anfang, aktuelles Element, hasAccess(), ist leer (=isEmpty()), einfügen, (hinten) anhängen, (das aktuelle Element) löschen

= Schnittstellenbeschreibung (Zentralabitur) =
* [[Medium:Dokumentation_List_Abi2017.pdf|Schnittstelle der Klasse List (PDF)]]

=Standardvorgehen im Umgang mit Listen=
Meistens werden Listen von vorne nach hinten durchlaufen und dabei wird mit jedem einzelnen Eintrag der Liste etwas gemacht. Das funktioniert folgendermaßen:
# Zeiger auf den Anfang der Liste setzen
# while-Schleife, die so lange läuft, wie der Zeiger in der Liste ist. Innerhalb der Schleife...
## das Element, auf das der Zeiger zeigt, in einer lokalen Variable speichern.
## mit diesem Element etwas machen (das hängt von der Aufgabe der Methode ab)
## den Zeiger eins weiterrücken.

=Java=
In '''Java''' sieht das so aus (die Liste ist in diesem Beispiel mit Objekten vom Typ <code>Person</code> gefüllt):
* <code>pList.toFirst();</code>
* <code>while(pList.hasAccess()){</code>
** <code>Person p = pList.getContent();</code>
** <code>//TODO: mit der Person p etwas machen!</code>
** <code>pList.next();</code>
* <code>}</code>

==Mit for-Schleife==
'''Mit einer for-Schleife lässt sich dieses Standard-Verfahren viel einfacher implementieren!'''
* <code>for(pList.toFirst(); pList.hasAccess(); pList.next()){</code>
** <code>Person p = pList.getContent();</code>
** <code>//TODO: mit der Person p etwas machen!</code>
* <code>}</code>

=Beispielmethoden für Listen=
Hier werden beispielhaft einige Methoden für Listen aufgeführt:

==enthaelt==
<code>
private boolean enthaelt(List<Person> pList, String pName) {
boolean ergebnis = false;
pList.toFirst();
while(pList.hasAccess()){
Person p = pList.getContent();
if(p.gibName().equals(pName)){
ergebnis = true;
}
pList.next();
}
return ergebnis;
}
</code>

Die Methode zeigt das Standard-Vorgehen zum Durchlaufen von Listen:
* Es wird ein <code>ergebnis</code> deklariert. <code>ergebnis</code> ist vom selben Typ wie der Rückgabetyp der Methode (hier: <code>boolean</code>). <code>ergebnis</code> wird mit einem Standardwert versehen: Bevor man die Liste durchsucht, hat man noch nichts gefunden, d.h. <code>ergebnis</code> ist <code>false</code>
* Der Zeiger wird auf den Anfang der Liste gesetzt.
* Mit <code>while(pList.hasAccess())</code> und <code>pList.next()</code> wird die Liste dann komplett durchlaufen.
* Dabei wird mit <code>Person p = pList.getContent();</code> jeweils die Person ausgelesen, auf die der Zeiger zeigt.
* Mit der Person <code>p</code> wird dann etwas gemacht; in diesem Fall wird ihr Name mit dem Parameter <code>pName</code> verglichen und wenn das übereinstimmt, dann wird <code>ergebnis</code> auf <code>true</code> gesetzt.
* Zum Schluss wird <code>ergebnis</code> zurückgegeben.

==Anzahl aus Geburtsjahr==
Hier wird folgendes algorithmische Verfahren umgesetzt:
* <code>ergebnis</code> wird auf 0 gesetzt.
* die Liste <code>pList</code> komplett durchlaufen.
** Für die jeweils aktuelle Person wird geprüft, ob ihr Geburtsjahr dem Parameter <code>pJahr</code> entspricht. Wenn ja, wird <code>ergebnis</code> um 1 erhöht.
* Nach dem Ende der Schleife wird <code>ergebnis</code> zurückgegeben.

''Hinweis: Hier wird die Liste mit einer for-Schleife durchlaufen. Das ist für die Programmierung viel angenehmer, weil man nicht Gefahr läuft, das <code>next()</code> zu vergessen!

<code>
public int anzahlPersonenAusGeburtsjahr(List<Person> pList, int pJahr){
int ergebnis = 0;
for(pList.toFirst(); pList.hasAccess(); pList.next()){
Person p = pList.getContent();
if(p.getGeburtsjahr() == pJahr){
ergebnis += 1;
}
}
return ergebnis;
}
</code>

==jüngste Person==
Hier wird folgende Strategie verfolgt:
* in <code>ergebnis</code> wird zuerst die erste Person der Liste gespeichert.
* Dann wird die Liste komplett durchlaufen.
** Dabei wird die jeweils die Person, auf die der Zeiger zeigt, mit <code>ergebnis</code> verglichen: Wenn sie jünger ist, dann wird <code>aktuell</code> in <code>ergebnis</code> gespeichert.
* Am Ende wird <code>ergebnis</code> zurückgegeben.

<code>
public Person juengstePerson(List<Person> pList){
Person ergebnis = null;
if(pList.isEmpty()){
return ergebnis;
}
pList.toFirst();
Person ergebnis = pList.getContent();
while(pList.hasAccess()){
Person p = pList.getContent();
if(p.getGeburtsjahr() < ergebnis.getGeburtsjahr()){
ergebnis = p;
}
pList.next();
}
return ergebnis;
}
</code>

= Sortierverfahren =

== Sortieren durch Einfügen ==
siehe [[Insertionsort|Insertionsort]]

== Sortieren durch Auswählen ==
siehe [[Selectionsort|Selectionsort]]

== Bubblesort ==
[[Bubblesort|Bubblesort]] ist mit der neuen List-Implementierung nicht mehr sinnvoll, da es keine Möglichkeit gibt die Methode '''Flip''' sinnvoll zu programieren. 
'''Flip''' soll immer dann zwei Werte vertauschen, wenn der im Alphabet vordere Buchstabe hinten steht bzw. die hintere Zahl größer ist. 
Um die Methode jedoch sinnvoll programieren zu können, wären '''komplizierte''' & '''umständliche''' Programierungen notwendig. 
Desweiteren wäre am Ende das Sortierverfahren zu '''Rechenintensiv'''.

== Mergesort ==
'''nicht relevant fürs Zentralabitur!'''

siehe [[Mergesort|Mergesort]]

==Quicksort==
'''im Zentralabitur nur relevant für den LK!'''

siehe [[Quicksort|Quicksort]]

== istSortiert ==
für eine Liste, die mit Objekten vom Typ String gefüllt ist.
<code>
public boolean istSortiert(List<String> pList)
{
boolean ergebnis = true;
pList.toFirst();
while(pList.hasAccess())
{
String aktuell = pList.getContent();
pList.next();
if(pList.hasAccess() == false)
{
ergebnis = true;
return ergebnis;
}
String naechster = pList.getContent();
if(aktuell.compareTo(naechster)>0)
{
ergebnis = false;
return ergebnis;
}
}
ergebnis = true;
return ergebnis;
}
</code>

Quelltextanalyse Java

2025-09-22T16:42:38Z

Akaibel: /* Klausurlösung */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Abitur]]

'''Ziel''' der Quelltextanalyse ist es, die Funktionsweise einer Methode mithilfe geeigneter Fachbegriffe möglichst kurz und präzise zu beschreiben. Dabei sind Standardformulierungen hilfreich.
* '''Fachbegriffe''' dienen der Präzision.
* '''kurz''' ist deswegen wichtig, weil man bei der Klausur möglichst wenig Zeit auf das Schreiben verwenden sollte.
* Auf '''Standardformulierungen''' sollte man zurückgreifen können - denn die Beschreibung für das Durchlaufen eines Queues oder einer Liste muss man nicht für jede Klausur neu erfinden.
** Beispiele für Standardformulierungen finden sich unten.
* Auf Ästhetik muss '''nicht''' geachtet werden, so sind z.B. Wiederholungen am Satzanfang kein Problem.

=Der Operator ''"Analysieren Sie..."'' im Zentralabitur=
Der Operator ''"Analysieren Sie..."'' kommt im Zentralabitur immer '''nur in Kombination mit einem weiteren Operator''' vor. Der weitere Operator sagt aus, was zu schreiben ist.

Konkret heißt das:
* '''''"Analysieren Sie..."'' heißt so viel wie ''"Denken Sie nach über..."'''''
* Konsequenz: Für den Operator ''"Analysieren Sie..."'' muss man gar nichts aufschreiben!!

Man muss das nicht verstehen. Aber wer das nicht berücksichtigt, verliert im Abitur sehr viel Zeit.

Hinweis: 
Diese Auffassung von ''"Analysieren Sie..."'' ist sehr spezifisch für das Informatik-Zentralabitur! Bitte auf keinen Fall auf andere Fächer übertragen!!

'''Beispiel:'''

Aufgabenstellung: 
''Analysieren und erläutern Sie den Algorithmus im Sachkontext.''

Was ist zu tun?
* ''Analysieren ...'': Einfach nur nachdenken - nichts schreiben!
* ''... und erläutern Sie den Algorithmus im Sachkontext'': Das ist das, was zu tun ist! Weil bei dieser Aufgabe "nur" im Sachkontext erläutert werden soll, braucht man überhaupt nicht auf Programmierungs-Details eingehen, wenn sie für den Sachkontext keine Rolle spielen.

=Standardformulierungen=
Mögliche Standardformulierungen werden hier an einem Beispiel aufgezeigt.

'''Beispiel:'''

Gegeben ist die Methode <code>tueWas</code>. <code>pQueue</code> enthält lauter Kunden, die nach Einkommen absteigend sortiert sind, d.h. der Kunde mit dem höchsten Einkommen ist vorne.

<code>
01 private void tueWas(Queue<Kunde> pQueue, Kunde pKunde) {
Queue<Kunde> hilfs = new Queue<Kunde>();
boolean zzz = false;
while (!pQueue.isEmpty()) {
05 Kunde k = pQueue.front();
if (zzz == false && pKunde.getGuthaben() > k.getGuthaben()) {
hilfs.enqueue(pKunde);
zzz = true;
}
10 hilfs.enqueue(k);
pQueue.dequeue();
}
if(!zzz){
hilfs.enqueue(pKunde);
15 }
while (!hilfs.isEmpty()) {
pQueue.enqueue(hilfs.front());
hilfs.dequeue();
}
20 }
</code>

'''Aufgabe:'''

* Unterteile die Methode in geeignete Abschnitte und erläutere die Funktionsweise der Abschnitte. Verwende dabei geeignete Fachbegriffe.
* Erläutere, welchen Zweck die lokale Variable <code>zzz</code> erfüllt und gib ihr einen geeigneten Namen.
* Benenne den Zweck, den die Methode erfüllt.

==Mögliche Lösung (sehr ausführlich!)==
''Diese Lösung ist sehr ausführlich, um möglichst alle Fachbegriffe unterzubringen. '''Für die Klausur ist das zu ausführlich!! Klausurlösung: siehe nächster Abschnitt!'''''

'''Fachbegriffe''' sind '''fett'''; die Lösung enthält möglichst viele Standardformulierungen.

* Die Methode <code>tueWas</code> erwartet die '''Parameter''' <code>pQueue</code> (vom Typ <code>Queue</code>) und <code>pKunde</code> vom '''Typ''' <code>Kunde</code>. Die Methode gibt nichts zurück.
* Zu Beginn (Z. 2-3) werden die '''lokalen Variablen''' <code>hilfs</code> und <code>zzz</code> '''deklariert'''; <code>hilfs</code> wird als leere Queue '''initialisiert''' und <code>zzz</code> mit dem Wert <code>false</code>.
* In der <code>while</code>-'''Schleife''' (Z.4-12) wird <code>pQueue</code> '''nach und nach geleert''' und hinten an <code>hilfs</code> '''angehängt''' (Z. 4+5+10+11).
** Dabei wird in der '''lokalen Variable''' <code>k</code> der jeweils '''vorderste''' Kunde aus <code>pQueue</code> gespeichert.
** '''Wenn''' <code>zzz</code> noch <code>false</code> ist '''und''' <code>pKunde</code> ein größeres Einkommen hat als der vorderste Kunde <code>k</code>, dann wird <code>pKunde</code> an <code>hilfs</code> '''hinten angehängt''' und <code>zzz</code> auf <code>true</code> gesetzt.
* Z. 13-15: Wenn <code>zzz</code> den Wert <code>false</code> hat, dann wird <code>pKunde</code> jetzt an <code>hilfs</code> '''hinten angehängt'''; das geschieht, wenn <code>pKunde</code> in der <code>while</code>-Schleife noch nicht an <code>hilfs</code> angehängt wurde.
* Z. 16-19: Alle Elemente von <code>hilfs</code> werden wieder auf <code>pQueue</code> zurückübertragen.

In der Variablen <code>zzz</code> wird festgehalten, ob <code>pKunde</code> schon in <code>hilfs</code> eingefügt wurde.

<code>zzz</code> heißt deswegen am besten <code>schonEingefuegt</code>.

Die Methode fügt <code>pKunde</code> gemäß seinem Einkommen an der richtigen Stelle in <code>pQueue</code> ein. 
Wenn <code>pKunde</code> ärmer ist als alle in <code>pQueue</code>, dann wird er hinten angehängt.

==Klausurlösung==
''Diese Lösung würde in der Klausur alle Punkte bringen. ''

* Zu Beginn der Methode tueWas wird <code>hilfs</code> als Queue erzeugt und <code>zzz</code> bekommt den Wert <code>false</code>.
* In der <code>while</code>-'''Schleife''' (Z.4-12) wird <code>pQueue</code> '''nach und nach geleert''' und hinten an <code>hilfs</code> '''angehängt''' (Z. 4+5+10+11).
** Dabei wird immer geprüft, ob <code>zzz</code> noch <code>false</code> ist '''und''' der ob der Parameter <code>pKunde</code> ein größeres Einkommen hat als der vorderste Kunde.
** '''Wenn ja''', dann wird <code>pKunde</code> an <code>hilfs</code> '''hinten angehängt''' und <code>zzz</code> auf <code>true</code> gesetzt.
* Nach dem Ende der Schleife wird geschaut, ob <code>zzz</code> den Wert <code>false</code> hat
** Wenn ja, dann wird <code>pKunde</code> jetzt an <code>hilfs</code> '''hinten angehängt'''.
** Damit ist man sicher, dass <code>pKunde</code> genau einmal an <code>hilfs</code> angehängt wird.
* Am Ende werden alle Kunden von <code>hilfs</code> werden wieder auf <code>pQueue</code> zurückübertragen.

<code>zzz</code> heißt am besten <code>schonEingefuegt</code>. ''(Und damit ist klar, was der Zweck der Variable ist.)''

Die Methode fügt <code>pKunde</code> gemäß seinem Einkommen an der richtigen Stelle in <code>pQueue</code> ein, ggf. auch an der letzten Stelle.

Quelltextanalyse Java

2025-09-22T16:41:52Z

Akaibel: /* Klausurlösung */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Abitur]]

'''Ziel''' der Quelltextanalyse ist es, die Funktionsweise einer Methode mithilfe geeigneter Fachbegriffe möglichst kurz und präzise zu beschreiben. Dabei sind Standardformulierungen hilfreich.
* '''Fachbegriffe''' dienen der Präzision.
* '''kurz''' ist deswegen wichtig, weil man bei der Klausur möglichst wenig Zeit auf das Schreiben verwenden sollte.
* Auf '''Standardformulierungen''' sollte man zurückgreifen können - denn die Beschreibung für das Durchlaufen eines Queues oder einer Liste muss man nicht für jede Klausur neu erfinden.
** Beispiele für Standardformulierungen finden sich unten.
* Auf Ästhetik muss '''nicht''' geachtet werden, so sind z.B. Wiederholungen am Satzanfang kein Problem.

=Der Operator ''"Analysieren Sie..."'' im Zentralabitur=
Der Operator ''"Analysieren Sie..."'' kommt im Zentralabitur immer '''nur in Kombination mit einem weiteren Operator''' vor. Der weitere Operator sagt aus, was zu schreiben ist.

Konkret heißt das:
* '''''"Analysieren Sie..."'' heißt so viel wie ''"Denken Sie nach über..."'''''
* Konsequenz: Für den Operator ''"Analysieren Sie..."'' muss man gar nichts aufschreiben!!

Man muss das nicht verstehen. Aber wer das nicht berücksichtigt, verliert im Abitur sehr viel Zeit.

Hinweis: 
Diese Auffassung von ''"Analysieren Sie..."'' ist sehr spezifisch für das Informatik-Zentralabitur! Bitte auf keinen Fall auf andere Fächer übertragen!!

'''Beispiel:'''

Aufgabenstellung: 
''Analysieren und erläutern Sie den Algorithmus im Sachkontext.''

Was ist zu tun?
* ''Analysieren ...'': Einfach nur nachdenken - nichts schreiben!
* ''... und erläutern Sie den Algorithmus im Sachkontext'': Das ist das, was zu tun ist! Weil bei dieser Aufgabe "nur" im Sachkontext erläutert werden soll, braucht man überhaupt nicht auf Programmierungs-Details eingehen, wenn sie für den Sachkontext keine Rolle spielen.

=Standardformulierungen=
Mögliche Standardformulierungen werden hier an einem Beispiel aufgezeigt.

'''Beispiel:'''

Gegeben ist die Methode <code>tueWas</code>. <code>pQueue</code> enthält lauter Kunden, die nach Einkommen absteigend sortiert sind, d.h. der Kunde mit dem höchsten Einkommen ist vorne.

<code>
01 private void tueWas(Queue<Kunde> pQueue, Kunde pKunde) {
Queue<Kunde> hilfs = new Queue<Kunde>();
boolean zzz = false;
while (!pQueue.isEmpty()) {
05 Kunde k = pQueue.front();
if (zzz == false && pKunde.getGuthaben() > k.getGuthaben()) {
hilfs.enqueue(pKunde);
zzz = true;
}
10 hilfs.enqueue(k);
pQueue.dequeue();
}
if(!zzz){
hilfs.enqueue(pKunde);
15 }
while (!hilfs.isEmpty()) {
pQueue.enqueue(hilfs.front());
hilfs.dequeue();
}
20 }
</code>

'''Aufgabe:'''

* Unterteile die Methode in geeignete Abschnitte und erläutere die Funktionsweise der Abschnitte. Verwende dabei geeignete Fachbegriffe.
* Erläutere, welchen Zweck die lokale Variable <code>zzz</code> erfüllt und gib ihr einen geeigneten Namen.
* Benenne den Zweck, den die Methode erfüllt.

==Mögliche Lösung (sehr ausführlich!)==
''Diese Lösung ist sehr ausführlich, um möglichst alle Fachbegriffe unterzubringen. '''Für die Klausur ist das zu ausführlich!! Klausurlösung: siehe nächster Abschnitt!'''''

'''Fachbegriffe''' sind '''fett'''; die Lösung enthält möglichst viele Standardformulierungen.

* Die Methode <code>tueWas</code> erwartet die '''Parameter''' <code>pQueue</code> (vom Typ <code>Queue</code>) und <code>pKunde</code> vom '''Typ''' <code>Kunde</code>. Die Methode gibt nichts zurück.
* Zu Beginn (Z. 2-3) werden die '''lokalen Variablen''' <code>hilfs</code> und <code>zzz</code> '''deklariert'''; <code>hilfs</code> wird als leere Queue '''initialisiert''' und <code>zzz</code> mit dem Wert <code>false</code>.
* In der <code>while</code>-'''Schleife''' (Z.4-12) wird <code>pQueue</code> '''nach und nach geleert''' und hinten an <code>hilfs</code> '''angehängt''' (Z. 4+5+10+11).
** Dabei wird in der '''lokalen Variable''' <code>k</code> der jeweils '''vorderste''' Kunde aus <code>pQueue</code> gespeichert.
** '''Wenn''' <code>zzz</code> noch <code>false</code> ist '''und''' <code>pKunde</code> ein größeres Einkommen hat als der vorderste Kunde <code>k</code>, dann wird <code>pKunde</code> an <code>hilfs</code> '''hinten angehängt''' und <code>zzz</code> auf <code>true</code> gesetzt.
* Z. 13-15: Wenn <code>zzz</code> den Wert <code>false</code> hat, dann wird <code>pKunde</code> jetzt an <code>hilfs</code> '''hinten angehängt'''; das geschieht, wenn <code>pKunde</code> in der <code>while</code>-Schleife noch nicht an <code>hilfs</code> angehängt wurde.
* Z. 16-19: Alle Elemente von <code>hilfs</code> werden wieder auf <code>pQueue</code> zurückübertragen.

In der Variablen <code>zzz</code> wird festgehalten, ob <code>pKunde</code> schon in <code>hilfs</code> eingefügt wurde.

<code>zzz</code> heißt deswegen am besten <code>schonEingefuegt</code>.

Die Methode fügt <code>pKunde</code> gemäß seinem Einkommen an der richtigen Stelle in <code>pQueue</code> ein. 
Wenn <code>pKunde</code> ärmer ist als alle in <code>pQueue</code>, dann wird er hinten angehängt.

==Klausurlösung==
''Diese Lösung würde in der Klausur alle Punkte bringen. ''

* Zu Beginn der Methode tueWas wird <code>hilfs</code> als Queue erzeugt und <code>zzz</code> bekommt den Wert <code>false</code>.
* In der <code>while</code>-'''Schleife''' (Z.4-12) wird <code>pQueue</code> '''nach und nach geleert''' und hinten an <code>hilfs</code> '''angehängt''' (Z. 4+5+10+11).
** Dabei wird immer geprüft, ob <code>zzz</code> noch <code>false</code> ist '''und''' der ob der Parameter <code>pKunde</code> ein größeres Einkommen hat als der vorderste Kunde.
** '''Wenn ja''', dann wird <code>pKunde</code> an <code>hilfs</code> '''hinten angehängt''' und <code>zzz</code> auf <code>true</code> gesetzt.
* Nach dem Ende der Schleife wird geschaut, ob <code>zzz</code> den Wert <code>false</code> hat
** Wenn ja, dann wird <code>pKunde</code> jetzt an <code>hilfs</code> '''hinten angehängt'''; das geschieht.
** Damit ist man sicher, dass <code>pKunde</code> genau einmal an <code>hilfs</code> angehängt wird.
* Am Ende werden alle Kunden von <code>hilfs</code> werden wieder auf <code>pQueue</code> zurückübertragen.

<code>zzz</code> heißt am besten <code>schonEingefuegt</code>. ''(Und damit ist klar, was der Zweck der Variable ist.)''

Die Methode fügt <code>pKunde</code> gemäß seinem Einkommen an der richtigen Stelle in <code>pQueue</code> ein, ggf. auch an der letzten Stelle.

Quelltextanalyse Java

2025-09-22T16:41:02Z

Akaibel: /* Mögliche Lösung */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Abitur]]

'''Ziel''' der Quelltextanalyse ist es, die Funktionsweise einer Methode mithilfe geeigneter Fachbegriffe möglichst kurz und präzise zu beschreiben. Dabei sind Standardformulierungen hilfreich.
* '''Fachbegriffe''' dienen der Präzision.
* '''kurz''' ist deswegen wichtig, weil man bei der Klausur möglichst wenig Zeit auf das Schreiben verwenden sollte.
* Auf '''Standardformulierungen''' sollte man zurückgreifen können - denn die Beschreibung für das Durchlaufen eines Queues oder einer Liste muss man nicht für jede Klausur neu erfinden.
** Beispiele für Standardformulierungen finden sich unten.
* Auf Ästhetik muss '''nicht''' geachtet werden, so sind z.B. Wiederholungen am Satzanfang kein Problem.

=Der Operator ''"Analysieren Sie..."'' im Zentralabitur=
Der Operator ''"Analysieren Sie..."'' kommt im Zentralabitur immer '''nur in Kombination mit einem weiteren Operator''' vor. Der weitere Operator sagt aus, was zu schreiben ist.

Konkret heißt das:
* '''''"Analysieren Sie..."'' heißt so viel wie ''"Denken Sie nach über..."'''''
* Konsequenz: Für den Operator ''"Analysieren Sie..."'' muss man gar nichts aufschreiben!!

Man muss das nicht verstehen. Aber wer das nicht berücksichtigt, verliert im Abitur sehr viel Zeit.

Hinweis: 
Diese Auffassung von ''"Analysieren Sie..."'' ist sehr spezifisch für das Informatik-Zentralabitur! Bitte auf keinen Fall auf andere Fächer übertragen!!

'''Beispiel:'''

Aufgabenstellung: 
''Analysieren und erläutern Sie den Algorithmus im Sachkontext.''

Was ist zu tun?
* ''Analysieren ...'': Einfach nur nachdenken - nichts schreiben!
* ''... und erläutern Sie den Algorithmus im Sachkontext'': Das ist das, was zu tun ist! Weil bei dieser Aufgabe "nur" im Sachkontext erläutert werden soll, braucht man überhaupt nicht auf Programmierungs-Details eingehen, wenn sie für den Sachkontext keine Rolle spielen.

=Standardformulierungen=
Mögliche Standardformulierungen werden hier an einem Beispiel aufgezeigt.

'''Beispiel:'''

Gegeben ist die Methode <code>tueWas</code>. <code>pQueue</code> enthält lauter Kunden, die nach Einkommen absteigend sortiert sind, d.h. der Kunde mit dem höchsten Einkommen ist vorne.

<code>
01 private void tueWas(Queue<Kunde> pQueue, Kunde pKunde) {
Queue<Kunde> hilfs = new Queue<Kunde>();
boolean zzz = false;
while (!pQueue.isEmpty()) {
05 Kunde k = pQueue.front();
if (zzz == false && pKunde.getGuthaben() > k.getGuthaben()) {
hilfs.enqueue(pKunde);
zzz = true;
}
10 hilfs.enqueue(k);
pQueue.dequeue();
}
if(!zzz){
hilfs.enqueue(pKunde);
15 }
while (!hilfs.isEmpty()) {
pQueue.enqueue(hilfs.front());
hilfs.dequeue();
}
20 }
</code>

'''Aufgabe:'''

* Unterteile die Methode in geeignete Abschnitte und erläutere die Funktionsweise der Abschnitte. Verwende dabei geeignete Fachbegriffe.
* Erläutere, welchen Zweck die lokale Variable <code>zzz</code> erfüllt und gib ihr einen geeigneten Namen.
* Benenne den Zweck, den die Methode erfüllt.

==Mögliche Lösung (sehr ausführlich!)==
''Diese Lösung ist sehr ausführlich, um möglichst alle Fachbegriffe unterzubringen. '''Für die Klausur ist das zu ausführlich!! Klausurlösung: siehe nächster Abschnitt!'''''

'''Fachbegriffe''' sind '''fett'''; die Lösung enthält möglichst viele Standardformulierungen.

* Die Methode <code>tueWas</code> erwartet die '''Parameter''' <code>pQueue</code> (vom Typ <code>Queue</code>) und <code>pKunde</code> vom '''Typ''' <code>Kunde</code>. Die Methode gibt nichts zurück.
* Zu Beginn (Z. 2-3) werden die '''lokalen Variablen''' <code>hilfs</code> und <code>zzz</code> '''deklariert'''; <code>hilfs</code> wird als leere Queue '''initialisiert''' und <code>zzz</code> mit dem Wert <code>false</code>.
* In der <code>while</code>-'''Schleife''' (Z.4-12) wird <code>pQueue</code> '''nach und nach geleert''' und hinten an <code>hilfs</code> '''angehängt''' (Z. 4+5+10+11).
** Dabei wird in der '''lokalen Variable''' <code>k</code> der jeweils '''vorderste''' Kunde aus <code>pQueue</code> gespeichert.
** '''Wenn''' <code>zzz</code> noch <code>false</code> ist '''und''' <code>pKunde</code> ein größeres Einkommen hat als der vorderste Kunde <code>k</code>, dann wird <code>pKunde</code> an <code>hilfs</code> '''hinten angehängt''' und <code>zzz</code> auf <code>true</code> gesetzt.
* Z. 13-15: Wenn <code>zzz</code> den Wert <code>false</code> hat, dann wird <code>pKunde</code> jetzt an <code>hilfs</code> '''hinten angehängt'''; das geschieht, wenn <code>pKunde</code> in der <code>while</code>-Schleife noch nicht an <code>hilfs</code> angehängt wurde.
* Z. 16-19: Alle Elemente von <code>hilfs</code> werden wieder auf <code>pQueue</code> zurückübertragen.

In der Variablen <code>zzz</code> wird festgehalten, ob <code>pKunde</code> schon in <code>hilfs</code> eingefügt wurde.

<code>zzz</code> heißt deswegen am besten <code>schonEingefuegt</code>.

Die Methode fügt <code>pKunde</code> gemäß seinem Einkommen an der richtigen Stelle in <code>pQueue</code> ein. 
Wenn <code>pKunde</code> ärmer ist als alle in <code>pQueue</code>, dann wird er hinten angehängt.

==Klausurlösung==
''Diese Lösung würde in der Klausur alle Punkte bringen. ''

* Zu Beginn der Methode tueWas wird die '''lokalen Variablen''' <code>hilfs</code> als Queue erzeugt und <code>zzz</code> bekommt den Wert <code>false</code>.
* In der <code>while</code>-'''Schleife''' (Z.4-12) wird <code>pQueue</code> '''nach und nach geleert''' und hinten an <code>hilfs</code> '''angehängt''' (Z. 4+5+10+11).
** Dabei wird immer geprüft, ob <code>zzz</code> noch <code>false</code> ist '''und''' der ob der Parameter <code>pKunde</code> ein größeres Einkommen hat als der vorderste Kunde.
** '''Wenn ja''', dann wird <code>pKunde</code> an <code>hilfs</code> '''hinten angehängt''' und <code>zzz</code> auf <code>true</code> gesetzt.
* Nach dem Ende der Schleife wird geschaut, ob <code>zzz</code> den Wert <code>false</code> hat
** Wenn ja, dann wird <code>pKunde</code> jetzt an <code>hilfs</code> '''hinten angehängt'''; das geschieht.
** Damit ist man sicher, dass <code>pKunde</code> genau einmal an <code>hilfs</code> angehängt wird.
* Am Ende werden alle Kunden von <code>hilfs</code> werden wieder auf <code>pQueue</code> zurückübertragen.

<code>zzz</code> heißt am besten <code>schonEingefuegt</code>. ''(Und damit ist klar, was der Zweck der Variable ist.)''

Die Methode fügt <code>pKunde</code> gemäß seinem Einkommen an der richtigen Stelle in <code>pQueue</code> ein, ggf. auch an der letzten Stelle.

Eclipse Tricks

2025-08-30T07:44:22Z

Akaibel: /* Shortcuts und Tricks */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
* Allgemeine Infos zu Eclipse: [[Eclipse]]
* Tricks für die Java-Entwicklung: [[Java Tricks]]

=Shortcuts und Tricks=
Da Eclipse das Tool schlechthin im Informatik-Unterricht der Q1 und Q2 ist, werden hier einige hilfreiche Shortcuts und Tricks aufgeführt. 
Die Tipps sind hier '''alphabetisch''' aufgeführt. 
Ggf. tauchen sie hier auch mehrfach (unter verschiedenen Titeln) auf.

* '''Ansicht wiederherstellen:''': Window -> perspective -> reset perspective
* '''Breakpoint für Debugging setzen''': Doppelklick ''links'' neben einer Zeilennummer.
* '''Correct Indentation''' (Einrückungen korrigieren): STRG+a und dann STRG+i (indentation)
* '''Debugging-Ansicht:''' Debug (rechts oben)
* '''Debugging starten:''' Den Käfer anklicken.
* '''Einrückungen korrigieren''' (correct indentation): STRG+a und dann STRG+i (indentation)
* '''ersetzen (Textfragment)''': STRG+f (find)
* '''for-Schleife erzeugen''': for STRG+Leertaste
* '''get-Methoden und set-Methoden erzeugen''': rechte Maustaste -> source -> generate getters and setters
* '''Java-Entwicklungs-Ansicht''': Java (rechts oben)
* '''Klasse in ein Projekt einfügen:''' Aus dem Windows-Explorer mit Drag&Drop an die richtige Stelle im Package-Explorer (links) ziehen.
* '''Klasse neu erzeugen:''' File -> New -> Class ''(oder direkt den "C"-Button anklicken)''
* '''Konstruktor erzeugen''': rechte Maustaste -> source -> generate constructor using fields
* '''main-Methode erzeugen''': main STRG+Leertaste
* '''neue Klasse erzeugen:''' File -> New -> Class ''(oder direkt den "C"-Button anklicken)''
* '''rename (Klasse, Attribut oder Methode)''': SHIFT+ALT+R (rename). Damit wird die Klasse (Attribut, Methode) überall umbenannt!
* '''suchen (Textfragment)''': STRG+f (find)
* '''toString()-Methode erzeugen''': rechte Maustaste -> source -> generate toString()
* '''umbenennen (Klasse, Attribut oder Methode)''': SHIFT+ALT+R (rename). Damit wird die Klasse (Attribut, Methode) überall umbenannt!

Eclipse Tricks

2025-08-30T07:43:58Z

Akaibel: /* Shortcuts und Tricks */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
* Allgemeine Infos zu Eclipse: [[Eclipse]]
* Tricks für die Java-Entwicklung: [[Java Tricks]]

=Shortcuts und Tricks=
Da Eclipse das Tool schlechthin im Informatik-Unterricht der Q1 und Q2 ist, werden hier einige hilfreiche Shortcuts und Tricks aufgeführt. 
Die Tipps sind hier '''alphabetisch''' aufgeführt. 
Ggf. tauchen sie hier auch mehrfach (unter verschiedenen Titeln) auf.

* '''Ansicht wiederherstellen:''': Window -> reset perspective
* '''Breakpoint für Debugging setzen''': Doppelklick ''links'' neben einer Zeilennummer.
* '''Correct Indentation''' (Einrückungen korrigieren): STRG+a und dann STRG+i (indentation)
* '''Debugging-Ansicht:''' Debug (rechts oben)
* '''Debugging starten:''' Den Käfer anklicken.
* '''Einrückungen korrigieren''' (correct indentation): STRG+a und dann STRG+i (indentation)
* '''ersetzen (Textfragment)''': STRG+f (find)
* '''for-Schleife erzeugen''': for STRG+Leertaste
* '''get-Methoden und set-Methoden erzeugen''': rechte Maustaste -> source -> generate getters and setters
* '''Java-Entwicklungs-Ansicht''': Java (rechts oben)
* '''Klasse in ein Projekt einfügen:''' Aus dem Windows-Explorer mit Drag&Drop an die richtige Stelle im Package-Explorer (links) ziehen.
* '''Klasse neu erzeugen:''' File -> New -> Class ''(oder direkt den "C"-Button anklicken)''
* '''Konstruktor erzeugen''': rechte Maustaste -> source -> generate constructor using fields
* '''main-Methode erzeugen''': main STRG+Leertaste
* '''neue Klasse erzeugen:''' File -> New -> Class ''(oder direkt den "C"-Button anklicken)''
* '''rename (Klasse, Attribut oder Methode)''': SHIFT+ALT+R (rename). Damit wird die Klasse (Attribut, Methode) überall umbenannt!
* '''suchen (Textfragment)''': STRG+f (find)
* '''toString()-Methode erzeugen''': rechte Maustaste -> source -> generate toString()
* '''umbenennen (Klasse, Attribut oder Methode)''': SHIFT+ALT+R (rename). Damit wird die Klasse (Attribut, Methode) überall umbenannt!

Projekt javaEF

2025-08-27T17:20:54Z

Akaibel: /* Eclipse: */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-EF]]

=Grundlegendes=
''Das Projekt javaEF ist relativ neu und deswegen vielleicht noch nicht absolut fehlerfrei.'' 
''Aber in der Praxis im Schuljahr 2024/25 hat es sich schon als großer Fortschritt erwiesen!!''

Das Projekt ist unter der '''Open-Source Lizenz GPL v3.0''' veröffentlicht.

==Vorteile==
* Man kann mit einer '''echten Entwicklungsumgebung''' (VS Code, Eclipse, IntelliJ) programmieren und ist nicht auf BlueJ und Greenfoot angewiesen. Das heißt:
** viel bessere Tooltips
** besseres Debugging
** besseres Code-Highlighting
** ... und was echte Entwicklungsumgebungen sonst noch alles können!
* Man hat '''alles in einem Projekt''' und muss nicht dauernd irgendwelche neuen Dateien runterladen etc.
''(Wer unbedingt BlueJ nutzen will, kann das auch machen. Aber empfehlen tun wir's nicht gerade.)''

=Was man mit JavaEF machen kann=
* prozedurale Programmierung
** mit Kara (auf Deutsch)
** mit Kara (auf Englisch)
** mit dem Rover (auf Deutsch)
* objektorientierte Programmierung...
** mit dem Projekt Formen (wie aus "Objects First")
* Programmierung von Arrays

Das Ziel ist es, dass man mit dem Projekt für die EF softwaremäßig ausgesorgt hat! ''(Dieses Ziel ist noch nicht erreicht, aber wir nähern uns dem an...)''

=Stand des Projektes:=

* Letztes Update: 24.04.2025

''Der aktuellste Stand des Projektes findet sich immer auf GitHub. (siehe weiter unten).''

=Voraussetzungen=

Man kann das Projekt mit jeder Entwicklungsumgebung bearbeiten. Unsere Empfehlung für die Installation zuhause ist Visual Studio Code, weil es einfach zu installieren und einfach zu bedienen ist - und problemlos auch für andere Programmiersprachen genutzt werden kann (mit sogenannten Extensions).

==Visual Studio Code==
''Man kann sich von ChatGPT durch die Installation von Visual Studio Code führen lassen. Wichtige Stichworte: Visual Studio Code Java installieren und GIT installieren. Ansonsten ist hier eine Anleitung:'' 

'''Installation''':
* [https://www.youtube.com/watch?v=RkU3ape9e24 Erklärvideo zur Installation von VS Code und Java (2:30min)]
* [https://devblogs.microsoft.com/java/announcing-visual-studio-code-java-installer/ Link zum Artikel (aus dem Video)]
* [https://aka.ms/vscode-java-installer-win direkter Link zum Installer]
* Wenn die Installation von VS-Code fehlschlägt:
** [https://code.visualstudio.com/Download Download von VS-Code]
** Dann muss man links das Symbol für "Extensions" anklicken, "Extension Pack für Java" auswählen und das installieren.

== Eclipse==
Eclipse ist die Entwicklungsumgebung im Unterricht am SIBI. 
Wer Eclipse installieren will, erfährt hier, wie es geht: '''[[Eclipse|Eclipse]]'''.

==BlueJ==

Man kann das Projekt auch mit '''BlueJ''' öffnen. 
Richtig zu empfehlen ist das nicht, denn BlueJ ist eine "Spielzeug"-Entwicklungsumgebung, die z.B. Visual Studio Code oder Eclipse (oder IntelliJ) weit unterlegen ist. 
BlueJ sollte man nur nehmen, wenn man es sowieso schon auf dem Rechner hat und überhaupt keine Lust hat sich mit einer vernünftigen Entwicklungsumgebung auseinanderzusetzen.

'''WICHTIG: ''' Wenn man das Projekt mit BlueJ öffnet, dann muss man alle Klassen über die main-Methode starten:

* rechte Maustaste auf die Klasse -> main auswählen.

=Von GitHub beziehen=
Man kann das Projekt javaEF auch von GitHub beziehen. Dort findet sich die aktuelleste Version des Projektes:

'''[https://github.com/akaibel/sibikara https://github.com/akaibel/javaEF]'''

==Visual Studio Code==
* ChatGPT befragen mit folgendem Prompt:
* <code>vs code runterladen https://github.com/akaibel/javaEF</code>

==Eclipse==
# Die Github-URL (siehe oben) in die Zwischenablage kopieren.
# Eclipse: File -> Import –> Git -> Projects from Git
# Clone URI anklicken und Next.
# URI eintragen. Der Rest erscheint automatisch. Next klicken.
# In "local destination" das Verzeichnis wählen, wo das Projekt hin soll.

==IntelliJ==
# File -> New -> Project from Version Control
# https://github.com/akaibel/javaEF

=Download und Öffnen in Eclipse=
'''''Dieser Weg ist viel komplizierter als das direkte Runterladen von GitHub (siehe oben).'''''

'''Runterladen und entpacken:'''
* '''[https://sibiwiki.de/wiki-files/javaEF.zip https://sibiwiki.de/wiki-files/javaEF.zip]''' runterladen
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")

'''In Eclipse...'''

*File -> New -> Java Project
*Haken weg bei "Use Default Location"
*"Browse" klicken und den Ordner "javaEF" suchen.
**Evtl. liegt dieser Ordner in einem übergeordneten Ordner "javaEF". Dann den "inneren" der beiden Ordner wählen.
*"Finish" klicken

=Download und Öffnen in BlueJ=
* '''[https://sibiwiki.de/wiki-files/javaEF.zip https://sibiwiki.de/wiki-files/javaEF.zip]''' runterladen
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")
* In BlueJ:
** Project -> Open Non BlueJ bzw. Projekt -> Fremdprojekt öffnen
** Den Ordner "javaEF" suchen.
*** Evtl. liegt dieser Ordner im Ordner "javaEF".

Projekt java Q1Q2

2025-08-27T17:20:23Z

Akaibel: /* Eclipse */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Q2]]

Das Projekt java_Q1Q2 umfasst ALLE Szenarien, mit denen am SIBI in der Q1 und Q2 Java entwickelt wird.

'''D.h. wer sich das einmal runterlädt, hat softwaremäßig für die Q1 und Q2 ausgesorgt!!!'''

Das Projekt ist unter der '''Open-Source Lizenz GPL v3.0''' veröffentlicht.

=Stand des Projektes:=

* Das Projekt bildet die Schnittstellen des Abi 2018 (und folgende) ab.

* Letztes Update: 24.04.2025

''Der aktuellste Stand des Projektes findet sich immer auf GitHub. (siehe weiter unten).''

=Voraussetzungen=

Man kann das Projekt mit jeder Entwicklungsumgebung bearbeiten. Unsere Empfehlung für die Installation zuhause ist Visual Studio Code, weil es einfach zu installieren und einfach zu bedienen ist - und problemlos auch für andere Programmiersprachen genutzt werden kann (mit sogenannten Extensions).

==Visual Studio Code==
''Man kann sich von ChatGPT durch die Installation von Visual Studio Code führen lassen. Wichtige Stichworte: Visual Studio Code Java installieren und GIT installieren. Ansonsten ist hier eine Anleitung:'' 

'''Installation''':
* [https://www.youtube.com/watch?v=RkU3ape9e24 Erklärvideo zur Installation von VS Code und Java (2:30min)]
* [https://devblogs.microsoft.com/java/announcing-visual-studio-code-java-installer/ Link zum Artikel (aus dem Video)]
* [https://aka.ms/vscode-java-installer-win direkter Link zum Installer]
* Wenn die Installation von VS-Code fehlschlägt:
** [https://code.visualstudio.com/Download Download von VS-Code]
** Dann muss man links das Symbol für "Extensions" anklicken, "Extension Pack für Java" auswählen und das installieren.

== Eclipse==

Um das Projekt öffnen zu können, muss man '''[[Eclipse]]''' installiert haben. Wie man das tut, erfährt man hier: '''[[Eclipse|Eclipse]]'''.

==BlueJ==

Man kann das Projekt auch mit '''BlueJ''' öffnen. 
Richtig zu empfehlen ist das nicht, denn BlueJ ist eine "Spielzeug"-Entwicklungsumgebung, die z.B. Visual Studio Code oder Eclipse (oder IntelliJ) weit unterlegen ist. 
BlueJ sollte man nur nehmen, wenn man es sowieso schon auf dem Rechner hat und überhaupt keine Lust hat sich mit einer vernünftigen Entwicklungsumgeung auseinanderzusetzen.

'''WICHTIG: ''' Wenn man das Projekt mit BlueJ öffnet, dann muss man alle Klassen über die main-Methode starten:

* rechte Maustaste auf die Klasse -> main auswählen.

=Von GitHub beziehen=
Man kann das Projekt javaQ1Q2 auch von GitHub beziehen. Dort findet sich die aktuelleste Version des Projektes:

'''[https://github.com/akaibel/javaQ1Q2 https://github.com/akaibel/javaQ1Q2]'''

==Visual Studio Code==
* ChatGPT befragen mit folgendem Prompt:
* <code>vs code runterladen https://github.com/akaibel/javaQ1Q2</code>

==Eclipse==
# Die Github-URL (siehe oben) in die Zwischenablage kopieren.
# Eclipse: File -> Import –> Git -> Projects from Git
# Clone URI anklicken und Next.
# URI eintragen. Der Rest erscheint automatisch. Next klicken.
# In "local destination" das Verzeichnis wählen, wo das Projekt hin soll.

=Download und Öffnen in Eclipse=
'''''Dieser Weg ist viel komplizierter als das direkte Runterladen von GitHub (siehe oben).'''''

'''Runterladen und entpacken:'''
* '''[https://sibiwiki.de/wiki-files/javaQ1Q2.zip https://sibiwiki.de/wiki-files/javaQ1Q2.zip]''' runterladen
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")

'''In Eclipse...'''

*File -> New -> Java Project
*Haken weg bei "Use Default Location"
*"Browse" klicken und den Ordner "javaQ1Q2" suchen.
**Evtl. liegt dieser Ordner in einem übergeordneten Ordner "javaQ1Q2". Dann den "inneren" der beiden Ordner wählen.
*"Finish" klicken

'''Die notwendigen Bibliotheken einbauen:'''

* in Eclipse sollten die Bibliotheken eingebaut sein.
** wenn nicht: __readme/notwendige_libraries.odt ''(im Ordner javaQ1Q2)''
* andere IDEs:
** __readme/notwendige_libraries.odt ''(im Ordner javaQ1Q2)'' zeigt, welche Libraries eingebaut werden müssen.

=Download und Öffnen in BlueJ=
* '''[https://sibiwiki.de/wiki-files/javaQ1Q2.zip https://sibiwiki.de/wiki-files/javaQ1Q2.zip]''' runterladen
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")
* In BlueJ:
** Project -> Open Non BlueJ bzw. Projekt -> Fremdprojekt öffnen
** Den Ordner "javaQ1Q2" suchen.
*** Evtl. enthält dieser einen inneren Ordner "javaQ1Q2"! Dann diesen nehmen.
* '''Jetzt noch die notwendigen Libraries hinzufügen:'''
** Tools -> Preferences -> Libraries -> Add bzw. Werkzeuge -> Einstellungen -> Bibliotheken -> Hinzufügen
** Den Ordner "libraries" suchen.
** In diesem Ordner jede jar-Datei einzeln durch Anklicken hinzufügen (=etwas mühsam...)
* Abschließend mit STRG+UMSCHALT+R die Virtuelle Maschine neu starten.
* Testen: Im Package _test die Klasse Graphtest: rechte Maustaste -> main ausführen.

Projekt java Q1Q2

2025-08-27T17:15:42Z

Akaibel: /* Eclipse: */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Q2]]

Das Projekt java_Q1Q2 umfasst ALLE Szenarien, mit denen am SIBI in der Q1 und Q2 Java entwickelt wird.

'''D.h. wer sich das einmal runterlädt, hat softwaremäßig für die Q1 und Q2 ausgesorgt!!!'''

Das Projekt ist unter der '''Open-Source Lizenz GPL v3.0''' veröffentlicht.

=Stand des Projektes:=

* Das Projekt bildet die Schnittstellen des Abi 2018 (und folgende) ab.

* Letztes Update: 24.04.2025

''Der aktuellste Stand des Projektes findet sich immer auf GitHub. (siehe weiter unten).''

=Voraussetzungen=

Man kann das Projekt mit jeder Entwicklungsumgebung bearbeiten. Unsere Empfehlung für die Installation zuhause ist Visual Studio Code, weil es einfach zu installieren und einfach zu bedienen ist - und problemlos auch für andere Programmiersprachen genutzt werden kann (mit sogenannten Extensions).

==Visual Studio Code==
''Man kann sich von ChatGPT durch die Installation von Visual Studio Code führen lassen. Wichtige Stichworte: Visual Studio Code Java installieren und GIT installieren. Ansonsten ist hier eine Anleitung:'' 

'''Installation''':
* [https://www.youtube.com/watch?v=RkU3ape9e24 Erklärvideo zur Installation von VS Code und Java (2:30min)]
* [https://devblogs.microsoft.com/java/announcing-visual-studio-code-java-installer/ Link zum Artikel (aus dem Video)]
* [https://aka.ms/vscode-java-installer-win direkter Link zum Installer]
* Wenn die Installation von VS-Code fehlschlägt:
** [https://code.visualstudio.com/Download Download von VS-Code]
** Dann muss man links das Symbol für "Extensions" anklicken, "Extension Pack für Java" auswählen und das installieren.

== Eclipse==

Um das Projekt öffnen zu können, muss man '''[[Eclipse]]''' installiert haben. Wie man das tut, erfährt man hier: '''[[Eclipse|Eclipse]]'''.

==BlueJ==

Man kann das Projekt auch mit '''BlueJ''' öffnen. 
Richtig zu empfehlen ist das nicht, denn BlueJ ist eine "Spielzeug"-Entwicklungsumgebung, die z.B. Visual Studio Code oder Eclipse (oder IntelliJ) weit unterlegen ist. 
BlueJ sollte man nur nehmen, wenn man es sowieso schon auf dem Rechner hat und überhaupt keine Lust hat sich mit einer vernünftigen Entwicklungsumgeung auseinanderzusetzen.

'''WICHTIG: ''' Wenn man das Projekt mit BlueJ öffnet, dann muss man alle Klassen über die main-Methode starten:

* rechte Maustaste auf die Klasse -> main auswählen.

=Von GitHub beziehen=
Man kann das Projekt javaQ1Q2 auch von GitHub beziehen. Dort findet sich die aktuelleste Version des Projektes:

'''[https://github.com/akaibel/javaQ1Q2 https://github.com/akaibel/javaQ1Q2]'''

==Visual Studio Code==
* ChatGPT befragen mit folgendem Prompt:
* <code>vs code runterladen https://github.com/akaibel/javaQ1Q2</code>

==Eclipse==
# Copy the GitHub URL of the repository to the clipboard.
# Open Eclipse and choose File -> Import –> Git -> Projects from Git
# Choose the Clone URI option in the Git import wizard and click Next.
# Confirm the URI, Host and Repository path parameters and click Next.
# In "local destination" choose the directory, where the project should go to.

=Download und Öffnen in Eclipse=
'''''Dieser Weg ist viel komplizierter als das direkte Runterladen von GitHub (siehe oben).'''''

'''Runterladen und entpacken:'''
* '''[https://sibiwiki.de/wiki-files/javaQ1Q2.zip https://sibiwiki.de/wiki-files/javaQ1Q2.zip]''' runterladen
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")

'''In Eclipse...'''

*File -> New -> Java Project
*Haken weg bei "Use Default Location"
*"Browse" klicken und den Ordner "javaQ1Q2" suchen.
**Evtl. liegt dieser Ordner in einem übergeordneten Ordner "javaQ1Q2". Dann den "inneren" der beiden Ordner wählen.
*"Finish" klicken

'''Die notwendigen Bibliotheken einbauen:'''

* in Eclipse sollten die Bibliotheken eingebaut sein.
** wenn nicht: __readme/notwendige_libraries.odt ''(im Ordner javaQ1Q2)''
* andere IDEs:
** __readme/notwendige_libraries.odt ''(im Ordner javaQ1Q2)'' zeigt, welche Libraries eingebaut werden müssen.

=Download und Öffnen in BlueJ=
* '''[https://sibiwiki.de/wiki-files/javaQ1Q2.zip https://sibiwiki.de/wiki-files/javaQ1Q2.zip]''' runterladen
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")
* In BlueJ:
** Project -> Open Non BlueJ bzw. Projekt -> Fremdprojekt öffnen
** Den Ordner "javaQ1Q2" suchen.
*** Evtl. enthält dieser einen inneren Ordner "javaQ1Q2"! Dann diesen nehmen.
* '''Jetzt noch die notwendigen Libraries hinzufügen:'''
** Tools -> Preferences -> Libraries -> Add bzw. Werkzeuge -> Einstellungen -> Bibliotheken -> Hinzufügen
** Den Ordner "libraries" suchen.
** In diesem Ordner jede jar-Datei einzeln durch Anklicken hinzufügen (=etwas mühsam...)
* Abschließend mit STRG+UMSCHALT+R die Virtuelle Maschine neu starten.
* Testen: Im Package _test die Klasse Graphtest: rechte Maustaste -> main ausführen.

Eclipse

2025-07-06T15:14:30Z

Akaibel:

[[Kategorie:Informatik]]
[[Kategorie:Informatik-EF]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Q2]]

Eclipse ist eine professionelle Entwicklungsumgebung für Java. Eclipse ist Open Source und damit gratis.

Am SIBI arbeiten wir in Eclipse vor allem mit dem [[Projekt_java_Q1Q2]].

'''Wenn man Eclipse installiert und das [[Projekt_java_Q1Q2]] runtergeladen und mit Eclipse geöffnet hat, dann hat man softwaremäßig bis zum Abitur ausgesorgt!''' 
'''D.h. der Aufwand lohnt sich!!!'''

=Eclipse Installation mit JRE (Java Runtime Environment) =
''Hier wird nur gezeigt, wie man Eclipse als Paket mit einer JRE (Java Runtime Environment) installiert. Wer Java schon installiert hat, kann auf eine Installation ohne JRE zurückgreifen. Die installierte Java-Version muss sich aber für Eclipse eignen! (Das tun nicht alle Java-Versionen.) ''

* [http://www.eclipse.org/downloads/ Eclipse Downloads]
* Install your favorite desktop IDE packages:
** Download klicken
** Download x86_64
** Auf der nächsten Seite "eclipse-inst-jre-win64.exe" klicken. Das ist ein Eclipse-Installer, mit dem man verschiedene Eclipse-Versionen installieren kann.
* Nach dem Runterladen des Installers:
** Installer "eclipse-inst-jre-win64.exe" mit Doppelklick starten.
** '''Eclipse IDE for Java Developers''' wählen. Das ist die minimale Eclipse-Version, die aber VIEL schneller hochfährt als andere Versionen, die noch alles Mögliche sonst können (was man nicht braucht).

=Projekt java_Q1Q2=
Das ist das große Projekt, was alle Java-Entwicklung für die ganze Oberstufe abdeckt:

[[Projekt_java_Q1Q2]]

=Tricks im Umgang mit Eclipse=
Wichtige Shortcuts etc., die einem das Leben leichter machen:

[[Eclipse Tricks]]

=Neues Projekt in Eclipse anlegen=
Wer selber mit Eclipse ein Projekt aufsetzen will, kann wie folgt ein neues Projekt anlegen:
* File -> New -> Java Project
* Haken wegnehmen bei "Use default location"
* Mit "Browse" den Ordner des Eclipse-Projektes angeben.
* Finish klicken.

Eclipse

2025-07-06T15:14:02Z

Akaibel: /* Graphische Oberflächen mit Eclipse programmieren */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Q2]]

Eclipse ist eine professionelle Entwicklungsumgebung für Java. Eclipse ist Open Source und damit gratis.

Am SIBI arbeiten wir in Eclipse vor allem mit dem [[Projekt_java_Q1Q2]].

'''Wenn man Eclipse installiert und das [[Projekt_java_Q1Q2]] runtergeladen und mit Eclipse geöffnet hat, dann hat man softwaremäßig bis zum Abitur ausgesorgt!''' 
'''D.h. der Aufwand lohnt sich!!!'''

=Eclipse Installation mit JRE (Java Runtime Environment) =
''Hier wird nur gezeigt, wie man Eclipse als Paket mit einer JRE (Java Runtime Environment) installiert. Wer Java schon installiert hat, kann auf eine Installation ohne JRE zurückgreifen. Die installierte Java-Version muss sich aber für Eclipse eignen! (Das tun nicht alle Java-Versionen.) ''

* [http://www.eclipse.org/downloads/ Eclipse Downloads]
* Install your favorite desktop IDE packages:
** Download klicken
** Download x86_64
** Auf der nächsten Seite "eclipse-inst-jre-win64.exe" klicken. Das ist ein Eclipse-Installer, mit dem man verschiedene Eclipse-Versionen installieren kann.
* Nach dem Runterladen des Installers:
** Installer "eclipse-inst-jre-win64.exe" mit Doppelklick starten.
** '''Eclipse IDE for Java Developers''' wählen. Das ist die minimale Eclipse-Version, die aber VIEL schneller hochfährt als andere Versionen, die noch alles Mögliche sonst können (was man nicht braucht).

=Projekt java_Q1Q2=
Das ist das große Projekt, was alle Java-Entwicklung für die ganze Oberstufe abdeckt:

[[Projekt_java_Q1Q2]]

=Tricks im Umgang mit Eclipse=
Wichtige Shortcuts etc., die einem das Leben leichter machen:

[[Eclipse Tricks]]

=Neues Projekt in Eclipse anlegen=
Wer selber mit Eclipse ein Projekt aufsetzen will, kann wie folgt ein neues Projekt anlegen:
* File -> New -> Java Project
* Haken wegnehmen bei "Use default location"
* Mit "Browse" den Ordner des Eclipse-Projektes angeben.
* Finish klicken.

2024-12-28T17:41:40Z

Akaibel: /* Von GitHub beziehen */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Q2]]

Das Projekt java_Q1Q2 umfasst ALLE Szenarien, mit denen am SIBI in der Q1 und Q2 Java entwickelt wird.

'''D.h. wer sich das einmal runterlädt, der hat softwaremäßig für die Q1 und Q2 ausgesorgt!!!'''

=Stand des Projektes:=

* Das Projekt bildet die Schnittstellen des Abi 2018 (und folgende) ab.

* Letztes Update: 28.12.2024

''Der aktuellste Stand des Projektes findet sich immer auf GitHub. (siehe weiter unten).''

=Voraussetzungen=

Man kann das Projekt mit jeder Entwicklungsumgebung bearbeiten. Unsere Empfehlung für die Installation zuhause ist Visual Studio Code, weil es einfach zu installieren und einfach zu bedienen ist - und problemlos auch für andere Programmiersprachen genutzt werden kann (mit sogenannten Extensions).

==Visual Studio Code==
''Man kann sich von ChatGPT durch die Installation von Visual Studio Code führen lassen. Wichtige Stichworte: Visual Studio Code Java installieren und GIT installieren. Ansonsten ist hier eine Anleitung:'' 

'''Installation''':
* [https://www.youtube.com/watch?v=RkU3ape9e24 Erklärvideo zur Installation von VS Code und Java (2:30min)]
* [https://devblogs.microsoft.com/java/announcing-visual-studio-code-java-installer/ Link zum Artikel (aus dem Video)]
* [https://aka.ms/vscode-java-installer-win direkter Link zum Installer]
* Wenn die Installation von VS-Code fehlschlägt:
** [https://code.visualstudio.com/Download Download von VS-Code]
** Dann muss man links das Symbol für "Extensions" anklicken, "Extension Pack für Java" auswählen und das installieren.

== Eclipse==

Um das Projekt öffnen zu können, muss man '''[[Eclipse]]''' installiert haben. Wie man das tut, erfährt man hier: '''[[Eclipse|Eclipse]]'''.

==BlueJ==

Man kann das Projekt auch mit '''BlueJ''' öffnen. 
Richtig zu empfehlen ist das nicht, denn BlueJ ist eine "Spielzeug"-Entwicklungsumgebung, die z.B. Visual Studio Code oder Eclipse (oder IntelliJ) weit unterlegen ist. 
BlueJ sollte man nur nehmen, wenn man es sowieso schon auf dem Rechner hat und überhaupt keine Lust hat sich mit einer vernünftigen Entwicklungsumgeung auseinanderzusetzen.

'''WICHTIG: ''' Wenn man das Projekt mit BlueJ öffnet, dann muss man alle Klassen über die main-Methode starten:

* rechte Maustaste auf die Klasse -> main auswählen.

=Download und Öffnen in Eclipse=
'''''Dieser Weg ist viel komplizierter als das direkte Runterladen von GitHub (siehe unten).'''''

'''Runterladen und entpacken:'''
* '''[https://sibiwiki.de/wiki-files/javaQ1Q2.zip https://sibiwiki.de/wiki-files/javaQ1Q2.zip]''' runterladen
* Stand: 28.12.2024
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")

'''In Eclipse...'''

*File -> New -> Java Project
*Haken weg bei "Use Default Location"
*"Browse" klicken und den Ordner "javaQ1Q2" suchen.
**Evtl. liegt dieser Ordner in einem übergeordneten Ordner "javaQ1Q2". Dann den "inneren" der beiden Ordner wählen.
*"Finish" klicken

'''Die notwendigen Bibliotheken einbauen:'''

* in Eclipse sollten die Bibliotheken eingebaut sein.
** wenn nicht: __readme/notwendige_libraries.odt ''(im Ordner javaQ1Q2)''
* andere IDEs:
** __readme/notwendige_libraries.odt ''(im Ordner javaQ1Q2)'' zeigt, welche Libraries eingebaut werden müssen.

==Von GitHub beziehen==
Man kann das Projekt javaQ1Q2 auch von GitHub beziehen. Dort findet sich die aktuelleste Version des Projektes:

'''[https://github.com/akaibel/javaQ1Q2 https://github.com/akaibel/javaQ1Q2]'''

===Eclipse:===
# Copy the GitHub URL of the repository to the clipboard.
# Open Eclipse and choose File -> Import –> Git -> Projects from Git
# Choose the Clone URI option in the Git import wizard and click Next.
# Confirm the URI, Host and Repository path parameters and click Next.
# In "local destination" choose the directory, where the project should go to.

===Visual Studio Code===
* ChatGPT befragen mit folgendem Prompt:
* <code>vs code runterladen https://github.com/akaibel/javaQ1Q2</code>

=Download und Öffnen in BlueJ=
* '''[[Datei:Java Q1Q2.zip]]'''
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")
* In BlueJ:
** Project -> Open Non BlueJ bzw. Projekt -> Fremdprojekt öffnen
** Den Ordner "java-Q1Q2-202021" suchen.
*** Evtl. liegt dieser Ordner im Ordner "java-Q1Q2-202021-2020-07-28".
* '''Jetzt noch die notwendigen Libraries laden:'''
** '''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen und entzippen.

** Tools -> Preferences -> Libraries -> Add bzw. Werkzeuge -> Einstellungen -> Bibliotheken -> Hinzufügen

** Den Ordner ECLIPSE_LIBRARIES suchen.
** In diesem Ordner jede jar-Datei einzeln durch Anklicken hinzufügen (=etwas mühsam...)
* Abschließend mit STRG+UMSCHALT+R die Virtuelle Maschine neu starten.
* Testen: Im Package _test die Klasse Graphtest: rechte Maustaste -> main ausführen.

Projekt java Q1Q2

2024-12-28T17:38:07Z

Akaibel: /* Von GitHub beziehen */

[[Kategorie:Informatik]]
[[Kategorie:Informatik-Q1]]
[[Kategorie:Informatik-Q2]]

Das Projekt java_Q1Q2 umfasst ALLE Szenarien, mit denen am SIBI in der Q1 und Q2 Java entwickelt wird.

'''D.h. wer sich das einmal runterlädt, der hat softwaremäßig für die Q1 und Q2 ausgesorgt!!!'''

=Stand des Projektes:=

* Das Projekt bildet die Schnittstellen des Abi 2018 (und folgende) ab.

* Letztes Update: 28.12.2024

''Der aktuellste Stand des Projektes findet sich immer auf GitHub. (siehe weiter unten).''

=Voraussetzungen=

Man kann das Projekt mit jeder Entwicklungsumgebung bearbeiten. Unsere Empfehlung für die Installation zuhause ist Visual Studio Code, weil es einfach zu installieren und einfach zu bedienen ist - und problemlos auch für andere Programmiersprachen genutzt werden kann (mit sogenannten Extensions).

==Visual Studio Code==
''Man kann sich von ChatGPT durch die Installation von Visual Studio Code führen lassen. Wichtige Stichworte: Visual Studio Code Java installieren und GIT installieren. Ansonsten ist hier eine Anleitung:'' 

'''Installation''':
* [https://www.youtube.com/watch?v=RkU3ape9e24 Erklärvideo zur Installation von VS Code und Java (2:30min)]
* [https://devblogs.microsoft.com/java/announcing-visual-studio-code-java-installer/ Link zum Artikel (aus dem Video)]
* [https://aka.ms/vscode-java-installer-win direkter Link zum Installer]
* Wenn die Installation von VS-Code fehlschlägt:
** [https://code.visualstudio.com/Download Download von VS-Code]
** Dann muss man links das Symbol für "Extensions" anklicken, "Extension Pack für Java" auswählen und das installieren.

== Eclipse==

Um das Projekt öffnen zu können, muss man '''[[Eclipse]]''' installiert haben. Wie man das tut, erfährt man hier: '''[[Eclipse|Eclipse]]'''.

==BlueJ==

Man kann das Projekt auch mit '''BlueJ''' öffnen. 
Richtig zu empfehlen ist das nicht, denn BlueJ ist eine "Spielzeug"-Entwicklungsumgebung, die z.B. Visual Studio Code oder Eclipse (oder IntelliJ) weit unterlegen ist. 
BlueJ sollte man nur nehmen, wenn man es sowieso schon auf dem Rechner hat und überhaupt keine Lust hat sich mit einer vernünftigen Entwicklungsumgeung auseinanderzusetzen.

'''WICHTIG: ''' Wenn man das Projekt mit BlueJ öffnet, dann muss man alle Klassen über die main-Methode starten:

* rechte Maustaste auf die Klasse -> main auswählen.

=Download und Öffnen in Eclipse=
'''''Dieser Weg ist viel komplizierter als das direkte Runterladen von GitHub (siehe unten).'''''

'''Runterladen und entpacken:'''
* '''[https://sibiwiki.de/wiki-files/javaQ1Q2.zip https://sibiwiki.de/wiki-files/javaQ1Q2.zip]''' runterladen
* Stand: 28.12.2024
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")

'''In Eclipse...'''

*File -> New -> Java Project
*Haken weg bei "Use Default Location"
*"Browse" klicken und den Ordner "javaQ1Q2" suchen.
**Evtl. liegt dieser Ordner in einem übergeordneten Ordner "javaQ1Q2". Dann den "inneren" der beiden Ordner wählen.
*"Finish" klicken

'''Die notwendigen Bibliotheken einbauen:'''

* in Eclipse sollten die Bibliotheken eingebaut sein.
** wenn nicht: __readme/notwendige_libraries.odt ''(im Ordner javaQ1Q2)''
* andere IDEs:
** __readme/notwendige_libraries.odt ''(im Ordner javaQ1Q2)'' zeigt, welche Libraries eingebaut werden müssen.

==Von GitHub beziehen==
Man kann das Projekt javaQ1Q2 auch von GitHub beziehen. Dort findet sich die aktuelleste Version des Projektes:

'''[https://github.com/akaibel/javaQ1Q2 https://github.com/akaibel/javaQ1Q2]'''

'''So bekommt man es in Eclipse:'''
# Copy the GitHub URL of the repository to the clipboard.
# Open Eclipse and choose File -> Import –> Git -> Projects from Git
# Choose the Clone URI option in the Git import wizard and click Next.
# Confirm the URI, Host and Repository path parameters and click Next.
# In "local destination" choose the directory, where the project should go to.

'''So bekommt man das Projekt in Visual Studio Code:''' 
* ChatGPT befragen mit folgendem Prompt:
* <code>vs code runterladen https://github.com/akaibel/javaQ1Q2</code>

=Download und Öffnen in BlueJ=
* '''[[Datei:Java Q1Q2.zip]]'''
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")
* In BlueJ:
** Project -> Open Non BlueJ bzw. Projekt -> Fremdprojekt öffnen
** Den Ordner "java-Q1Q2-202021" suchen.
*** Evtl. liegt dieser Ordner im Ordner "java-Q1Q2-202021-2020-07-28".
* '''Jetzt noch die notwendigen Libraries laden:'''
** '''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen und entzippen.

** Tools -> Preferences -> Libraries -> Add bzw. Werkzeuge -> Einstellungen -> Bibliotheken -> Hinzufügen

** Den Ordner ECLIPSE_LIBRARIES suchen.
** In diesem Ordner jede jar-Datei einzeln durch Anklicken hinzufügen (=etwas mühsam...)
* Abschließend mit STRG+UMSCHALT+R die Virtuelle Maschine neu starten.
* Testen: Im Package _test die Klasse Graphtest: rechte Maustaste -> main ausführen.