https://sibiwiki.de/wiki/api.php?action=feedcontributions&user=Akaibel&feedformat=atomSibiWiki - Benutzerbeiträge [de]2024-03-29T01:42:26ZBenutzerbeiträgeMediaWiki 1.37.1https://sibiwiki.de/wiki/index.php?title=Java_nervige_Sprachelemente&diff=3692Java nervige Sprachelemente2024-03-16T17:17:22Z<p>Akaibel: Die Seite wurde neu angelegt: „Kategorie:Informatik Kategorie:Informatik-Abitur Hier wird aufgeführt, was sich kurz vor der Abiturklausur zu wiederholen lohnt - einfach um darüber Bescheid zu wissen! '''Datei:Dokumentation-Informatik-Seite-1-3.pdf''':<br/>Hier sind alle Java- und SQL-Sprachelemente aufgeführt, die im Zentralabitur vorausgesetzt werden.<br/>'''Einmal durchlesen und checken, ob man etwas nicht kennt / kann!'''* Aus dieser Datei werden einige wichtige Sp…“</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<br />
<br />
Hier wird aufgeführt, was sich kurz vor der Abiturklausur zu wiederholen lohnt - einfach um darüber Bescheid zu wissen!<br />
'''[[Datei:Dokumentation-Informatik-Seite-1-3.pdf]]''':<br/>Hier sind alle Java- und SQL-Sprachelemente aufgeführt, die im Zentralabitur vorausgesetzt werden.<br/>'''Einmal durchlesen und checken, ob man etwas nicht kennt / kann!'''*<br />
<br />
Aus dieser Datei werden einige wichtige Sprachelemente hier nochmal kurz erklärt. Wichtig sind sie insofern, als sie schon häufiger im Abitur vorkamen!<br />
<br />
* '''Teilen von ganzen Zahlen''' : z.B.: <code>int a = 11/4;</code><br/>Beim Teilen von ganzen Zahlen wird '''immer abgerundet'''. D.h. a hat den Wert 2.<br />
<br />
* '''%''' : z.B.: <code>int a = x%4;</code><br/>Mit % berechnet man den Rest beim Teilen. <br/>D.h. für x = 14 wird dann a = 14%4 = 2.<br />
<br />
* '''!''' : z.B.: <code>if(!pTree.isEmpty())</code><br/>bedeutet "nicht". <br/>D.h. hier: Wenn pTree nicht leer ist.<br />
<br />
* '''||''' : z.B.: <code>if(zahl < 0 || zahl > 10) </code><br/>bedeutet "oder".<br/>D.h. hier: Wenn zahl kleiner als 0 oder zahl größer als 10 ist .<br />
<br />
* '''&&''' : z.B.: <code>if(zahl > 0 && zahl < 10) </code><br/>bedeutet "und".<br/>D.h. hier: Wenn zahl größer als 0 und zahl kleiner als 10 ist (d.h. für Zahlen zwischen 0 und 10, jeweils ausschließlich).<br />
<br />
* '''Integer.parseInt(...)''': Wandelt einen String in eine Ganzzahl um.Z.B.<br/><code>String zahlString = "12345";<br/><code>int zahl = Integer.parseInt(zahlString);</code><br/>Entsprechend gibt es Double.parseDouble(...) und Boolean.parseBoolean(...)<br />
<br />
* '''charAt(n)''': Eine Methode der Klasse String: Gibt den n-ten Buchstaben eines Strings zurück. Z.B.:<br/><code>String wort = "Hallo";<br/><code>char buchstabe = wort.charAt(1);</code><br/>buchstabe hat dann den Wert 'a' (Denn der erste Buchstabe hat immer den Index 0!)<br />
<br />
* '''indexOf(teilString)''': Methode der Klasse String. Gibt die Position des Teilstrings an. Z.B.:<br/><code>String wort = "Hallo";<br/><code>int position = wort.indexOf("ll");</code><br/>position hat dann den Wert 2.<br />
<br />
* '''compareTo(andererString)''': Methode der Klasse String. Vergleicht die zwei Strings alphabetisch und gibt eine negative Zahl, 0 oder eine positive Zahl zurück.<br />
* '''substring(int beginIndex)''' bzw. '''substring(int beginIndex, int endIndex)''': Methoden der Klasse String. Sie geben einen Teilstring zurück.<br />
* '''continue;''' Macht beim nächsten Schleifendurchlauf weiter.<br />
<br />
* '''break;''' Verlässt eine Schleife.<br />
<br />
* '''continue;''' Macht sofort beim nächsten Schleifendurchlauf weiter<br />
<br />
* '''BETWEEN''': SQL: bedeutet "zwischen".<br/> Beispiel: SELECT f.name FROM film f WHERE f.jahr BETWEEN 1980 and 1990.<br />
<br />
* '''UNION''': SQL: Schlüsselwort für Vereinigung:<br/>SELECT s.name, s.vorname FROM schueler s UNION SELECT l.name, l.vorname FROM lehrer l<br/>Die Namen und Vornamen von allen Schülern und allen Lehrern.<br/>Die durch UNION verbundenen Abfragen müssen gleich viele Spalten haben. <br />
<br />
* '''DISTINCT''': SQL. Sorgt dafür, dass alles, was dahinter steht, nur 1x aufgeführt wird:<br/>SELECT DISTINCT k.vorname, k.name FROM kunde k.<br/>Wenn es mehrere "Stefan Meyer" gibt, wird nur einer ausgegeben. (Aber andere Stefans werden ausgegeben!)<br />
<br />
* '''AVG''': SQL. Berechnet den Durchschnitt Beispiel:<br/>SELECT AVG(u.stunden) FROM unterricht u.<br />
<br />
* '''GROUP BY''': SQL. Fasst jeweils mehrere Zeilen zu einer zusammen. Beispiel:<br/>SELECT u.fach, SUM(u.stunden) FROM unterricht u GROUP BY u.fach<br />
<br />
* '''LIKE''' in Kombination mit '''%''': SQL. LIKE mit Prozent ermöglicht einen "ungefähren" Abgleich. Beispiel: <br/>SELECT k.name, k.ort FROM kunde k WHERE k.ort LIKE 'Bad%'<br>Sucht alle Kunden aus Orten, die mit "Bad" anfangen.<br />
<br />
* '''Wrapper-Klassen:''' Das sind Klassen zu den einfachen Datentypen int, double, char und boolean. D.h. so kann man zu den einfachen Datentypen Objekte erzeugen, z.B.: <br/><code>Double d = new Double(3.1415927);</code><br />
<br />
* '''Reguläre Sprache:''' Für jede reguläre Sprache '''gibt''' es eine reguläre Grammatik und einen DEA. <br/><u>ABER:</u>Eine nicht-reguläre Grammatik kann eine reguläre Sprache erzeugen!</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik-Abitur-2024&diff=3691Informatik-Abitur-20242024-03-16T16:51:06Z<p>Akaibel: /* Im GK NICHT im Vorabi: c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird alles gesammelt, was für das Abitur 2024 (LK + GK) wichtig ist.<br />
<br />
=Vorgaben für das Zentralabitur 2024=<br />
* '''[[Datei:IF-Abi-2024-Vorgaben.pdf|Vorgaben für das Informatik-Abitur 2024]]'''<br />
* Wesentlich sind die Tabellen auf S. 4 (GK) und S. 5 (LK).<br />
<br />
=Fachbegriffe=<br />
In der Vorabi-Klausur und im Abitur wird auf zuverlässige Anwendung von Fachbegriffen geachtet! <br />
<br />
Fachbegriffe erleichtern das Schreiben, weil man viel schneller und genauer schreiben kann!<br />
<br />
'''[[Informatik Fachbegriffe]]'''<br />
<br />
==Vorabi-Klausur==<br />
<font color='red'><br />
* Im LK gibt es im Vorabi 3 Aufgaben aus den drei unten genannten Bereichen. <br />
* Im GK gibt es nur 2 Aufgaben aus den Bereichen Datenbanken und Automaten. <br />
** Die Automaten-Aufgabe enthält eine Teilaufgabe zum Umgang mit linearen Datenstrukturen; wie unten angegeben.<br />
</font><br />
<br />
===a) Datenbanken und Datenschutz===<br />
# [[Entity-Relationship-Modell]] <br />
# [[relationales Datenmodell]]<br />
# [[SQL]]<br />
## schreiben<br />
## analysieren<br />
# <font color="red">im GK nicht im Vorabi: </font>[[Normalisierung]]<br />
# [[Java-SQL|mit Java auf SQL zugreifen]]<br />
# Grundprinzipien des [[Datenschutz|Datenschutzes]], und dabei vor allem:<br />
## Verbot mit Erlaubnisvorbehalt<br />
## Erforderlichkeit<br />
<br />
===b) Automaten und Grammatiken:===<br />
# [[Deterministischer Endlicher Automat]] (DEA)<br />
# [[reguläre Grammatik]] (linkslinear bzw. rechtslinear): Anforderungen kennen!<br />
# DEA/NEA in reguläre Grammatik umwandeln<br />
# reguläre Grammatik in NEA umwandeln<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Potenzmengenkonstruktion]] (um NEA in DEA zu verwandeln)<br />
# Grenzen von DEA: Darf nur endlich viele Zustände haben! Kann nicht zählen!<br />
# Durchlauf durch [[List|Listen]], um etwas zu suchen oder zu berechnen: <br />
## am einfachsten mit einer for-Schleife!<br />
## völlig ausreichend ist es, wenn man folgendes kann: [[List#Anzahl_aus_Geburtsjahr|Anzahl Personen aus Geburtsjahr]]<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Parser]] für DEA programmieren: Am einfachsten mit if-else<br />
# '''nur LK:''' [[Kellerautomat]] und Parser für Kellerautomat<br />
# '''nur LK:''' [[Kontextfreie Grammatik]] (Anforderungen kennen!)<br />
# '''nur LK:''' [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomat]]<br />
<br />
===<font color='red'>Im GK NICHT im Vorabi: </font>c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung===<br />
# Erstellen / Erweitern von [[Klassen-_und_Implementationsdiagramm|Implementationsdiagrammen]]<br />
# Anwendung von linearen Datenstrukturen in der Programmierung: [[List]], [[Stack]], [[Queue]]<br />
# <font color="red">NEU: </font>Einen [[Algorithmus entwickeln und implementieren]].<br />
# [[Vererbung]] und [[Polymorphie]] <strike>und [[Interface]]</strike><br />
# [[Array|Arrays]]<br />
## eindimensionale Arrays und zweidimensionale Arrays, die Objekte enthalten.<br />
## Arrays, die Objekte enthalten.<br />
## Datenbanken: <i><code>String[][] data = queryResult.getData()</code> und dann das 2-dim Array <code>data</code> mit einer Schleife auswerten.</i><br />
# <s><font color="red">NEU: </font>[[Rekursion]]: <br/>Man muss nur eine rekursive Methode analysieren können, d.h. nicht selber schreiben!</s><br />
# <font color="red">NEU: </font>[[Wrapper-Klassen]]<br />
# <s>[[Struktogramm|Struktogramme]] für Programmabläufe verstehen/erweitern.</s></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Bin%C3%A4rer_Suchbaum&diff=3690Binärer Suchbaum2024-03-11T17:57:05Z<p>Akaibel: </p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Q1]]<br />
[[Kategorie:Datenstrukturen(IF)]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<br />
[[File:Binbaum.jpg|thumb|Binärer Suchbaum mit 15 Elementen |600px]]<br />
=Definition=<br />
Ein binärer Suchbaum ist ein [[allgemeiner Binärbaum ab Abi 2017|Binärbaum]] mit einer zusätzlichen Eigenschaft:<br />
* die Elemente im linken Teilbaum sind ''kleiner'' als die Wurzel; die Elemente im rechten Teilbaum sind ''größer'' als die Wurzel.<br />
* Diese Eigenschaft gilt auch für alle Teilbäume eines binären Suchbaumes.<br />
Wie ''kleiner'' bzw. ''größer'' definiert werden, hängt dabei vom Anwendungszusammenhang ab; bei Personen kann z.B. das Alter oder die alphabetische Ordnung des Nachnamens das wesentliche Ordnungskriterium sein.<br />
<br />
=Erklärvideos=<br />
* [https://youtu.be/Hv2gABx0KAo Video 1: CelebritiesVerwaltung - Implementationsdiagramm]<br />
* [https://youtu.be/Cz1Nv8B1RH4 Video 2: CelebritiesVerwaltung - Implementierung]<br />
<br />
=Fachbegriffe=<br />
<br />
Wurzel, linker Teilbaum, rechter Teilbaum, Schnittstelle (interface), eine Schnittstelle implementieren (implements), abstrakt (abstrakte Methode)<br />
<br />
=Eigenschaften eines Suchbaumes=<br />
'''Suchen:'''<br />
<br />
Binäre Suchbäume haben den Vorteil, dass man in ihnen <u>sehr schnell suchen</u> kann: <br/>Man muss nicht den ganzen Baum zu durchsuchen, sondern kann - ausgehend von der Wurzel - einen Pfad bis zum Blatt abgehen. Je nachdem, ob das gesuchte Element kleiner oder größer ist als der gerade betrachtete Knoten, biegt man rechts (bzw. links) ab.<br />
<br />
Der Geschwindigkeitsvorteil ist enorm und wird immer größer, je größer der Baum wird.<br/>(Vorausgesetzt, der Baum ist balanciert.)<br />
<br />
Bei einem perfekt balancierten Baum sieht das so aus:<br />
* Bei 1.000 Elementen braucht man nur 10 Vergleiche<br />
* Bei 1.000.000 Elementen braucht man nur 20 Vergleiche<br />
* Bei n Elementen braucht man log<sub>2</sub>(n) Vergleiche.<br />
<br />
<br />
'''Sortierte Liste:'''<br />
<br />
Der Inorder-Durchlauf (Links -> Wurzel -> Rechts) eines Suchbaumes ergibt genau die alphabetische Ordnung. (Zu den verschiedenen Durchlaufarten durch Binärbäume: s. [[allgemeiner Binärbaum ab Abi 2017#Traversierung|Traversierung von Binärbäumen]])<br />
<br />
=Schnittstelle des Zentralabiturs=<br />
[[Medium:Dokumentation2017_BinarySearchTree_ComparableContent.pdf|Schnittstelle BinarySearchTree (PDF)]]<br />
==Erläuterungen zur Schnittstelle ==<br />
Die Schnittstelle des Zentralabiturs besteht aus zwei Klassen:<br />
* <code>BinarySearchTree</code> ist der eigentliche binäre Suchbaum.<br />
* <code>ComparableContent</code>: In einen <code>BinarySearchTree</code> können nur Objekte eingefügt werden, die das [[Interface]] <code>ComparableContent</code> implementieren. <code>ComparableContent</code> erzwingt die Implementierung der Methoden <code>isEqual</code>, <code>isGreater</code> und <code>isLess</code>. Dadurch wird festgelegt, wie Objekte in den Suchbaum einsortiert werden.<br />
* Die Methoden von <code>CompararableContent</code> sind alle '''abstrakt''': Das heißt, sie haben selber keine Implementierung, sie erzwingen aber eine Implementierung von jeder Klasse, die von <code>CompararableContent</code> erbt.<br />
=Beispiel: Verwendung von <code>BinarySearchTree</code> und <code>ComparableContent</code>=<br />
In einer Bibliothek soll der Buchbestand in einem Binären Suchbaum gespeichert werden, damit man schnell nach einem bestimmten Buchtitel suchen kann. Das heißt, das Ordnungskriterium für den Suchbaum ist die alphabetische Ordnung nach dem Titel der Bücher.<br />
<br />
Im Detail sind für die Bibliothek folgende Methoden vorgesehen:<br />
* '''suchen:''' Man übergibt einen Buchtitel und erhält das Buch<br />
* '''buecherListeEinfuegen:''' Man übergibt eine Liste von Büchern, die - gemäß dem Ordnungskriterium Titel - richtig in den binären Suchbaum eingefügt werden.<br />
Für die einzelnen Bücher werden lediglich Titel und Regalnummer gespeichert; die Regalnummer soll man nachträglich ändern können, den Titel nicht.<br />
Objekte der Klasse <code>Buch</code> sollen in einen binären Suchbaum eingefügt bzw. nach bestimmten Titeln gesucht werden. Dabei soll das Ordnungskriterium die alphabetische Ordnung nach dem Titel sein.<br />
<br />
==Implementationdiagramm==<br />
[[File:BinarySearchTree_Bibliothek_Implementationsdiagramm.png|Implementationsdiagramm Bibliothek |686px]]<br />
<br />
'''Erläuterungen:'''<br />
* Bibliothek hat (=besitzt) einen <code>BinarySearchTree</code>, in dem nur Objekte vom Typ <code>Buch</code> gespeichert werden können.<br />
* <code>Buch</code> muss das [[Interface]] <code>ComparableCont</code> implementieren, damit es überhaupt im <code>BinarySearchTree buecherBaum</code> gespeichert werden kann.<br />
* Das hat als Konsequenz: <code>Buch</code> muss die Methoden <code>isEqual</code>, <code>isGreater</code> und <code>isLess</code> so überschreiben, dass die Bücher nach dem Titel verglichen werden.<br />
<br />
==Implementierung==<br />
<br />
<code><br />
public class Buch <u><b>implements ComparableContent<Buch></b></u>{<br />
private String titel;<br />
private int regalNr;<br />
<br />
public Buch(String pTitel, int pRegalNr){<br />
titel = pTitel;<br />
regalNr = pRegalNr;<br />
}<br />
<br />
public int getRegalNr() {<br />
return regalNr;<br />
}<br />
<br />
public void setRegalNr(int regalNr) {<br />
this.regalNr = regalNr;<br />
}<br />
<br />
public String getTitel() {<br />
return titel;<br />
}<br />
<br />
<b><u>public boolean isEqual(Buch pContent) {</u></b><br />
<b>return (titel.equals(pBuch.getTitel());</b><br />
}<br />
<br />
<b><u>public boolean isLess(Buch pContent) {</u></b><br />
<b>return(titel.compareTo(pBuch.getTitel())<0);</b><br />
}<br />
<br />
<b><u>public boolean isGreater(Buch pContent) {</u></b><br />
<b>return(titel.compareTo(pBuch.getTitel())>0);</b><br />
}<br />
}<br />
</code><br />
<br />
Jetzt können z.B. in einer Klasse <code>Bibliothek</code> Objekte der Klasse <code>Buch</code> in einen <code>BinarySearchTree</code> eingefügt werden:<br />
<br />
<code><br />
public class Bibliothek{<br />
<br />
//hier werden die Buecher gespeichert<br />
BinarySearchTree<Buch> buecherBaum;<br />
<br />
public Bibliothek(){<br />
buecherBaum = new BinarySearchTree<Buch>();<br />
} <br />
<br />
'''public void uebertrageListeInBaum(List<Buch> buecherListe)'''{<br />
for(buecherListe.toFirst(); buecherListe.hasAccess(); buecherListe.next()){<br />
Buch aktuellesBuch = buecherListe.getContent();<br />
<u>buecherBaum.insert(aktuellesBuch);</u><br />
}<br />
}<br />
<br />
'''public Buch suche(String pTitel)'''{<br />
// man muss erst ein Dummy-Buch erzeugen<br />
// nach dem kann man dann suchen<br />
<u>Buch dummyBuch = new Buch(pTitel, -1);</u><br />
Buch ergebnis = <u>buecherBaum.search(dummyBuch);</u><br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
'''Erläuterungen zur Methode <code>public Buch suche(String pTitel)</code>''':<br />
<br />
Die Implementierung sieht auf den ersten Blick etwas eigenwillig aus, ist aber die einfachste und schnellste. Warum wird das so gemacht?<br />
<br />
* In Objekten vom Typ <code>BinarySearchTree<Buch></code> kann man nur nach Objekten vom Typ <code>Buch</code> suchen.<br />
* D.h. man muss erst ein <code>dummyBuch</code> erstellen, das den gewünschten Titel trägt.<br />
* Da <code>Buch</code> das [[Interface]] <code>ComparableContent</code> implementiert, kann man mithilfe von <code>dummyBuch</code> die Methode <code>search</code> aufrufen.<br />
* <code>search</code> gibt dann das "richtige" gesuchte Buch zurück.<br />
* WICHTIG: <code>ergebnis</code> ist das "richtige" Buch; <code>dummyBuch</code> wurde nur dafür erstellt, damit man nach einem Titel suchen kann!<br />
<br />
=ComparableContent: Java-Quellcode=<br />
Das [[Interface]] <code>ComparableContent</code> stellt sicher, dass nur Objekte in einen '''binären Suchbaum''' eingefügt werden, die man miteinander vergleichen kann. (Ohne Objekte als ''größer'', ''gleich'' oder ''kleiner'' vergleichen zu können, wäre ein binärer Suchbaum natürlich sinnlos, man könnte keine Sortierung auf linke und rechte Teilbäume vornehmen.)<br />
<code><br />
public interface ComparableContent<ContentType> {<br />
public boolean isEqual(ContentType pContent);<br />
public boolean isLess(ContentType pContent);<br />
public boolean isGreater(ContentType pContent);<br />
}<br />
</code><br />
<br />
* Die Methoden werden in <code>ContentType</code> sind '''abstrakte Methoden''', d.h. sie werden nur deklariert, aber nicht implementiert!<br />
* Jede Klasse, die <code>ComparableContent</code> implementiert (Syntax: <code>public MyClass '''implements ComparableContent'''</code>), muss diese drei Methoden überschreiben und eine Implementierung anbieten.<br />
<br />
=Innerer Aufbau eines BinarySearchTree=<br />
Am einfachsten lässt sich ein BinarySearchTree konstruieren, wenn der BinarySearchTree einen BinaryTree besitzt und alle Aufgaben an ihn delegiert:<br />
[[File:BinarySearchTree_innerer_Aufbau.png]]<br />
<br />
''(Eine erbt-Beziehung ist <u>nicht</u> möglich, da es Methoden in BinaryTree gibt, die die Suchbaumstruktur des BinarySearchTree zerstören würden, z.B. setLeftTree.)''<br />
<br />
==Implementierung von search (LK)==<br />
Die Methode <code>search</code> lässt sich - genauso wie die Methode <code>insert</code> - mit einem Pfaddurchlauf realisieren:<br />
<br />
<code><br />
'''public ContentType search(ContentType pContent) {'''<br />
BinaryTree<ContentType b = myTree;<br />
while( ! b.isEmpty()){<br />
ContentType wurzel = b.getContent();<br />
if(pContent.isEqual(wurzel)){<br />
// gefunden!<br />
return wurzel;<br />
}<br />
if(pContent.isLess(wurzel)){<br />
// links abbiegen<br />
b = b.getLeftTree();<br />
}<br />
else{<br />
// rechts abbiegen<br />
b = b.getRightTree();<br />
}<br />
}<br />
// nicht gefunden!<br />
return null;<br />
}<br />
</code><br />
<br />
== Implementierung von insert(LK) ==<br />
Die Methode <code>insert</code> lässt sich - genauso wie die Methode <code>search</code> - mit einem Pfaddurchlauf realisieren:<br />
<br />
<code><br />
public void insert(ContentType pContent) {<br />
BinaryTree<ContentType> b = myTree;<br />
'''while(!b.isEmpty()){'''<br />
ContentType wurzel = b.getContent();<br />
'''// UPDATE von b'''<br />
if(pContent.isLess(wurzel)){<br />
'''b = b.getLeftTree();'''<br />
}<br />
else{<br />
'''b = b.getRightTree();'''<br />
}<br />
}<br />
// jetzt ist man beim richtigen leeren Knoten angekommen!<br />
b.setContent(pContent);<br />
}<br />
</code><br />
<br />
=Löschen (remove)=<br />
<br />
Die Klasse <code>BinarySearchTree</code> bietet neben der Methode <code>insert</code> auch die Methode <code>remove</code>, mit der man ein Element aus einem Suchbaum löschen kann - und die Suchbaumstruktur bleibt gewahrt!<br />
<br />
Das ist sehr angenehm, denn das Löschen von Elementen aus einem Suchbaum ist eine SEHR mühsame Angelegenheit, weil man genau darauf achten muss, dass die Suchbaum-Struktur nicht zerstört wird.<br />
<br />
'''Im folgenden wird dargestellt, wie das Löschen von Elementen aus einem Binären Suchbaum funktioniert.'''<br />
<br />
==Implementierung einer Löschmethode==<br />
[[Datei:loeschen_von_elementen_aus_baeumen.png|400px|thumb|right|Beispiel: Löschen der 34]]<br />
<br />
<font color='red'> Diese Methode ist '''nicht''' relevant für das Zentralabitur! </font><br />
<br />
Das Löschen von Knoten aus binären Suchbäumen ist insofern nicht ganz einfach, als man darauf achten muss, dass die Struktur des binären Suchbaums nicht zerstört wird. <br />
<br />
'''<font color='green'> TODO: Implementierung des Löschens auf Abi 2017 anpassen!!!</font>'''<br />
<br />
<br />
===Strategie===<br />
'''Standardfall'''<br />
# Den richtigen Knoten suchen: '''K0'''. Außerdem braucht man den '''Vorgänger von K0'''<br />
# Suche im linken Teilbaum von K0 den Knoten, der am weitesten rechts ist: '''K1'''. Außerdem braucht man den '''Vorgänger von K1'''<br />
# Hänge den (linken!) Nachfolger von K1 an den Vorgänger von K1.<br />
# K1 ersetzt jetzt K0, d.h. der Inhalt von K1 wird jetzt in den Knoten K0 geschrieben.<br />
<br />
<br />
<br />
'''Ausnahmefälle'''<br />
<br />
# K0 ist ein Blatt → einfach löschen.<br />
# Die Wurzel des Gesamtbaumes enthält das zu löschende Element<br />
## TODO<br />
# K0 hat keinen linken Teilbaum → Der Nachfolger von K0 ersetzt K0, d.h.:<br />
## Im Vorgänger von K0 wird der Nachfolger von K0 als (richtigen!) Nachfolger eingetragen.<br />
<br />
'''benötigte Methoden'''<br />
<br />
# <code>public boolean istBlatt(BinaryTree pTree)</code><br />
# <code>public BinaryTree findeK0Vorgaenger(BinaryTree pTree, Object pObject)</code><br />
# <code>public BinaryTree findeK1Vorgaenger(BinaryTree pTree)</code><br />
<br />
===Implementierung===<br />
<code><br />
public void loeschen(BinaryTree b, String zahl) {<br />
if(b.isEmpty())<br />
{<br />
return;<br />
}<br />
<br />
// wenn das zu loeschende Element die Wurzel ist:<br />
// 1. an einen Vater-Knoten anhaengen<br />
// 2. loeschen<br />
// 3. vaterknoten wieder wegnehmen <br />
if(b.getObject().equals(zahl)){<br />
BinaryTree vater = new BinaryTree("-999999");<br />
vater.setRightTree(b);<br />
loeschen(vater, zahl);<br />
b = vater.getRightTree();<br />
return;<br />
}<br />
<br />
BinaryTree K0vorgaenger = this.findeVorgaengerKnoten(b,zahl );<br />
System.out.println("Vorgänger von K0:" + K0vorgaenger.getObject());<br />
<br />
boolean K0haengtLinksAmVorgaenger = true;<br />
BinaryTree K0 = K0vorgaenger.getLeftTree();<br />
if(!K0vorgaenger.getRightTree().isEmpty() && <br />
zahl.equals(K0vorgaenger.getRightTree().getObject()))<br />
{ <br />
K0 = K0vorgaenger.getRightTree();<br />
K0haengtLinksAmVorgaenger = false;<br />
}<br />
<br />
String K0String = (String) K0.getObject();<br />
System.out.println("K0String: "+K0String);<br />
<br />
if(istBlatt(K0)){<br />
System.out.println("istBlatt!");<br />
if(K0haengtLinksAmVorgaenger){<br />
K0vorgaenger.setLeftTree(new BinaryTree());<br />
}<br />
else{<br />
K0vorgaenger.setRightTree(new BinaryTree());<br />
}<br />
return;<br />
}<br />
<br />
if(K0.getLeftTree().isEmpty()){<br />
K0.setObject(K0.getRightTree().getObject());<br />
K0.setLeftTree(K0.getRightTree().getLeftTree());<br />
K0.setRightTree(K0.getRightTree().getRightTree());<br />
return;<br />
}<br />
<br />
BinaryTree K1vorgaenger = vorgaengerVonAmWeitestenRechts(K0.getLeftTree());<br />
System.out.println("K1vorgaenger: " + K1vorgaenger.getObject());<br />
BinaryTree K1 = K1vorgaenger.getRightTree();<br />
System.out.println("K1: " + K1.getObject());<br />
<br />
K1vorgaenger.setRightTree(K1.getLeftTree());<br />
K0.setObject(K1.getObject());<br />
<br />
return;<br />
}<br />
<br />
private boolean istBlatt(BinaryTree pTree) {<br />
boolean ergebnis = pTree.getLeftTree().isEmpty() && pTree.getRightTree().isEmpty(); <br />
System.out.println("istBlatt("+pTree.getObject()+"): "+ergebnis);<br />
return ergebnis;<br />
}<br />
<br />
private BinaryTree vorgaengerVonAmWeitestenRechts(BinaryTree pTree) {<br />
System.out.println("vorgaengervonAmWeitestenRechts("+pTree.getObject()+")");<br />
if(pTree.getRightTree().isEmpty()){<br />
System.err.println("Fehler in vorgaengerVonAmWeitestenRechts");<br />
return null;<br />
}<br />
if(pTree.getRightTree().getRightTree().isEmpty()){<br />
return pTree;<br />
}<br />
BinaryTree ergebnis = this.vorgaengerVonAmWeitestenRechts(pTree.getRightTree());<br />
return ergebnis;<br />
}<br />
<br />
private BinaryTree findeVorgaengerKnoten(BinaryTree pTree, String zahl)<br />
{<br />
System.out.println("findeVorgaengerKnoten("+pTree.getObject()+", "+zahl+")");<br />
if(zahl.equals(pTree.getObject())){<br />
System.err.println(zahl+"ist die Wurzel von pTree selber!!!");<br />
return null;<br />
}<br />
boolean gefunden = false;<br />
int zahl1 = Integer.parseInt(zahl);<br />
<br />
BinaryTree ergebnis = pTree;<br />
while(gefunden == false){<br />
String wurzelString = (String) ergebnis.getObject();<br />
int wurzelInt = Integer.parseInt(wurzelString);<br />
<br />
System.out.println("wurzelInt" + wurzelInt);<br />
System.out.println("zahl" + zahl);<br />
System.out.println("ergebnis.getObject(): " + ergebnis.getObject());<br />
<br />
if(zahl.equals(ergebnis.getRightTree().getObject()) || <br />
zahl.equals(ergebnis.getLeftTree().getObject()))<br />
{<br />
gefunden = true;<br />
}<br />
else<br />
{<br />
if(zahl1 < wurzelInt){<br />
ergebnis = ergebnis.getLeftTree();<br />
}<br />
else{<br />
ergebnis = ergebnis.getRightTree();<br />
}<br />
}<br />
}<br />
return ergebnis;<br />
}<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik_Fachbegriffe&diff=3689Informatik Fachbegriffe2024-03-10T12:56:11Z<p>Akaibel: /* Algorithmen */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
<br />
Hier werden die wesentlichen Fachbegriffe zusammengestellt, die für das Informatik-Abitur relevant sind.<br />
<br />
''Kursiv sind "interne" Begriffe, die anschaulich sind, aber keine echten Fachbegriffe.''<br />
=Operatoren=<br />
Die Operatoren definieren, was genau man in einer Aufgabe zu machen hat. Anders als in Mathe sind die Operatoren weitestgehend "intuitiv" verständlich - mit Ausnahme des Operators "Analysieren" (siehe unten).<br />
* '''Liste der Operatoren:'''<br/>analysieren, angeben, anwenden, begründen, beschreiben, bestimmen, beurteilen, darstellen, dokumentieren, entscheiden, entwerfen, entwickeln, erläutern, ermitteln, erweitern, implementieren, interpretieren, modellieren, modifizieren, Stellung nehmen, überführen, vergleichen, vervollständigen, zeigen<br />
* '''Vollständige Liste der Operatoren mit Erläuterungen:'''<br/>[https://www.standardsicherung.schulministerium.nrw.de/cms/zentralabitur-wbk/faecher/getfile.php?file=2282 Operatoren Informatik-Abitur (Standardsicherung NRW)]<br />
* '''Analysieren Sie ... '''.<br/>''Der Operator "Analysieren Sie..." heißt in Informatik nur so viel wie "Denken Sie nach über...". <br/>Das heißt: <font color='red'>Dazu muss man NICHTS aufschreiben!!</font><br/>Der Operator "Analysieren Sie..." steht immer zusammen mit einem anderen Operator - und für den muss man was tun.<br />
<br />
=Algorithmen=<br />
''Algorithmen entwickeln und implementieren'' kann in jedem Teilbereich vorkommen! <br />
<br />
'''[[Algorithmus_entwickeln_und_implementieren|zum Nachlesen hier klicken]]'''<br />
<br />
* Die Methode ... hat als Parameter ... <br />
* Abbruchbedingung: Wenn ...., wird die Methode verlassen und ... zurückgegeben.<br />
* eine Variable ... mit Startwert ... festlegen.<br />
* ... mit einer Schleife ... durchlaufen.<br />
* für jedes Element...<br />
* wenn ... (sonst...)<br />
* Die Variable ... erhöhen/verringern um ...<br />
* Am Ende ... zurückgeben.<br />
<br />
=Datenbanken=<br />
==Entity-Relationship-Modellierung==<br />
'''[[Entity-Relationship-Modell|zum Nachlesen hier klicken]]'''<br />
* Kardinalität<br />
* 1:n<br />
* n:m<br />
* Primärschlüssel<br />
* Attribut<br />
* Entitätsmenge<br />
* Entität (=ein Objekt einer Entitätsmenge)<br />
* Relation (=Beziehung)<br />
<br />
==relationales Datenmodell==<br />
'''[[Relationales Datenmodell|zum Nachlesen hier klicken]]'''<br />
* Tabelle<br />
* Relationenschema (damit meint das Zentralabitur eine Tabelle)<br />
* Datenbankschema (damit meint das Zentralabitur das ganze relationale Datenmodell)<br />
* Attribut<br />
* Primärschlüssel: <u>unterstrichen</u><br />
* Fremdschlüssel: ↑<br/>''...bezieht sich auf den Primärschlüssel der Tabelle ...''<br />
* kombinierter Primärschlüssel<br />
<br />
==Normalisierung==<br />
'''[[Normalisierung|zum Nachlesen hier klicken]]'''<br />
* atomar<br />
* nicht eindeutiger Primärschlüssel<br />
* funktional abhängig von einem Teil des Primärschlüssel (Verstoß gegen 2. NF)<br />
* funktional abhängig von einem Nicht-Schlüssel-Attribut (Verstoß gegen 3. NF)<br />
* Anomalien<br />
** Einfüge-Anomalie<br />
** Änderungs-Anomalie<br />
** Lösch-Anomalie<br />
** die können nach Normalisierung nicht mehr auftreten!<br />
<br />
==SQL==<br />
'''[[SQL|zum Nachlesen hier klicken]]'''<br />
* Kartesisches Produkt: "jede(r) mit jedem"<br />
* Abgleich zwischen Tabellen<br />
* Verknüpfen (Join) von zwei Tabellen, wobei ... mit ... abgeglichen wird.<br />
* ''"Drückeberger"'': <code>... LEFT JOIN ... WHERE ... IS NULL</code><br />
* Differenz: <code>NOT IN</code><br />
* Vereinigung: <code>UNION</code><br />
* selbstdefinierte Tabelle<br />
* Alias: <code>AS</code><br />
* zusammenfassen von Zeilen: <code>GROUP BY</code><br />
* sortieren nach: <code>ORDER BY</code><br />
<br />
==mit Java auf Datenbanken zugreifen==<br />
'''[[Java-SQL|zum Nachlesen hier klicken]]'''<br />
* DatabaseConnector<br />
* Query (=Abfrage)<br />
* Variablen (z.B. Parameter) im SQL-Statement<br />
* Zeilenzahl: <code>int zeilenZahl = queryResult.getRowCount();</code><br />
* Array (2-dim): <code>String[][] data = queryResult.getData();</code><br />
** durchlaufen:<br/><code>for(int i=0; i<data.length; i++){<br/>&nbsp;&nbsp;&nbsp;String name = data[i][0];<br/>&nbsp;&nbsp;&nbsp;String vorname = data[i][1];</code><br />
* In Zahl konvertieren: <code>int zahl = Integer.parseInt(data[i][0]);</code><br />
<br />
=Objektorientierte Modellierung und Programmierung=<br />
'''zum Nachlesen:'''<br />
* [[Klassen-_und_Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* [[Klasse|Klasse]]<br />
* [[Vererbung|Vererbung]]<br />
* [[Polymorphie|Polymorphie]]<br />
* [[Abstrakte Klasse|Abstrakte Klasse]]<br />
* [[Interface|Interface]]<br />
* [[Java_Basis-Sprachelemente|Java Basis Sprachelemente]], u.a. Bedingung, Schleife etc.<br />
* [[Array|Arrays]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Vererbung|Vererbung]]<br />
** erbt von <br />
** ist ein (gleichbedeutend mit "erbt von"!)<br />
** Super-Klasse<br />
** Sub-Klasse<br />
* [[Polymorphie|Polymorphie]]<br />
** polymorphe Methode<br />
* [[Abstrakte Klasse|Abstrakte Klasse]] (=Klasse mit mind. einer abstrakten Methode)<br />
* abstrakte Methode<br />
* [[Interface|Interface]]<br />
* [[Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* hat-Beziehung<br />
* Assoziation (=kennt-Beziehung)<br />
* Multiplizität<br />
* [[Klasse|Klasse]]<br />
** Objekt (Von einer Klasse kann man mehrere Objekte erzeugen.)<br />
** Attribut<br />
*** public / private<br />
** Konstruktor<br />
* [[Java_Basis-Sprachelemente#Methoden|Methode]]<br />
** Parameter<br />
** lokale Variable<br />
** Rückgabetyp<br />
** public / private<br />
* ContentType (z.B. für Listen kann man den ContentType angeben.)<br />
* [[Interface|Schnittstelle (interface, vgl. ComparableContent)]]<br />
* [[Struktogramm]]<br />
* Anweisung<br />
* Methodenaufruf<br />
* [[Java_Basis-Sprachelemente#Verzweigungen_(if-else)|Bedingung]]<br />
* [[Java_Basis-Sprachelemente#Schleifen_(while,_for,_do-while)|Schleife]]<br />
** Zählschleife (for)<br />
** bedingte Schleife (while)<br />
** mit Schleife ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
* [[Array|Arrays]]<br />
** Index<br />
** Wert<br />
** [[Array#Zweidimensionale_Arrays|zweidimensionales Array]], z.B.: <code> private int[][] einmalEinsTabelle;</code><br />
<br />
=Java-Programmierung mit linearen Datenstrukturen=<br />
'''zum Nachlesen:'''<br />
* [[Queue#Verwendung_von_Queues|Verwendung von Queues]]<br />
* [[Stack#Verwendung_von_Stacks|Verwendung von Stacks]]<br />
* [[List#Standardvorgehen_im_Umgang_mit_Listen|List: Standardvorgehen]]<br />
* [[Array#Ein_Array_mit_einer_for-Schleife_durchlaufen|Array: durchlaufen]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Laufzeit_von_Algorithmen|Laufzeit]]<br />
** O(log(n)): Suchen in einem [[Binärer Suchbaum|Binären Suchbaum]]<br />
** O(n): Suchen in einer unsortierten Liste<br />
** O(n*log(n)): Sortieren mit [[Quicksort|Quicksort]]<br />
** O(n<sup>2</sup>): Sortieren mit [[Bubblesort]], [[Insertionsort]], [[Selectionsort|Selectionsort]]<br />
* <u>statische</u> Datenstruktur (Array): <br/>''Man muss vorher angeben, wie viele Einträge das Array hat.''<br />
* <u>dynamische</u> Datenstrukturen: Stack, List, Queue (und auch BinaryTree, BinarySearchTree, Graph)<br/>''Dynamische Datenstrukturen können während der Laufzeit "wachsen" und "schrumpfen".''<br />
* [[Java_Basis-Sprachelemente#NullPointerException|NullPointerException]]<br />
* [[Queue|Queue]]: Schlange (vorne - hinten)<br />
** vorderstes Element: <code>pQueue.front()</code><br />
** anhängen: <code>pQueue.enqueue(...)</code> <br />
** vorderstes Element entfernen: <code>pQueue.dequeue()</code><br />
** ist leer: <code>pQueue.isEmpty()</code><br />
** Hilfs-Queue: z.B. um einen Queue zu durchlaufen, ohne ihn zu zustören<br />
* [[Stack|Stack]]: Stapel (oben)<br />
** oberstes Element: <code>pStack.top()</code><br />
** oben drauflegen: <code>pStack.push(...)</code> <br />
** oberstes Element entfernen: <code>pStack.pop()</code><br />
** ist leer: <code>pStack.isEmpty()</code><br />
** Hilfs-Stack: z.B. um einen Stack zu durchlaufen, ohne ihn zu zustören<br />
* [[List|List]]: Liste.<br/>''Listen kann man einfach durchlaufen und irgendwo einfügen.''<br />
** anhängen: <code>pList.append(...)</code><br />
** einfügen vor dem aktuellen Element: <code>pList.insert(...);</code><br />
* [[Array|Array]]: <br/>''statische Datenstruktur - man muss die Anzahl der Elemente vorher festlegen.''<br />
* durchlaufen (Liste, Array)<br />
** ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
** eine Liste durchlaufen: <code>for(pList.toFirst(); pList.hasAccess(); pList.next())</code><br />
* aktuelles Element:<br />
** Array: <code>array[i];</code><br />
** Liste: <code>pList.getContent();</code><br />
* erzeugen<br />
** erzeugen eines Objektes: <code>Person p = '''new''' Person("Mustermann", "Max");</code><br />
** erzeugen einer Liste: <code>List<Person> ergebnisListe = '''new''' List<>();</code><br />
** erzeugen eines Arrays: <br/>z.B. <code>Person[] einwohner = '''new''' int[1000];</code><br/>''Vorsicht! In jedem der 1000 Werte steht <code>null</code>!''<br />
** erzeugen eines zweidimensionalen Arrays: <code>int[][] einmalEinsTabelle = new int[10][10];</code><br />
* Schleife<br />
** Schleife verlassen: <code>break;</code><br />
** Schleife beim nächsten Element fortsetzen: <code>continue;</code><br />
* Methode verlassen <code>return;</code><br />
* zurückgeben: <code>return ergebnis;</code><br />
* ausgeben: <code>System.out.println("Hallo");</code><br />
<br />
=Sortierverfahren=<br />
* [[Bubblesort]] <u>nur für Arrays!</u>, Laufzeit O(n<sup>2</sup>)<br />
* [[Insertionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* [[Selectionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* nur LK: [[Quicksort]] für Listen, Laufzeit O(n*log(n)) im Average Case<br />
* Sortieren mit einem [[Binärer Suchbaum|Binären Suchbaum ]]<br/>- Der Reihe nach in den Binären Suchbaum einfügen<br/>- Inorder-Traversierung<br/>Laufzeit O(n*log(n)) im Average Case<br />
<br />
=Binärbäume und binäre Suchbäume=<br />
* Rahmenmethode<br />
* rekursive Methode<br />
* Abbruchbedingung<br />
* ''Wurzelbehandlung''<br />
* ''Sachlogik''<br />
* rekursive Aufrufe<br />
* Traversierung<br />
* Preorder<br />
* Inorder (=im Suchbaum: Sortierte Ausgabe!)<br />
* Levelorder (nur LK)<br />
* Baumliste für Levelorder (nur LK)<br />
* ComparableContent<br />
* implementiert die Schnittstelle (ComparableContent)<br />
* ''Dummy'': zum Suchen in Suchbäumen.<br />
<br />
=Automaten und Grammatiken=<br />
'''zum Nachlesen:'''<br/><br />
[https://sibiwiki.de/wiki/index.php?title=Kategorie:Endliche_Automaten Kategorie endliche Automaten]<br />
<br/>''Da gibt es Links zu allen Unterüberschriften.''<br />
==endliche Automaten==<br />
* [[Deterministischer Endlicher Automat|Deterministischer endlicher Automat (DEA)]]<br />
** A, Z, d, Q<sub>0</sub>, E: ''allen Zuhörern doofen Quatsch erzählen''<br />
* Der DEA '''erkennt''' eine reguläre Sprache<br />
* Der DEA '''überprüft''' ein Wort, ob es zur Sprache gehört.<br />
* [[Nicht-deterministischer endlicher Automaten|Nicht-deterministischer endlicher Automat (NEA)]]<br />
** ''"es gibt einen Weg"''<br />
* Zustand<br />
**Anfangszustand<br />
**Endzustände<br />
* Übergang<br />
* Alphabet<br />
* Zustands-Übergangs-Graph<br />
* Zustands-Übergangs-Tabelle<br />
* Zustandsfolge<br />
** für einen NEA ggf. mit geschweifter Klammer mehrere Zustände zusammenfassen.<br />
* Senke (=ein Zustand, aus dem es keinen Ausweg mehr gibt)<br />
* [[Potenzmengenkonstruktion|Potenzmengenkonstruktion]]<br />
** Potenzmenge (=eine Menge von Zuständen)<br />
<br />
==[[Reguläre Grammatik|reguläre Grammatik]]==<br />
* G = {N, T, S, P} ''Nerds testen Sonys Playstation''<br />
* linkslineare Grammatik: Nicht-Terminal links<br />
* rechtslineare Grammatik: Nicht-Terminal rechts<br />
** <i>linkslineare und rechtslineare Regeln nicht mischen!!!<br/>z.B.: <code>S → aS | Sb</code><br/>ist nicht regulär!!!</i><br />
* Terminal-Symbol<br />
* Nicht-Terminal-Symbol<br />
**Startsymbol<br />
* Produktionsregeln<br />
* Produktion eines Wortes<br />
* die RG erzeugt eine (reguläre) Sprache<br />
<br />
==[[Kellerautomat|Kellerautomaten (nur LK)]]==<br />
* Keller-Alphabet<br />
* Keller-Zeichen<br />
* Epsilon (ε): Um den Endzustand zu erreichen, darf man das Zeichen ε (="nichts") schreiben.<br />
<br />
==[[Kontextfreie_Grammatik|kontextfreie Grammatik (nur LK)]]==<br />
* lässt sich durch Kellerautomaten prüfen<br />
<br />
==Parser==<br />
* [[Parser|Parser für DEA]]<br />
* [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomaten (nur LK)]]<br />
** Keller (=<code>Stack</code>)<br />
<br />
=[[Graph|Graph (nur LK!)]]=<br />
* Knoten<br />
* Kante<br />
* markieren (Knoten oder Kante)<br />
* Markierung aufheben<br />
* Gewicht<br />
* Traversierung (d.h. Breitendurchlauf oder Tiefendurchlauf)<br />
* [[Graph#Tiefendurchlauf|Tiefendurchlauf]]<br />
** rekursiv<br />
* [[Graph#Breitendurchlauf|Breitendurchlauf]]<br />
** Knotenliste<br />
* [[Dijkstra-Algorithmus|Dijkstra-Algorithmus]]<br />
* rote Liste (für Dijkstra-Algo)<br />
* gelbe Liste (für Dijkstra-Algo)<br />
<br />
=[[Datenschutz|Datenschutz]]=<br />
Schutz von Angaben, aus denen man einen bestimmten Menschen erkennen kann oder die einem bestimmten Menschen zugeordnet werden können. <br />
<br />
'''Prinzipien des Datenschutzes:'''<br />
* <u>Verbot mit Erlaubnisvorbehalt</u><br />
* Datenminimierung<br />
* Zweckbindung<br />
* Transparenz<br />
* <u>Erforderlichkeit</u><br />
<br />
=[[Backtracking|Backtracking (nur LK!)]]=<br />
* Stufe<br />
* Teillösungsschritt<br />
* Abbruchbedingung<br />
** Lösung erreicht<br />
** Lösung nicht mehr erreichbar<br />
** maximale Stufenzahl überschritten<br />
* rückgängig machen</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik_Fachbegriffe&diff=3688Informatik Fachbegriffe2024-03-10T12:54:57Z<p>Akaibel: /* Operatoren */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
<br />
Hier werden die wesentlichen Fachbegriffe zusammengestellt, die für das Informatik-Abitur relevant sind.<br />
<br />
''Kursiv sind "interne" Begriffe, die anschaulich sind, aber keine echten Fachbegriffe.''<br />
=Operatoren=<br />
Die Operatoren definieren, was genau man in einer Aufgabe zu machen hat. Anders als in Mathe sind die Operatoren weitestgehend "intuitiv" verständlich - mit Ausnahme des Operators "Analysieren" (siehe unten).<br />
* '''Liste der Operatoren:'''<br/>analysieren, angeben, anwenden, begründen, beschreiben, bestimmen, beurteilen, darstellen, dokumentieren, entscheiden, entwerfen, entwickeln, erläutern, ermitteln, erweitern, implementieren, interpretieren, modellieren, modifizieren, Stellung nehmen, überführen, vergleichen, vervollständigen, zeigen<br />
* '''Vollständige Liste der Operatoren mit Erläuterungen:'''<br/>[https://www.standardsicherung.schulministerium.nrw.de/cms/zentralabitur-wbk/faecher/getfile.php?file=2282 Operatoren Informatik-Abitur (Standardsicherung NRW)]<br />
* '''Analysieren Sie ... '''.<br/>''Der Operator "Analysieren Sie..." heißt in Informatik nur so viel wie "Denken Sie nach über...". <br/>Das heißt: <font color='red'>Dazu muss man NICHTS aufschreiben!!</font><br/>Der Operator "Analysieren Sie..." steht immer zusammen mit einem anderen Operator - und für den muss man was tun.<br />
<br />
=Algorithmen=<br />
''Algorithmen entwickeln und implementieren'' kann in jedem Teilbereich vorkommen! <br />
<br />
'''zum Nachlesen:'''<br />
* [[Algorithmus_entwickeln_und_implementieren|Algorithmen entwickeln und implementieren]]<br />
<br />
'''Fachbegriffe:'''<br />
* Die Methode ... hat als Parameter ... <br />
* Abbruchbedingung: Wenn ...., wird die Methode verlassen und ... zurückgegeben.<br />
* eine Variable ... mit Startwert ... festlegen.<br />
* ... mit einer Schleife ... durchlaufen.<br />
* für jedes Element...<br />
* wenn ... (sonst...)<br />
* Die Variable ... erhöhen/verringern um ...<br />
* Am Ende ... zurückgeben.<br />
<br />
=Datenbanken=<br />
==Entity-Relationship-Modellierung==<br />
'''[[Entity-Relationship-Modell|zum Nachlesen hier klicken]]'''<br />
* Kardinalität<br />
* 1:n<br />
* n:m<br />
* Primärschlüssel<br />
* Attribut<br />
* Entitätsmenge<br />
* Entität (=ein Objekt einer Entitätsmenge)<br />
* Relation (=Beziehung)<br />
<br />
==relationales Datenmodell==<br />
'''[[Relationales Datenmodell|zum Nachlesen hier klicken]]'''<br />
* Tabelle<br />
* Relationenschema (damit meint das Zentralabitur eine Tabelle)<br />
* Datenbankschema (damit meint das Zentralabitur das ganze relationale Datenmodell)<br />
* Attribut<br />
* Primärschlüssel: <u>unterstrichen</u><br />
* Fremdschlüssel: ↑<br/>''...bezieht sich auf den Primärschlüssel der Tabelle ...''<br />
* kombinierter Primärschlüssel<br />
<br />
==Normalisierung==<br />
'''[[Normalisierung|zum Nachlesen hier klicken]]'''<br />
* atomar<br />
* nicht eindeutiger Primärschlüssel<br />
* funktional abhängig von einem Teil des Primärschlüssel (Verstoß gegen 2. NF)<br />
* funktional abhängig von einem Nicht-Schlüssel-Attribut (Verstoß gegen 3. NF)<br />
* Anomalien<br />
** Einfüge-Anomalie<br />
** Änderungs-Anomalie<br />
** Lösch-Anomalie<br />
** die können nach Normalisierung nicht mehr auftreten!<br />
<br />
==SQL==<br />
'''[[SQL|zum Nachlesen hier klicken]]'''<br />
* Kartesisches Produkt: "jede(r) mit jedem"<br />
* Abgleich zwischen Tabellen<br />
* Verknüpfen (Join) von zwei Tabellen, wobei ... mit ... abgeglichen wird.<br />
* ''"Drückeberger"'': <code>... LEFT JOIN ... WHERE ... IS NULL</code><br />
* Differenz: <code>NOT IN</code><br />
* Vereinigung: <code>UNION</code><br />
* selbstdefinierte Tabelle<br />
* Alias: <code>AS</code><br />
* zusammenfassen von Zeilen: <code>GROUP BY</code><br />
* sortieren nach: <code>ORDER BY</code><br />
<br />
==mit Java auf Datenbanken zugreifen==<br />
'''[[Java-SQL|zum Nachlesen hier klicken]]'''<br />
* DatabaseConnector<br />
* Query (=Abfrage)<br />
* Variablen (z.B. Parameter) im SQL-Statement<br />
* Zeilenzahl: <code>int zeilenZahl = queryResult.getRowCount();</code><br />
* Array (2-dim): <code>String[][] data = queryResult.getData();</code><br />
** durchlaufen:<br/><code>for(int i=0; i<data.length; i++){<br/>&nbsp;&nbsp;&nbsp;String name = data[i][0];<br/>&nbsp;&nbsp;&nbsp;String vorname = data[i][1];</code><br />
* In Zahl konvertieren: <code>int zahl = Integer.parseInt(data[i][0]);</code><br />
<br />
=Objektorientierte Modellierung und Programmierung=<br />
'''zum Nachlesen:'''<br />
* [[Klassen-_und_Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* [[Klasse|Klasse]]<br />
* [[Vererbung|Vererbung]]<br />
* [[Polymorphie|Polymorphie]]<br />
* [[Abstrakte Klasse|Abstrakte Klasse]]<br />
* [[Interface|Interface]]<br />
* [[Java_Basis-Sprachelemente|Java Basis Sprachelemente]], u.a. Bedingung, Schleife etc.<br />
* [[Array|Arrays]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Vererbung|Vererbung]]<br />
** erbt von <br />
** ist ein (gleichbedeutend mit "erbt von"!)<br />
** Super-Klasse<br />
** Sub-Klasse<br />
* [[Polymorphie|Polymorphie]]<br />
** polymorphe Methode<br />
* [[Abstrakte Klasse|Abstrakte Klasse]] (=Klasse mit mind. einer abstrakten Methode)<br />
* abstrakte Methode<br />
* [[Interface|Interface]]<br />
* [[Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* hat-Beziehung<br />
* Assoziation (=kennt-Beziehung)<br />
* Multiplizität<br />
* [[Klasse|Klasse]]<br />
** Objekt (Von einer Klasse kann man mehrere Objekte erzeugen.)<br />
** Attribut<br />
*** public / private<br />
** Konstruktor<br />
* [[Java_Basis-Sprachelemente#Methoden|Methode]]<br />
** Parameter<br />
** lokale Variable<br />
** Rückgabetyp<br />
** public / private<br />
* ContentType (z.B. für Listen kann man den ContentType angeben.)<br />
* [[Interface|Schnittstelle (interface, vgl. ComparableContent)]]<br />
* [[Struktogramm]]<br />
* Anweisung<br />
* Methodenaufruf<br />
* [[Java_Basis-Sprachelemente#Verzweigungen_(if-else)|Bedingung]]<br />
* [[Java_Basis-Sprachelemente#Schleifen_(while,_for,_do-while)|Schleife]]<br />
** Zählschleife (for)<br />
** bedingte Schleife (while)<br />
** mit Schleife ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
* [[Array|Arrays]]<br />
** Index<br />
** Wert<br />
** [[Array#Zweidimensionale_Arrays|zweidimensionales Array]], z.B.: <code> private int[][] einmalEinsTabelle;</code><br />
<br />
=Java-Programmierung mit linearen Datenstrukturen=<br />
'''zum Nachlesen:'''<br />
* [[Queue#Verwendung_von_Queues|Verwendung von Queues]]<br />
* [[Stack#Verwendung_von_Stacks|Verwendung von Stacks]]<br />
* [[List#Standardvorgehen_im_Umgang_mit_Listen|List: Standardvorgehen]]<br />
* [[Array#Ein_Array_mit_einer_for-Schleife_durchlaufen|Array: durchlaufen]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Laufzeit_von_Algorithmen|Laufzeit]]<br />
** O(log(n)): Suchen in einem [[Binärer Suchbaum|Binären Suchbaum]]<br />
** O(n): Suchen in einer unsortierten Liste<br />
** O(n*log(n)): Sortieren mit [[Quicksort|Quicksort]]<br />
** O(n<sup>2</sup>): Sortieren mit [[Bubblesort]], [[Insertionsort]], [[Selectionsort|Selectionsort]]<br />
* <u>statische</u> Datenstruktur (Array): <br/>''Man muss vorher angeben, wie viele Einträge das Array hat.''<br />
* <u>dynamische</u> Datenstrukturen: Stack, List, Queue (und auch BinaryTree, BinarySearchTree, Graph)<br/>''Dynamische Datenstrukturen können während der Laufzeit "wachsen" und "schrumpfen".''<br />
* [[Java_Basis-Sprachelemente#NullPointerException|NullPointerException]]<br />
* [[Queue|Queue]]: Schlange (vorne - hinten)<br />
** vorderstes Element: <code>pQueue.front()</code><br />
** anhängen: <code>pQueue.enqueue(...)</code> <br />
** vorderstes Element entfernen: <code>pQueue.dequeue()</code><br />
** ist leer: <code>pQueue.isEmpty()</code><br />
** Hilfs-Queue: z.B. um einen Queue zu durchlaufen, ohne ihn zu zustören<br />
* [[Stack|Stack]]: Stapel (oben)<br />
** oberstes Element: <code>pStack.top()</code><br />
** oben drauflegen: <code>pStack.push(...)</code> <br />
** oberstes Element entfernen: <code>pStack.pop()</code><br />
** ist leer: <code>pStack.isEmpty()</code><br />
** Hilfs-Stack: z.B. um einen Stack zu durchlaufen, ohne ihn zu zustören<br />
* [[List|List]]: Liste.<br/>''Listen kann man einfach durchlaufen und irgendwo einfügen.''<br />
** anhängen: <code>pList.append(...)</code><br />
** einfügen vor dem aktuellen Element: <code>pList.insert(...);</code><br />
* [[Array|Array]]: <br/>''statische Datenstruktur - man muss die Anzahl der Elemente vorher festlegen.''<br />
* durchlaufen (Liste, Array)<br />
** ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
** eine Liste durchlaufen: <code>for(pList.toFirst(); pList.hasAccess(); pList.next())</code><br />
* aktuelles Element:<br />
** Array: <code>array[i];</code><br />
** Liste: <code>pList.getContent();</code><br />
* erzeugen<br />
** erzeugen eines Objektes: <code>Person p = '''new''' Person("Mustermann", "Max");</code><br />
** erzeugen einer Liste: <code>List<Person> ergebnisListe = '''new''' List<>();</code><br />
** erzeugen eines Arrays: <br/>z.B. <code>Person[] einwohner = '''new''' int[1000];</code><br/>''Vorsicht! In jedem der 1000 Werte steht <code>null</code>!''<br />
** erzeugen eines zweidimensionalen Arrays: <code>int[][] einmalEinsTabelle = new int[10][10];</code><br />
* Schleife<br />
** Schleife verlassen: <code>break;</code><br />
** Schleife beim nächsten Element fortsetzen: <code>continue;</code><br />
* Methode verlassen <code>return;</code><br />
* zurückgeben: <code>return ergebnis;</code><br />
* ausgeben: <code>System.out.println("Hallo");</code><br />
<br />
=Sortierverfahren=<br />
* [[Bubblesort]] <u>nur für Arrays!</u>, Laufzeit O(n<sup>2</sup>)<br />
* [[Insertionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* [[Selectionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* nur LK: [[Quicksort]] für Listen, Laufzeit O(n*log(n)) im Average Case<br />
* Sortieren mit einem [[Binärer Suchbaum|Binären Suchbaum ]]<br/>- Der Reihe nach in den Binären Suchbaum einfügen<br/>- Inorder-Traversierung<br/>Laufzeit O(n*log(n)) im Average Case<br />
<br />
=Binärbäume und binäre Suchbäume=<br />
* Rahmenmethode<br />
* rekursive Methode<br />
* Abbruchbedingung<br />
* ''Wurzelbehandlung''<br />
* ''Sachlogik''<br />
* rekursive Aufrufe<br />
* Traversierung<br />
* Preorder<br />
* Inorder (=im Suchbaum: Sortierte Ausgabe!)<br />
* Levelorder (nur LK)<br />
* Baumliste für Levelorder (nur LK)<br />
* ComparableContent<br />
* implementiert die Schnittstelle (ComparableContent)<br />
* ''Dummy'': zum Suchen in Suchbäumen.<br />
<br />
=Automaten und Grammatiken=<br />
'''zum Nachlesen:'''<br/><br />
[https://sibiwiki.de/wiki/index.php?title=Kategorie:Endliche_Automaten Kategorie endliche Automaten]<br />
<br/>''Da gibt es Links zu allen Unterüberschriften.''<br />
==endliche Automaten==<br />
* [[Deterministischer Endlicher Automat|Deterministischer endlicher Automat (DEA)]]<br />
** A, Z, d, Q<sub>0</sub>, E: ''allen Zuhörern doofen Quatsch erzählen''<br />
* Der DEA '''erkennt''' eine reguläre Sprache<br />
* Der DEA '''überprüft''' ein Wort, ob es zur Sprache gehört.<br />
* [[Nicht-deterministischer endlicher Automaten|Nicht-deterministischer endlicher Automat (NEA)]]<br />
** ''"es gibt einen Weg"''<br />
* Zustand<br />
**Anfangszustand<br />
**Endzustände<br />
* Übergang<br />
* Alphabet<br />
* Zustands-Übergangs-Graph<br />
* Zustands-Übergangs-Tabelle<br />
* Zustandsfolge<br />
** für einen NEA ggf. mit geschweifter Klammer mehrere Zustände zusammenfassen.<br />
* Senke (=ein Zustand, aus dem es keinen Ausweg mehr gibt)<br />
* [[Potenzmengenkonstruktion|Potenzmengenkonstruktion]]<br />
** Potenzmenge (=eine Menge von Zuständen)<br />
<br />
==[[Reguläre Grammatik|reguläre Grammatik]]==<br />
* G = {N, T, S, P} ''Nerds testen Sonys Playstation''<br />
* linkslineare Grammatik: Nicht-Terminal links<br />
* rechtslineare Grammatik: Nicht-Terminal rechts<br />
** <i>linkslineare und rechtslineare Regeln nicht mischen!!!<br/>z.B.: <code>S → aS | Sb</code><br/>ist nicht regulär!!!</i><br />
* Terminal-Symbol<br />
* Nicht-Terminal-Symbol<br />
**Startsymbol<br />
* Produktionsregeln<br />
* Produktion eines Wortes<br />
* die RG erzeugt eine (reguläre) Sprache<br />
<br />
==[[Kellerautomat|Kellerautomaten (nur LK)]]==<br />
* Keller-Alphabet<br />
* Keller-Zeichen<br />
* Epsilon (ε): Um den Endzustand zu erreichen, darf man das Zeichen ε (="nichts") schreiben.<br />
<br />
==[[Kontextfreie_Grammatik|kontextfreie Grammatik (nur LK)]]==<br />
* lässt sich durch Kellerautomaten prüfen<br />
<br />
==Parser==<br />
* [[Parser|Parser für DEA]]<br />
* [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomaten (nur LK)]]<br />
** Keller (=<code>Stack</code>)<br />
<br />
=[[Graph|Graph (nur LK!)]]=<br />
* Knoten<br />
* Kante<br />
* markieren (Knoten oder Kante)<br />
* Markierung aufheben<br />
* Gewicht<br />
* Traversierung (d.h. Breitendurchlauf oder Tiefendurchlauf)<br />
* [[Graph#Tiefendurchlauf|Tiefendurchlauf]]<br />
** rekursiv<br />
* [[Graph#Breitendurchlauf|Breitendurchlauf]]<br />
** Knotenliste<br />
* [[Dijkstra-Algorithmus|Dijkstra-Algorithmus]]<br />
* rote Liste (für Dijkstra-Algo)<br />
* gelbe Liste (für Dijkstra-Algo)<br />
<br />
=[[Datenschutz|Datenschutz]]=<br />
Schutz von Angaben, aus denen man einen bestimmten Menschen erkennen kann oder die einem bestimmten Menschen zugeordnet werden können. <br />
<br />
'''Prinzipien des Datenschutzes:'''<br />
* <u>Verbot mit Erlaubnisvorbehalt</u><br />
* Datenminimierung<br />
* Zweckbindung<br />
* Transparenz<br />
* <u>Erforderlichkeit</u><br />
<br />
=[[Backtracking|Backtracking (nur LK!)]]=<br />
* Stufe<br />
* Teillösungsschritt<br />
* Abbruchbedingung<br />
** Lösung erreicht<br />
** Lösung nicht mehr erreichbar<br />
** maximale Stufenzahl überschritten<br />
* rückgängig machen</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Diffie-Hellmann-Schl%C3%BCsseltausch&diff=3687Diffie-Hellmann-Schlüsseltausch2024-03-03T17:48:50Z<p>Akaibel: /* Taschenrechner / Online-Rechner */</p>
<hr />
<div>[[Kategorie:Kryptographie]]<br />
[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<br />
Der Diffie-Hellmann-Schlüsseltausch ermöglicht es zwei Kommunikationspartnern einen geheimen Schlüssel zu vereinbaren.<br />
<br />
Das Besondere dabei ist, dass mögliche Angreifer die gesamte Kommunikation mithören können, aber trotzdem nicht an den Schlüssel kommen.<br />
<br />
=Verfahren=<br />
Die beiden Kommunikationspartner (Alice und Bob) einigen sich auf eine Primzahl '''p''' und eine [http://de.wikipedia.org/wiki/Primitivwurzel Primitivwurzel] '''g''' modulo '''p'''.<br />
<br />
Diese beiden Zahlen können öffentlich sein, d.h. auch mögliche Angreifer (Eve) dürfen sie erfahren.<br />
<br />
Jetzt läuft das Verfahren wie folgt ab:<br />
[[File:Diffie-Hellman-Schlüsselaustausch.png|thumb|a,b,K sind privat; g,p,A,B sind öffentlich|400px]]<br />
<br />
<br />
{| class="wikitable"<br />
|-<br />
! Alice !! Kommunikation (belauscht von Eve!) !!<br />
Bob<br />
|-<br />
| --- || Alice und Bob einigen sich auf '''p''' und '''g''' || ---<br />
|-<br />
| Alice denkt sich eine geheime Zahl '''a''' aus.<br>(a muss kleiner als p sein.) || --- || Bob denkt sich eine geheime Primzahl '''b''' aus.<br>(b muss kleiner als p sein.)<br />
|-<br />
| Alice berechnet '''A''' = g<sup>a</sup> mod p || --- || Bob berechnet '''B''' = g<sup>b</sup> mod p<br />
|-<br />
| --- || Alice schickt '''A''' an Bob. <br>Bob schickt '''B''' an Alice.|| ---<br />
|-<br />
| Alice berechnet '''K''' = B<sup>a</sup> mod p<br>und hat den Schlüssel '''K'''! || --- || Bob berechnet '''K''' = A<sup>b</sup> mod p<br>und hat ebenfalls den Schlüssel '''K'''!<br />
|-<br />
| --- || Eve kann aus p, g, A und B <br>den Schlüssel '''K''' <u>nicht</u> berechnen! || ---<br />
|}<br />
<br />
=Beispiel=<br />
{| class="wikitable"<br />
|-<br />
! Alice !! Kommunikation (belauscht von Eve!) !!<br />
Bob<br />
|-<br />
| --- || Alice und Bob einigen sich auf '''p = 13''' und '''g = 2''' || ---<br />
|-<br />
| Alice denkt sich eine geheime Zahl aus: '''a = 5'''.<br>(a muss kleiner als p sein) || --- || Bob denkt sich eine geheime Zahl aus: '''b = 8'''.<br>(b muss kleiner als p sein.)<br />
|-<br />
| Alice berechnet '''A''' = g<sup>a</sup> mod p <br> '''A''' = 2<sup>5</sup> mod 13 = 32 mod 13 = '''6'''|| --- || Bob berechnet '''B''' = g<sup>b</sup> mod p <br> '''B''' = 2<sup>8</sup> mod 13 = 256 mod 13 = '''9'''<br />
|-<br />
| --- || Alice schickt '''A = 6''' an Bob. <br>Bob schickt '''B = 9''' an Alice.|| ---<br />
|-<br />
| Alice berechnet '''K''' = B<sup>a</sup> mod p<br>'''K''' = 9<sup>5</sup> mod 13 = 59049 mod 13 = '''3'''<br>und hat den Schlüssel '''K = 3'''! || --- || Bob berechnet '''K''' = A<sup>b</sup> mod p<br>'''K''' = 6^8 mod 13 = 1679616 mod 13 = '''3''' <br>und hat den Schlüssel '''K = 3'''!<br />
|-<br />
| --- || Eve kann aus p = 13, g = 2, A = 6 und B = 9 <br>den Schlüssel '''K''' <u>nicht</u> berechnen! || ---<br />
|}<br />
<br />
== Taschenrechner / Online-Rechner ==<br />
Mit dem Casio-Taschenrechner kommt man am einfachsten so zum Modulo-Rechnen:<br />
* <code>OPTN -> F6 -> F4 -> F6 -> F4</code><br />
* Eingabe dann z.B.: <code>MOD(27,6)</code><br/>''Dann müsste 3 rauskommen.''<br />
<br />
Der Taschenrechner hat allerdings Probleme, modulo für große Zahlen zu berechnen.<br />
<br />
'''Das kann man VIEL BESSER online machen!'''<br />
<br />
Folgende Online-Rechner sind geeignet:<br />
<br />
* '''[http://web2.0rechner.de/ web2.0rechner.de]'''.<br/>''(Modulo ist '''<font size="4"><code>2nd</code> <code>&divide;</code></font> ''')''<br />
<br />
* '''[https://www.omnicalculator.com/math/power-modulo PowerMod-Calculator]'''<br/>Den braucht man, wenn auch der web2.0rechner überfordert ist, z.B. für 123456789^123456789 mod 987654321<br/>allgemein: Basis '''^''' Exponent '''mod''' Modulo <br/><br />
<br />
* '''[https://services.informatik.hs-mannheim.de/KryptoLern/primitive_wurzel.php?p=29&start=8&cnt=12&x= Primitiv-Wurzel-Rechner]'''<br/>Zum Suchen von Primitivwurzeln.<br />
<br />
=Warum funktioniert das?=<br />
* Alices Berechnug für K ist: K = B<sup>a</sup> mod p = (g<sup>b</sup>)<sup>a</sup> mod p = g<sup>ab</sup> mod p<br />
* Bobs Berechnung für K ist: K = A<sup>b</sup> mod p = (g<sup>a</sup>)<sup>b</sup> mod p = g<sup>ba</sup> mod p = g<sup>ab</sup> mod p<br />
* Also haben Alice und Bob den gleichen Schlüssel!<br />
<br />
==Allgemeine Anforderungen an die Verschlüsselungsfunktion==<br />
Allgemein gesprochen muss die Verschlüsselungsfunktion '''kommutativ''' sein, d.h. f<sub>a</sub>(f<sub>b</sub>(x)) = f<sub>b</sub>(f<sub>a</sub>(x)).<br />
<br />
Das ist wichtig, damit Alice und Bob den gleichen Schlüssel erhalten!<br />
<br />
Die Exponentialfunktion modulo p ist kommutativ, wie oben gezeigt.<br />
<br />
<br />
Außerdem muss die Verschlüsselungsfunktion eine '''Einwegfunktion''' sein, d.h. die Umkehrung der Rechnung muss unmöglich oder mindestens sehr zeitintensiv sein.<br />
<br />
Das ist wichtig, damit man nicht aus den öffentlichen Teilen der Kommunikation die privaten Werte von Alice und Bob errechnen kann.<br />
<br />
Dass die Exponentialfunktion modulo p eine Einwegfunktion ist, ist mathematisch bewiesen; siehe [[Diffie-Hellmann-Schlüsseltausch#Warum ist das sicher?|Warum ist das sicher?]]<br />
<br />
=Warum ist das sicher?=<br />
* Um aus p, g, A und B den geheimen Schlüssel K (oder die geheimen Primzahlen a und b) zu ermitteln, muss Alice den sog. ''"diskreten Logarithmus"'' bilden <br>d.h. sie muss eine Zahl '''x''' finden, so dass g<sup>'''x'''</sup> mod p = A.<br />
* Das erfordert für große Zahlen eine sehr lange Rechendauer; man kann sogar angeben, wie groß die Zahlen sein müssen, damit Eve mit aller Rechenleistung der Welt 10 Jahre, 100 Jahre oder 1000 Jahre braucht...<br />
<br />
Mehr Details zur Sicherheit bei [http://de.wikipedia.org/wiki/Diffie-Hellman-Schlüsselaustausch#Diffie-Hellman-Problem wikipedia]<br />
<br />
=Praxis=<br />
In der Praxis nimmt man für p, g, a und b Zahlen mit mehreren hundert Stellen.<br />
<br />
=Man-In-The-Middle-Attack=<br />
[[File:Diffie-Hellman-Man-In-The-Middle-Attack.png|thumb|Man-In-The-Middle-Attack auf Diffie-Hellman|300px]]<br />
Der Diffie-Hellmann-Schlüsseltausch ist anfällig für die Man-In-The-Middle-Attack.<br />
<br />
D.h. wenn sich Mallory unbemerkt in den Schlüsselaustausch "einklinkt", indem sie Alice vorspiegelt, sie sei Bob und Bob vorspiegelt, sie sei Alice, dann kann Mallory mit jeder Seite einen Schlüssel vereinbaren - und Alice und Bob denken, sie hätten miteinander einen Schlüssel vereinbart. (Dabei haben beide jeweils nur einen Schlüssel mit dem bösen Mallory vereinbart!)<br />
<br />
Details dazu bei [http://de.wikipedia.org/wiki/Diffie-Hellman-Schlüsselaustausch#Man-in-the-Middle-Angriff wikipedia]<br />
<br />
=Veranschaulichung: Mischen von Farben=<br />
Das Diffie-Hellman-Verfahren wird häufig durch ein Farbmisch-Verfahren veranschaulicht.<br />
<br />
[[File:Diffie-Hellman-Farben.png|left|Man-In-The-Middle-Attack auf Diffie-Hellman|399px]]</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Diffie-Hellmann-Schl%C3%BCsseltausch&diff=3686Diffie-Hellmann-Schlüsseltausch2024-03-03T17:48:14Z<p>Akaibel: /* Taschenrechner / Online-Rechner */</p>
<hr />
<div>[[Kategorie:Kryptographie]]<br />
[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<br />
Der Diffie-Hellmann-Schlüsseltausch ermöglicht es zwei Kommunikationspartnern einen geheimen Schlüssel zu vereinbaren.<br />
<br />
Das Besondere dabei ist, dass mögliche Angreifer die gesamte Kommunikation mithören können, aber trotzdem nicht an den Schlüssel kommen.<br />
<br />
=Verfahren=<br />
Die beiden Kommunikationspartner (Alice und Bob) einigen sich auf eine Primzahl '''p''' und eine [http://de.wikipedia.org/wiki/Primitivwurzel Primitivwurzel] '''g''' modulo '''p'''.<br />
<br />
Diese beiden Zahlen können öffentlich sein, d.h. auch mögliche Angreifer (Eve) dürfen sie erfahren.<br />
<br />
Jetzt läuft das Verfahren wie folgt ab:<br />
[[File:Diffie-Hellman-Schlüsselaustausch.png|thumb|a,b,K sind privat; g,p,A,B sind öffentlich|400px]]<br />
<br />
<br />
{| class="wikitable"<br />
|-<br />
! Alice !! Kommunikation (belauscht von Eve!) !!<br />
Bob<br />
|-<br />
| --- || Alice und Bob einigen sich auf '''p''' und '''g''' || ---<br />
|-<br />
| Alice denkt sich eine geheime Zahl '''a''' aus.<br>(a muss kleiner als p sein.) || --- || Bob denkt sich eine geheime Primzahl '''b''' aus.<br>(b muss kleiner als p sein.)<br />
|-<br />
| Alice berechnet '''A''' = g<sup>a</sup> mod p || --- || Bob berechnet '''B''' = g<sup>b</sup> mod p<br />
|-<br />
| --- || Alice schickt '''A''' an Bob. <br>Bob schickt '''B''' an Alice.|| ---<br />
|-<br />
| Alice berechnet '''K''' = B<sup>a</sup> mod p<br>und hat den Schlüssel '''K'''! || --- || Bob berechnet '''K''' = A<sup>b</sup> mod p<br>und hat ebenfalls den Schlüssel '''K'''!<br />
|-<br />
| --- || Eve kann aus p, g, A und B <br>den Schlüssel '''K''' <u>nicht</u> berechnen! || ---<br />
|}<br />
<br />
=Beispiel=<br />
{| class="wikitable"<br />
|-<br />
! Alice !! Kommunikation (belauscht von Eve!) !!<br />
Bob<br />
|-<br />
| --- || Alice und Bob einigen sich auf '''p = 13''' und '''g = 2''' || ---<br />
|-<br />
| Alice denkt sich eine geheime Zahl aus: '''a = 5'''.<br>(a muss kleiner als p sein) || --- || Bob denkt sich eine geheime Zahl aus: '''b = 8'''.<br>(b muss kleiner als p sein.)<br />
|-<br />
| Alice berechnet '''A''' = g<sup>a</sup> mod p <br> '''A''' = 2<sup>5</sup> mod 13 = 32 mod 13 = '''6'''|| --- || Bob berechnet '''B''' = g<sup>b</sup> mod p <br> '''B''' = 2<sup>8</sup> mod 13 = 256 mod 13 = '''9'''<br />
|-<br />
| --- || Alice schickt '''A = 6''' an Bob. <br>Bob schickt '''B = 9''' an Alice.|| ---<br />
|-<br />
| Alice berechnet '''K''' = B<sup>a</sup> mod p<br>'''K''' = 9<sup>5</sup> mod 13 = 59049 mod 13 = '''3'''<br>und hat den Schlüssel '''K = 3'''! || --- || Bob berechnet '''K''' = A<sup>b</sup> mod p<br>'''K''' = 6^8 mod 13 = 1679616 mod 13 = '''3''' <br>und hat den Schlüssel '''K = 3'''!<br />
|-<br />
| --- || Eve kann aus p = 13, g = 2, A = 6 und B = 9 <br>den Schlüssel '''K''' <u>nicht</u> berechnen! || ---<br />
|}<br />
<br />
== Taschenrechner / Online-Rechner ==<br />
Mit dem Casio-Taschenrechner kommt man am einfachsten so zum Modulo-Rechnen:<br />
* <code>OPTN -> F6 -> F4 -> F6 -> F4</code><br />
* Eingabe dann z.B.: <code>MOD(27,6)</code><br/>''Dann müsste 3 rauskommen.''<br />
<br />
Der Taschenrechner hat allerdings Probleme, modulo für große Zahlen zu berechnen.<br />
<br />
'''Das kann man VIEL BESSER online machen!'''<br />
<br />
Folgende Online-Rechner sind geeignet:<br />
<br />
* '''[http://web2.0rechner.de/ web2.0rechner.de]'''.<br/>''(Modulo ist '''<font size="4"><code>2nd</code> <code>&divide;</code></font> ''')''<br />
<br />
* '''[https://www.omnicalculator.com/math/power-modulo]'''<br/>Den braucht man, wenn auch der web2.0rechner überfordert ist, z.B. für 123456789^123456789 mod 987654321<br/>allgemein: Basis '''^''' Exponent '''mod''' Modulo <br/><br />
<br />
* '''[https://services.informatik.hs-mannheim.de/KryptoLern/primitive_wurzel.php?p=29&start=8&cnt=12&x= Primitiv-Wurzel-Rechner]'''<br/>Zum Suchen von Primitivwurzeln.<br />
<br />
=Warum funktioniert das?=<br />
* Alices Berechnug für K ist: K = B<sup>a</sup> mod p = (g<sup>b</sup>)<sup>a</sup> mod p = g<sup>ab</sup> mod p<br />
* Bobs Berechnung für K ist: K = A<sup>b</sup> mod p = (g<sup>a</sup>)<sup>b</sup> mod p = g<sup>ba</sup> mod p = g<sup>ab</sup> mod p<br />
* Also haben Alice und Bob den gleichen Schlüssel!<br />
<br />
==Allgemeine Anforderungen an die Verschlüsselungsfunktion==<br />
Allgemein gesprochen muss die Verschlüsselungsfunktion '''kommutativ''' sein, d.h. f<sub>a</sub>(f<sub>b</sub>(x)) = f<sub>b</sub>(f<sub>a</sub>(x)).<br />
<br />
Das ist wichtig, damit Alice und Bob den gleichen Schlüssel erhalten!<br />
<br />
Die Exponentialfunktion modulo p ist kommutativ, wie oben gezeigt.<br />
<br />
<br />
Außerdem muss die Verschlüsselungsfunktion eine '''Einwegfunktion''' sein, d.h. die Umkehrung der Rechnung muss unmöglich oder mindestens sehr zeitintensiv sein.<br />
<br />
Das ist wichtig, damit man nicht aus den öffentlichen Teilen der Kommunikation die privaten Werte von Alice und Bob errechnen kann.<br />
<br />
Dass die Exponentialfunktion modulo p eine Einwegfunktion ist, ist mathematisch bewiesen; siehe [[Diffie-Hellmann-Schlüsseltausch#Warum ist das sicher?|Warum ist das sicher?]]<br />
<br />
=Warum ist das sicher?=<br />
* Um aus p, g, A und B den geheimen Schlüssel K (oder die geheimen Primzahlen a und b) zu ermitteln, muss Alice den sog. ''"diskreten Logarithmus"'' bilden <br>d.h. sie muss eine Zahl '''x''' finden, so dass g<sup>'''x'''</sup> mod p = A.<br />
* Das erfordert für große Zahlen eine sehr lange Rechendauer; man kann sogar angeben, wie groß die Zahlen sein müssen, damit Eve mit aller Rechenleistung der Welt 10 Jahre, 100 Jahre oder 1000 Jahre braucht...<br />
<br />
Mehr Details zur Sicherheit bei [http://de.wikipedia.org/wiki/Diffie-Hellman-Schlüsselaustausch#Diffie-Hellman-Problem wikipedia]<br />
<br />
=Praxis=<br />
In der Praxis nimmt man für p, g, a und b Zahlen mit mehreren hundert Stellen.<br />
<br />
=Man-In-The-Middle-Attack=<br />
[[File:Diffie-Hellman-Man-In-The-Middle-Attack.png|thumb|Man-In-The-Middle-Attack auf Diffie-Hellman|300px]]<br />
Der Diffie-Hellmann-Schlüsseltausch ist anfällig für die Man-In-The-Middle-Attack.<br />
<br />
D.h. wenn sich Mallory unbemerkt in den Schlüsselaustausch "einklinkt", indem sie Alice vorspiegelt, sie sei Bob und Bob vorspiegelt, sie sei Alice, dann kann Mallory mit jeder Seite einen Schlüssel vereinbaren - und Alice und Bob denken, sie hätten miteinander einen Schlüssel vereinbart. (Dabei haben beide jeweils nur einen Schlüssel mit dem bösen Mallory vereinbart!)<br />
<br />
Details dazu bei [http://de.wikipedia.org/wiki/Diffie-Hellman-Schlüsselaustausch#Man-in-the-Middle-Angriff wikipedia]<br />
<br />
=Veranschaulichung: Mischen von Farben=<br />
Das Diffie-Hellman-Verfahren wird häufig durch ein Farbmisch-Verfahren veranschaulicht.<br />
<br />
[[File:Diffie-Hellman-Farben.png|left|Man-In-The-Middle-Attack auf Diffie-Hellman|399px]]</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Vigenere-Verschl%C3%BCsselung&diff=3685Vigenere-Verschlüsselung2024-02-29T15:41:21Z<p>Akaibel: </p>
<hr />
<div>[[Kategorie:Kryptographie]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
[[File:Vigenere-Beispiel.png|thumb|Quelle: [http://commons.wikimedia.org/wiki/File:Vigenere-Beispiel.png Wikimedia] |727px]]<br />
<br />
Das Vigenere-Verfahren ist eine '''polyalphabetische''' Verschlüsselung, die die [[Caesar-Verschlüsselung]] erheblich verbessert.<br />
Es wurde im 16. Jahrhundert entwickelt und galt lange als sicher; erst 1854 wurde der sog. '''Kasiski-Test''' veröffentlicht, mit dem man das Vigenere-Verfahren für kurze Schlüssellängen bei ausreichender Textmenge knacken konnte. (Bei langen Schlüsseln, am besten so lang wie der Text selber, ist das Vigenere-Verfahren auch heute noch sicher.)<br />
<br />
=Verfahren=<br />
==Verschlüsselung==<br />
* Unter den Klartext wird der Schlüssel geschrieben. Dabei wird der Schlüssel ggf. mehrfach wiederholt.<br />
* Jetzt schaut man für jeden Buchstaben in der Tabelle nach (s. Grafik).<br />
==Entschlüsselung==<br />
* Man schreibt den Schlüssel unter den Geheimtext, dabei wiederholt man ggf. den Schlüssel.<br />
* Jetzt geht man von dem Buchstaben des Schlüssels in der Tabelle nach rechts, bis man auf den geheimen Buchstaben trifft.<br />
* Jetzt geht man nach oben und erhält den Buchstaben des Klartextes.<br />
<br />
==Implementierung==<br />
<br />
<code>public class Vigenere {<br />
'''private static char[][] vigenereQuadrat;'''<br />
<br />
'''public static void vigenereQuadratErstellen(){'''<br />
if(vigenereQuadrat == null){<br />
vigenereQuadrat = new char['z'+1]['z'+1];<br />
int zahl = 0;<br />
for (char i = 'a'; i <= 'z'; i++) {<br />
for(char j='a'; j <= 'z'; j++){<br />
vigenereQuadrat[i][j] = j;<br />
vigenereQuadrat[i][j] += zahl;<br />
if(vigenereQuadrat[i][j] > 'z'){<br />
vigenereQuadrat[i][j] -= 26;<br />
}<br />
}<br />
zahl++;<br />
}<br />
}<br />
}<br />
<br />
public static void quadratDrucken(){<br />
System.out.println("*** Das Vigenere-Quadrat ***");<br />
if(vigenereQuadrat == null){<br />
vigenereQuadratErstellen();<br />
}<br />
for (char i = 'a'; i <= 'z'; i++) {<br />
for(char j='a'; j <= 'z'; j++){<br />
System.out.print(vigenereQuadrat[i][j]);<br />
}<br />
System.out.println();<br />
}<br />
}<br />
<br />
'''public static String entschluesseln(String pText, String pSchluessel) {'''<br />
vigenereQuadratErstellen();<br />
// alles auf Kleinbuchstaben bringen!<br />
pText = pText.toLowerCase();<br />
String ergebnis = "";<br />
int laengeSchluessel = pSchluessel.length();<br />
for(int i=0; i<pText.length(); i++){<br />
char verschluesseltBuchstabe = pText.charAt(i);<br />
int indexSchluessel = i%laengeSchluessel;<br />
int schluesselBuchstabe = pSchluessel.charAt(indexSchluessel);<br />
// den richtigen Buchstaben suchen!<br />
char[] zeile = vigenereQuadrat[schluesselBuchstabe];<br />
char textBuchstabe = 'a';<br />
while(zeile[textBuchstabe] != verschluesseltBuchstabe){<br />
textBuchstabe++;<br />
}<br />
ergebnis += textBuchstabe;<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''private static String verschluesseln(String pText, String pSchluessel) {'''<br />
vigenereQuadratErstellen();<br />
// Leerzeichen rausnehmen!<br />
pText = pText.replaceAll(" ", "");<br />
// alles auf Kleinbuchstaben bringen!<br />
pText = pText.toLowerCase();<br />
System.out.println("Nachricht ohne Leerzeichen und alles klein: "+pText);<br />
String ergebnis = "";<br />
int laengeSchluessel = pSchluessel.length();<br />
for(int i=0; i<pText.length(); i++){<br />
char textBuchstabe = pText.charAt(i);<br />
int indexSchluessel = i%laengeSchluessel;<br />
char schluesselBuchstabe = pSchluessel.charAt(indexSchluessel);<br />
char verschluesseltBuchstabe = vigenereQuadrat[textBuchstabe][schluesselBuchstabe];<br />
ergebnis += verschluesseltBuchstabe;<br />
}<br />
return ergebnis;<br />
}<br />
<br />
public static void main(String[] args) {<br />
//quadratDrucken();<br />
String schluessel = "test";<br />
System.out.println("Schluessel: "+schluessel);<br />
String nachricht = "Hallo zusammen wie gehts";<br />
System.out.println("Nachricht: "+nachricht);<br />
String verschluesselt = verschluesseln(nachricht, schluessel);<br />
System.out.println("verschluesselt: "+verschluesselt);<br />
String entschluesselt = entschluesseln(verschluesselt, schluessel);<br />
System.out.println("entschluesselt: "+entschluesselt);<br />
}<br />
}</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik-Abitur-2024&diff=3684Informatik-Abitur-20242024-02-23T16:09:51Z<p>Akaibel: /* Vorabi-Klausur */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird alles gesammelt, was für das Abitur 2024 (LK + GK) wichtig ist.<br />
<br />
=Vorgaben für das Zentralabitur 2024=<br />
* '''[[Datei:IF-Abi-2024-Vorgaben.pdf|Vorgaben für das Informatik-Abitur 2024]]'''<br />
* Wesentlich sind die Tabellen auf S. 4 (GK) und S. 5 (LK).<br />
<br />
=Fachbegriffe=<br />
In der Vorabi-Klausur und im Abitur wird auf zuverlässige Anwendung von Fachbegriffen geachtet! <br />
<br />
Fachbegriffe erleichtern das Schreiben, weil man viel schneller und genauer schreiben kann!<br />
<br />
'''[[Informatik Fachbegriffe]]'''<br />
<br />
==Vorabi-Klausur==<br />
<font color='red'><br />
* Im LK gibt es im Vorabi 3 Aufgaben aus den drei unten genannten Bereichen. <br />
* Im GK gibt es nur 2 Aufgaben aus den Bereichen Datenbanken und Automaten. <br />
** Die Automaten-Aufgabe enthält eine Teilaufgabe zum Umgang mit linearen Datenstrukturen; wie unten angegeben.<br />
</font><br />
<br />
===a) Datenbanken und Datenschutz===<br />
# [[Entity-Relationship-Modell]] <br />
# [[relationales Datenmodell]]<br />
# [[SQL]]<br />
## schreiben<br />
## analysieren<br />
# <font color="red">im GK nicht im Vorabi: </font>[[Normalisierung]]<br />
# [[Java-SQL|mit Java auf SQL zugreifen]]<br />
# Grundprinzipien des [[Datenschutz|Datenschutzes]], und dabei vor allem:<br />
## Verbot mit Erlaubnisvorbehalt<br />
## Erforderlichkeit<br />
<br />
===b) Automaten und Grammatiken:===<br />
# [[Deterministischer Endlicher Automat]] (DEA)<br />
# [[reguläre Grammatik]] (linkslinear bzw. rechtslinear): Anforderungen kennen!<br />
# DEA/NEA in reguläre Grammatik umwandeln<br />
# reguläre Grammatik in NEA umwandeln<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Potenzmengenkonstruktion]] (um NEA in DEA zu verwandeln)<br />
# Grenzen von DEA: Darf nur endlich viele Zustände haben! Kann nicht zählen!<br />
# Durchlauf durch [[List|Listen]], um etwas zu suchen oder zu berechnen: <br />
## am einfachsten mit einer for-Schleife!<br />
## völlig ausreichend ist es, wenn man folgendes kann: [[List#Anzahl_aus_Geburtsjahr|Anzahl Personen aus Geburtsjahr]]<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Parser]] für DEA programmieren: Am einfachsten mit if-else<br />
# '''nur LK:''' [[Kellerautomat]] und Parser für Kellerautomat<br />
# '''nur LK:''' [[Kontextfreie Grammatik]] (Anforderungen kennen!)<br />
# '''nur LK:''' [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomat]]<br />
<br />
===<font color='red'>Im GK NICHT im Vorabi: </font>c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung===<br />
# Erstellen / Erweitern von [[Klassen-_und_Implementationsdiagramm|Implementationsdiagrammen]]<br />
# Anwendung von linearen Datenstrukturen in der Programmierung: [[List]], [[Stack]], [[Queue]]<br />
# <font color="red">NEU: </font>Einen [[Algorithmus entwickeln und implementieren]].<br />
# [[Vererbung]] und [[Polymorphie]] <strike>und [[Interface]]</strike><br />
# [[Array|Arrays]]<br />
## eindimensionale Arrays und zweidimensionale Arrays, die Objekte enthalten.<br />
## Arrays, die Objekte enthalten.<br />
## Datenbanken: <i><code>String[][] data = queryResult.getData()</code> und dann das 2-dim Array <code>data</code> mit einer Schleife auswerten.</i><br />
# <s><font color="red">NEU: </font>[[Rekursion]]: <br/>Man muss nur eine rekursive Methode analysieren können, d.h. nicht selber schreiben!</s><br />
# <font color="red">NEU: </font>[[Wrapper-Klassen]]<br />
# <s>Struktogramme für Programmabläufe verstehen/erweitern.</s></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik-Abitur-2024&diff=3683Informatik-Abitur-20242024-02-23T16:06:17Z<p>Akaibel: /* Vorabi-Klausur */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird alles gesammelt, was für das Abitur 2024 (LK + GK) wichtig ist.<br />
<br />
=Vorgaben für das Zentralabitur 2024=<br />
* '''[[Datei:IF-Abi-2024-Vorgaben.pdf|Vorgaben für das Informatik-Abitur 2024]]'''<br />
* Wesentlich sind die Tabellen auf S. 4 (GK) und S. 5 (LK).<br />
<br />
=Fachbegriffe=<br />
In der Vorabi-Klausur und im Abitur wird auf zuverlässige Anwendung von Fachbegriffen geachtet! <br />
<br />
Fachbegriffe erleichtern das Schreiben, weil man viel schneller und genauer schreiben kann!<br />
<br />
'''[[Informatik Fachbegriffe]]'''<br />
<br />
==Vorabi-Klausur==<br />
<font color='red'><br />
* Im LK gibt es im Vorabi 3 Aufgaben aus den drei unten genannten Bereichen. <br />
* Im GK gibt es nur 2 Aufgaben aus den Bereichen Datenbanken und Automaten. <br />
** Die Automaten-Aufgabe enthält eine Teilaufgabe zum Umgang mit linearen Datenstrukturen; wie unten angegeben.<br />
</font><br />
<br />
===a) Datenbanken===<br />
# [[Entity-Relationship-Modell]] <br />
# [[relationales Datenmodell]]<br />
# [[SQL]]<br />
# [[Normalisierung]]<br />
# [[Java-SQL|mit Java auf SQL zugreifen]]<br />
# Grundprinzipien des [[Datenschutz|Datenschutzes]], und dabei vor allem:<br />
## Verbot mit Erlaubnisvorbehalt<br />
## Erforderlichkeit<br />
<br />
===b) Automaten und Grammatiken:===<br />
# [[Deterministischer Endlicher Automat]] (DEA)<br />
# [[reguläre Grammatik]] (linkslinear bzw. rechtslinear): Anforderungen kennen!<br />
# DEA/NEA in reguläre Grammatik umwandeln<br />
# reguläre Grammatik in NEA umwandeln<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Potenzmengenkonstruktion]] (um NEA in DEA zu verwandeln)<br />
# Grenzen von DEA: Darf nur endlich viele Zustände haben! Kann nicht zählen!<br />
# Durchlauf durch [[List|Listen]], um etwas zu suchen oder zu berechnen: <br />
## am einfachsten mit einer for-Schleife!<br />
## völlig ausreichend ist es, wenn man folgendes kann: [[List#Anzahl_aus_Geburtsjahr|Anzahl Personen aus Geburtsjahr]]<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Parser]] für DEA programmieren: Am einfachsten mit if-else<br />
# '''nur LK:''' [[Kellerautomat]] und Parser für Kellerautomat<br />
# '''nur LK:''' [[Kontextfreie Grammatik]] (Anforderungen kennen!)<br />
# '''nur LK:''' [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomat]]<br />
<br />
===<font color='red'>Im GK NICHT im Vorabi: </font>c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung===<br />
# Erstellen / Erweitern von [[Klassen-_und_Implementationsdiagramm|Implementationsdiagrammen]]<br />
# Anwendung von linearen Datenstrukturen in der Programmierung: [[List]], [[Stack]], [[Queue]]<br />
# <font color="red">NEU: </font>Einen [[Algorithmus entwickeln und implementieren]].<br />
# [[Vererbung]] und [[Polymorphie]] <strike>und [[Interface]]</strike><br />
# [[Array|Arrays]]<br />
## eindimensionale Arrays und zweidimensionale Arrays, die Objekte enthalten.<br />
## Arrays, die Objekte enthalten.<br />
## Datenbanken: <i><code>String[][] data = queryResult.getData()</code> und dann das 2-dim Array <code>data</code> mit einer Schleife auswerten.</i><br />
# <s><font color="red">NEU: </font>[[Rekursion]]: <br/>Man muss nur eine rekursive Methode analysieren können, d.h. nicht selber schreiben!</s><br />
# <font color="red">NEU: </font>[[Wrapper-Klassen]]<br />
# <s>Struktogramme für Programmabläufe verstehen/erweitern.</s></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik-Abitur-2024&diff=3682Informatik-Abitur-20242024-02-23T16:04:35Z<p>Akaibel: /* c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird alles gesammelt, was für das Abitur 2024 (LK + GK) wichtig ist.<br />
<br />
=Vorgaben für das Zentralabitur 2024=<br />
* '''[[Datei:IF-Abi-2024-Vorgaben.pdf|Vorgaben für das Informatik-Abitur 2024]]'''<br />
* Wesentlich sind die Tabellen auf S. 4 (GK) und S. 5 (LK).<br />
<br />
=Fachbegriffe=<br />
In der Vorabi-Klausur und im Abitur wird auf zuverlässige Anwendung von Fachbegriffen geachtet! <br />
<br />
Fachbegriffe erleichtern das Schreiben, weil man viel schneller und genauer schreiben kann!<br />
<br />
'''[[Informatik Fachbegriffe]]'''<br />
<br />
==Vorabi-Klausur==<br />
<font color='red'><br />
* Im LK gibt es im Vorabi 3 Aufgaben aus den drei unten genannten Bereichen. <br />
* Im GK gibt es nur 2 Aufgaben aus den Bereichen Datenbanken und Automaten. <br />
** Es kann sein, dass im GK noch ein bisschen lineare Datenstrukturen / Objektorientierte Modellierung dazukommt, das wird aber angekündigt.<br />
</font><br />
<br />
===a) Datenbanken===<br />
# [[Entity-Relationship-Modell]] <br />
# [[relationales Datenmodell]]<br />
# [[SQL]]<br />
# [[Normalisierung]]<br />
# [[Java-SQL|mit Java auf SQL zugreifen]]<br />
# Grundprinzipien des [[Datenschutz|Datenschutzes]], und dabei vor allem:<br />
## Verbot mit Erlaubnisvorbehalt<br />
## Erforderlichkeit<br />
<br />
===b) Automaten und Grammatiken:===<br />
# [[Deterministischer Endlicher Automat]] (DEA)<br />
# [[reguläre Grammatik]] (linkslinear bzw. rechtslinear): Anforderungen kennen!<br />
# DEA/NEA in reguläre Grammatik umwandeln<br />
# reguläre Grammatik in NEA umwandeln<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Potenzmengenkonstruktion]] (um NEA in DEA zu verwandeln)<br />
# Grenzen von DEA: Darf nur endlich viele Zustände haben! Kann nicht zählen!<br />
# Durchlauf durch [[List|Listen]], um etwas zu suchen oder zu berechnen: <br />
## am einfachsten mit einer for-Schleife!<br />
## völlig ausreichend ist es, wenn man folgendes kann: [[List#Anzahl_aus_Geburtsjahr|Anzahl Personen aus Geburtsjahr]]<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Parser]] für DEA programmieren: Am einfachsten mit if-else<br />
# '''nur LK:''' [[Kellerautomat]] und Parser für Kellerautomat<br />
# '''nur LK:''' [[Kontextfreie Grammatik]] (Anforderungen kennen!)<br />
# '''nur LK:''' [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomat]]<br />
<br />
===<font color='red'>Im GK NICHT im Vorabi: </font>c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung===<br />
# Erstellen / Erweitern von [[Klassen-_und_Implementationsdiagramm|Implementationsdiagrammen]]<br />
# Anwendung von linearen Datenstrukturen in der Programmierung: [[List]], [[Stack]], [[Queue]]<br />
# <font color="red">NEU: </font>Einen [[Algorithmus entwickeln und implementieren]].<br />
# [[Vererbung]] und [[Polymorphie]] <strike>und [[Interface]]</strike><br />
# [[Array|Arrays]]<br />
## eindimensionale Arrays und zweidimensionale Arrays, die Objekte enthalten.<br />
## Arrays, die Objekte enthalten.<br />
## Datenbanken: <i><code>String[][] data = queryResult.getData()</code> und dann das 2-dim Array <code>data</code> mit einer Schleife auswerten.</i><br />
# <s><font color="red">NEU: </font>[[Rekursion]]: <br/>Man muss nur eine rekursive Methode analysieren können, d.h. nicht selber schreiben!</s><br />
# <font color="red">NEU: </font>[[Wrapper-Klassen]]<br />
# <s>Struktogramme für Programmabläufe verstehen/erweitern.</s></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik-Abitur-2024&diff=3681Informatik-Abitur-20242024-02-23T16:03:39Z<p>Akaibel: /* b) Automaten und Grammatiken: */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird alles gesammelt, was für das Abitur 2024 (LK + GK) wichtig ist.<br />
<br />
=Vorgaben für das Zentralabitur 2024=<br />
* '''[[Datei:IF-Abi-2024-Vorgaben.pdf|Vorgaben für das Informatik-Abitur 2024]]'''<br />
* Wesentlich sind die Tabellen auf S. 4 (GK) und S. 5 (LK).<br />
<br />
=Fachbegriffe=<br />
In der Vorabi-Klausur und im Abitur wird auf zuverlässige Anwendung von Fachbegriffen geachtet! <br />
<br />
Fachbegriffe erleichtern das Schreiben, weil man viel schneller und genauer schreiben kann!<br />
<br />
'''[[Informatik Fachbegriffe]]'''<br />
<br />
==Vorabi-Klausur==<br />
<font color='red'><br />
* Im LK gibt es im Vorabi 3 Aufgaben aus den drei unten genannten Bereichen. <br />
* Im GK gibt es nur 2 Aufgaben aus den Bereichen Datenbanken und Automaten. <br />
** Es kann sein, dass im GK noch ein bisschen lineare Datenstrukturen / Objektorientierte Modellierung dazukommt, das wird aber angekündigt.<br />
</font><br />
<br />
===a) Datenbanken===<br />
# [[Entity-Relationship-Modell]] <br />
# [[relationales Datenmodell]]<br />
# [[SQL]]<br />
# [[Normalisierung]]<br />
# [[Java-SQL|mit Java auf SQL zugreifen]]<br />
# Grundprinzipien des [[Datenschutz|Datenschutzes]], und dabei vor allem:<br />
## Verbot mit Erlaubnisvorbehalt<br />
## Erforderlichkeit<br />
<br />
===b) Automaten und Grammatiken:===<br />
# [[Deterministischer Endlicher Automat]] (DEA)<br />
# [[reguläre Grammatik]] (linkslinear bzw. rechtslinear): Anforderungen kennen!<br />
# DEA/NEA in reguläre Grammatik umwandeln<br />
# reguläre Grammatik in NEA umwandeln<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Potenzmengenkonstruktion]] (um NEA in DEA zu verwandeln)<br />
# Grenzen von DEA: Darf nur endlich viele Zustände haben! Kann nicht zählen!<br />
# Durchlauf durch [[List|Listen]], um etwas zu suchen oder zu berechnen: <br />
## am einfachsten mit einer for-Schleife!<br />
## völlig ausreichend ist es, wenn man folgendes kann: [[List#Anzahl_aus_Geburtsjahr|Anzahl Personen aus Geburtsjahr]]<br />
# <font color='red'>Im GK NICHT im Vorabi: </font>[[Parser]] für DEA programmieren: Am einfachsten mit if-else<br />
# '''nur LK:''' [[Kellerautomat]] und Parser für Kellerautomat<br />
# '''nur LK:''' [[Kontextfreie Grammatik]] (Anforderungen kennen!)<br />
# '''nur LK:''' [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomat]]<br />
<br />
===c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung===<br />
# Erstellen / Erweitern von [[Klassen-_und_Implementationsdiagramm|Implementationsdiagrammen]]<br />
# Anwendung von linearen Datenstrukturen in der Programmierung: [[List]], [[Stack]], [[Queue]]<br />
# <font color="red">NEU: </font>Einen [[Algorithmus entwickeln und implementieren]].<br />
# [[Vererbung]] und [[Polymorphie]] <strike>und [[Interface]]</strike><br />
# [[Array|Arrays]]<br />
## eindimensionale Arrays und zweidimensionale Arrays, die Objekte enthalten.<br />
## Arrays, die Objekte enthalten.<br />
## Datenbanken: <i><code>String[][] data = queryResult.getData()</code> und dann das 2-dim Array <code>data</code> mit einer Schleife auswerten.</i><br />
# <s><font color="red">NEU: </font>[[Rekursion]]: <br/>Man muss nur eine rekursive Methode analysieren können, d.h. nicht selber schreiben!</s><br />
# <font color="red">NEU: </font>[[Wrapper-Klassen]]<br />
# <s>Struktogramme für Programmabläufe verstehen/erweitern.</s></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=List&diff=3680List2024-02-23T15:58:15Z<p>Akaibel: /* jüngste Person */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Q1]]<br />
[[Kategorie:Datenstrukturen(IF)]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<font color='red'>'''Diese Seite entspricht dem Abi 17 (und folgenden)'''</font><br />
=Erklärvideo=<br />
Wie durchläuft man standardmäßig Listen? <br />
<br />
Das wird hier anhand der Methode <code>public int gesamtVermoegen()</code> erklärt.<br />
<br />
[https://youtu.be/W3-JBKnl7xk Erklärvideo: Liste durchlaufen am Beispiel "public int gesamtVermoegen()"]<br />
<br />
=Fachbegriffe=<br />
<br />
Liste, Zeiger, an den Anfang, aktuelles Element, hasAccess(), ist leer (=isEmpty()), einfügen, (hinten) anhängen, (das aktuelle Element) löschen<br />
<br />
= Schnittstellenbeschreibung (Zentralabitur) =<br />
* [[Medium:Dokumentation_List_Abi2017.pdf|Schnittstelle der Klasse List (PDF)]]<br />
<br />
<br />
=Standardvorgehen im Umgang mit Listen=<br />
Meistens werden Listen von vorne nach hinten durchlaufen und dabei wird mit jedem einzelnen Eintrag der Liste etwas gemacht. Das funktioniert folgendermaßen:<br />
# Zeiger auf den Anfang der Liste setzen<br />
# while-Schleife, die so lange läuft, wie der Zeiger in der Liste ist. Innerhalb der Schleife...<br />
## das Element, auf das der Zeiger zeigt, in einer lokalen Variable speichern.<br />
## mit diesem Element etwas machen (das hängt von der Aufgabe der Methode ab)<br />
## den Zeiger eins weiterrücken.<br />
<br />
=Java=<br />
In '''Java''' sieht das so aus (die Liste ist in diesem Beispiel mit Objekten vom Typ <code>Person</code> gefüllt):<br />
* <code>pList.toFirst();</code><br />
* <code>while(pList.hasAccess()){</code><br />
** <code>Person p = pList.getContent();</code><br />
** <code>//TODO: mit der Person p etwas machen!</code><br />
** <code>pList.next();</code><br />
* <code>}</code><br />
<br />
==Mit for-Schleife==<br />
'''Mit einer for-Schleife lässt sich dieses Standard-Verfahren viel einfacher implementieren!'''<br />
* <code>for(pList.toFirst(); pList.hasAccess(); pList.next()){</code><br />
** <code>Person p = pList.getContent();</code><br />
** <code>//TODO: mit der Person p etwas machen!</code><br />
* <code>}</code><br />
<br />
=Beispielmethoden für Listen=<br />
Hier werden beispielhaft einige Methoden für Listen aufgeführt:<br />
<br />
==enthaelt==<br />
<code><br />
private boolean enthaelt(List<Person> pList, String pName) {<br />
boolean ergebnis = false;<br />
pList.toFirst();<br />
while(pList.hasAccess()){<br />
Person p = pList.getContent();<br />
if(p.gibName().equals(pName)){<br />
ergebnis = true;<br />
}<br />
pList.next();<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
Die Methode zeigt das Standard-Vorgehen zum Durchlaufen von Listen:<br />
* 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><br />
* Der Zeiger wird auf den Anfang der Liste gesetzt.<br />
* Mit <code>while(pList.hasAccess())</code> und <code>pList.next()</code> wird die Liste dann komplett durchlaufen.<br />
* Dabei wird mit <code>Person p = pList.getContent();</code> jeweils die Person ausgelesen, auf die der Zeiger zeigt.<br />
* 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.<br />
* Zum Schluss wird <code>ergebnis</code> zurückgegeben.<br />
<br />
==Anzahl aus Geburtsjahr==<br />
Hier wird folgendes algorithmische Verfahren umgesetzt:<br />
* <code>ergebnis</code> wird auf 0 gesetzt.<br />
* die Liste <code>pList</code> komplett durchlaufen.<br />
** Für die jeweils aktuelle Person wird geprüft, ob ihr Geburtsjahr dem Parameter <code>pJahr</code> entspricht.<br/>Wenn ja, wird <code>ergebnis</code> um 1 erhöht.<br />
* Nach dem Ende der Schleife wird <code>ergebnis</code> zurückgegeben. <br />
<br />
''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!<br />
<br />
<code><br />
public Person anzahlPersonenAusGeburtsjahr(List<Person> pList, int pJahr){<br />
int ergebnis = 0;<br />
for(pList.toFirst(); pList.hasAccess(); pList.next()){<br />
Person p = pList.getContent();<br />
if(p.getGeburtsjahr() == pJahr){<br />
ergebnis += 1;<br />
}<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
<br />
<br />
==jüngste Person==<br />
Hier wird folgende Strategie verfolgt:<br />
* in <code>ergebnis</code> wird zuerst die erste Person der Liste gespeichert.<br />
* Dann wird die Liste komplett durchlaufen.<br />
** 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.<br />
* Am Ende wird <code>ergebnis</code> zurückgegeben. <br />
<br />
<code><br />
public Person juengstePerson(List<Person> pList){<br />
Person ergebnis = null;<br />
if(pList.isEmpty()){<br />
return ergebnis;<br />
}<br />
pList.toFirst();<br />
Person ergebnis = pList.getContent();<br />
while(pList.hasAccess()){<br />
Person p = pList.getContent();<br />
if(p.getGeburtsjahr() < ergebnis.getGeburtsjahr()){<br />
ergebnis = p;<br />
}<br />
pList.next();<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
= Sortierverfahren =<br />
<br />
== Sortieren durch Einfügen ==<br />
siehe [[Insertionsort|Insertionsort]]<br />
<br />
== Sortieren durch Auswählen ==<br />
siehe [[Selectionsort|Selectionsort]]<br />
<br />
== Bubblesort ==<br />
[[Bubblesort|Bubblesort]] ist mit der neuen List-Implementierung nicht mehr sinnvoll, da es keine Möglichkeit gibt die Methode '''Flip''' sinnvoll zu programieren. <br><br />
'''Flip''' soll immer dann zwei Werte vertauschen, wenn der im Alphabet vordere Buchstabe hinten steht bzw. die hintere Zahl größer ist.<br><br />
Um die Methode jedoch sinnvoll programieren zu können, wären '''komplizierte''' & '''umständliche''' Programierungen notwendig.<br><br />
Desweiteren wäre am Ende das Sortierverfahren zu '''Rechenintensiv'''.<br />
<br />
== Mergesort ==<br />
'''<font color='red'>nicht relevant fürs Zentralabitur!</font>'''<br />
<br />
siehe [[Mergesort|Mergesort]]<br />
<br />
==Quicksort==<br />
'''<font color='red'>im Zentralabitur nur relevant für den LK!</font>'''<br />
<br />
siehe [[Quicksort|Quicksort]]<br />
<br />
== istSortiert ==<br />
für eine Liste, die mit Objekten vom Typ String gefüllt ist.<br />
<code><br />
public boolean istSortiert(List<String> pList)<br />
{<br />
boolean ergebnis = true;<br />
pList.toFirst();<br />
while(pList.hasAccess())<br />
{<br />
String aktuell = pList.getContent();<br />
pList.next();<br />
if(pList.hasAccess() == false)<br />
{<br />
ergebnis = true;<br />
return ergebnis;<br />
}<br />
String naechster = pList.getContent();<br />
if(aktuell.compareTo(naechster)>0)<br />
{<br />
ergebnis = false;<br />
return ergebnis;<br />
}<br />
}<br />
ergebnis = true;<br />
return ergebnis;<br />
}<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik-Abitur-2024&diff=3679Informatik-Abitur-20242024-02-22T16:39:57Z<p>Akaibel: /* b) Automaten und Grammatiken: */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird alles gesammelt, was für das Abitur 2024 (LK + GK) wichtig ist.<br />
<br />
=Vorgaben für das Zentralabitur 2024=<br />
* '''[[Datei:IF-Abi-2024-Vorgaben.pdf|Vorgaben für das Informatik-Abitur 2024]]'''<br />
* Wesentlich sind die Tabellen auf S. 4 (GK) und S. 5 (LK).<br />
<br />
=Fachbegriffe=<br />
In der Vorabi-Klausur und im Abitur wird auf zuverlässige Anwendung von Fachbegriffen geachtet! <br />
<br />
Fachbegriffe erleichtern das Schreiben, weil man viel schneller und genauer schreiben kann!<br />
<br />
'''[[Informatik Fachbegriffe]]'''<br />
<br />
==Vorabi-Klausur==<br />
<font color='red'><br />
* Im LK gibt es im Vorabi 3 Aufgaben aus den drei unten genannten Bereichen. <br />
* Im GK gibt es nur 2 Aufgaben aus den Bereichen Datenbanken und Automaten. <br />
** Es kann sein, dass im GK noch ein bisschen lineare Datenstrukturen / Objektorientierte Modellierung dazukommt, das wird aber angekündigt.<br />
</font><br />
<br />
===a) Datenbanken===<br />
# [[Entity-Relationship-Modell]] <br />
# [[relationales Datenmodell]]<br />
# [[SQL]]<br />
# [[Normalisierung]]<br />
# [[Java-SQL|mit Java auf SQL zugreifen]]<br />
# Grundprinzipien des [[Datenschutz|Datenschutzes]], und dabei vor allem:<br />
## Verbot mit Erlaubnisvorbehalt<br />
## Erforderlichkeit<br />
<br />
===b) Automaten und Grammatiken:===<br />
# [[Deterministischer Endlicher Automat]] (DEA)<br />
# [[reguläre Grammatik]] (linkslinear bzw. rechtslinear): Anforderungen kennen!<br />
# DEA in reguläre Grammatik umwandeln<br />
# reguläre Grammatik in NEA umwandeln<br />
# [[Potenzmengenkonstruktion]] (um NEA in DEA zu verwandeln)<br />
# Grenzen von DEA: Darf nur endlich viele Zustände haben!<br />
# Durchlauf durch [[List|Listen]], um etwas zu suchen oder zu berechnen: <br />
## am einfachsten mit einer for-Schleife!<br />
# [[Parser]] für DEA programmieren: Am einfachsten mit if-else<br />
# '''nur LK:''' [[Kellerautomat]] und Parser für Kellerautomat<br />
# '''nur LK:''' [[Kontextfreie Grammatik]] (Anforderungen kennen!)<br />
# '''nur LK:''' [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomat]]<br />
<br />
===c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung===<br />
# Erstellen / Erweitern von [[Klassen-_und_Implementationsdiagramm|Implementationsdiagrammen]]<br />
# Anwendung von linearen Datenstrukturen in der Programmierung: [[List]], [[Stack]], [[Queue]]<br />
# <font color="red">NEU: </font>Einen [[Algorithmus entwickeln und implementieren]].<br />
# [[Vererbung]] und [[Polymorphie]] <strike>und [[Interface]]</strike><br />
# [[Array|Arrays]]<br />
## eindimensionale Arrays und zweidimensionale Arrays, die Objekte enthalten.<br />
## Arrays, die Objekte enthalten.<br />
## Datenbanken: <i><code>String[][] data = queryResult.getData()</code> und dann das 2-dim Array <code>data</code> mit einer Schleife auswerten.</i><br />
# <s><font color="red">NEU: </font>[[Rekursion]]: <br/>Man muss nur eine rekursive Methode analysieren können, d.h. nicht selber schreiben!</s><br />
# <font color="red">NEU: </font>[[Wrapper-Klassen]]<br />
# <s>Struktogramme für Programmabläufe verstehen/erweitern.</s></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik-Abitur-2024&diff=3678Informatik-Abitur-20242024-02-22T16:39:13Z<p>Akaibel: /* b) Automaten und Grammatiken: */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird alles gesammelt, was für das Abitur 2024 (LK + GK) wichtig ist.<br />
<br />
=Vorgaben für das Zentralabitur 2024=<br />
* '''[[Datei:IF-Abi-2024-Vorgaben.pdf|Vorgaben für das Informatik-Abitur 2024]]'''<br />
* Wesentlich sind die Tabellen auf S. 4 (GK) und S. 5 (LK).<br />
<br />
=Fachbegriffe=<br />
In der Vorabi-Klausur und im Abitur wird auf zuverlässige Anwendung von Fachbegriffen geachtet! <br />
<br />
Fachbegriffe erleichtern das Schreiben, weil man viel schneller und genauer schreiben kann!<br />
<br />
'''[[Informatik Fachbegriffe]]'''<br />
<br />
==Vorabi-Klausur==<br />
<font color='red'><br />
* Im LK gibt es im Vorabi 3 Aufgaben aus den drei unten genannten Bereichen. <br />
* Im GK gibt es nur 2 Aufgaben aus den Bereichen Datenbanken und Automaten. <br />
** Es kann sein, dass im GK noch ein bisschen lineare Datenstrukturen / Objektorientierte Modellierung dazukommt, das wird aber angekündigt.<br />
</font><br />
<br />
===a) Datenbanken===<br />
# [[Entity-Relationship-Modell]] <br />
# [[relationales Datenmodell]]<br />
# [[SQL]]<br />
# [[Normalisierung]]<br />
# [[Java-SQL|mit Java auf SQL zugreifen]]<br />
# Grundprinzipien des [[Datenschutz|Datenschutzes]], und dabei vor allem:<br />
## Verbot mit Erlaubnisvorbehalt<br />
## Erforderlichkeit<br />
<br />
===b) Automaten und Grammatiken:===<br />
# [[Deterministischer Endlicher Automat]] (DEA)<br />
# [[reguläre Grammatik]] (linkslinear bzw. rechtslinear): Anforderungen kennen!<br />
# DEA in reguläre Grammatik umwandeln<br />
# reguläre Grammatik in NEA umwandeln<br />
# [[Potenzmengenkonstruktion]] (um NEA in DEA zu verwandeln)<br />
# Grenzen von DEA: Darf nur endlich viele Zustände haben!<br />
# Durchlauf durch Listen, um etwas zu suchen oder zu berechnen: [List]<br />
## am einfachsten mit einer for-Schleife!<br />
# [[Parser]] für DEA programmieren: Am einfachsten mit if-else<br />
# '''nur LK:''' [[Kellerautomat]] und Parser für Kellerautomat<br />
# '''nur LK:''' [[Kontextfreie Grammatik]] (Anforderungen kennen!)<br />
# '''nur LK:''' [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomat]]<br />
<br />
===c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung===<br />
# Erstellen / Erweitern von [[Klassen-_und_Implementationsdiagramm|Implementationsdiagrammen]]<br />
# Anwendung von linearen Datenstrukturen in der Programmierung: [[List]], [[Stack]], [[Queue]]<br />
# <font color="red">NEU: </font>Einen [[Algorithmus entwickeln und implementieren]].<br />
# [[Vererbung]] und [[Polymorphie]] <strike>und [[Interface]]</strike><br />
# [[Array|Arrays]]<br />
## eindimensionale Arrays und zweidimensionale Arrays, die Objekte enthalten.<br />
## Arrays, die Objekte enthalten.<br />
## Datenbanken: <i><code>String[][] data = queryResult.getData()</code> und dann das 2-dim Array <code>data</code> mit einer Schleife auswerten.</i><br />
# <s><font color="red">NEU: </font>[[Rekursion]]: <br/>Man muss nur eine rekursive Methode analysieren können, d.h. nicht selber schreiben!</s><br />
# <font color="red">NEU: </font>[[Wrapper-Klassen]]<br />
# <s>Struktogramme für Programmabläufe verstehen/erweitern.</s></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java-SQL&diff=3677Java-SQL2024-02-06T17:29:36Z<p>Akaibel: /* Vorüberlegungen */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.<br />
<br />
<b>Einschränkung der Allgemeingültigkeit dieser Seite:</b><br/><br />
Hier werden die Klassen <code>DatabaseConnector.java</code> und <code>QueryResult.java</code> verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist<br />
<br />
=Erklärvideo=<br />
<br />
[https://youtu.be/2wwpp27AM3s Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)]<br />
<br />
=Fachbegriffe=<br />
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)<br />
<br />
=Schnittstelle des Zentralabitur=<br />
<br />
[[Datei:DatabaseConnector_QueryResult_Abi_2018.pdf]]<br />
<br />
=Beispiel=<br />
<br />
==Vorüberlegungen==<br />
Das folgende Beispiel bezieht sich auf die Datenbank Schule, die auch im Unterricht häufig zum Einsatz kommt. <br/><br />
Das Datenbank-Modell und alle Daten der Datenbank finden sich hier:<br />
<br />
'''[[Datenbank#Beispieldatenbank_Schule|Beispieldatenbank Schule]]'''<br />
<br />
<br />
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler einer Klasse als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt.<br/>Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können.<br />
<br />
D.h. die Methodenkopf soll wie folgt aussehen:<br />
<code><br />
public List<Person> schuelerDerKlasse(String pKlasse)<br />
</code><br />
<br />
''(Die Klasse Person hat einen Konstruktor <code>public Person(String pName, String pVorname)</code> - mehr muss man über die Klasse Person hier nicht wissen.)''<br />
<br />
==Datenbank-Abfrage==<br />
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.name = '<font color='red'>8B</font>'<br />
</code><br />
<br />
Diese Datenbank-Abfrage sollte man vorab entwickelt und getestet haben.<br />
<br />
''Es ist besser, wenn man für die SQL-Abfrage <u>einfach Anführungszeichen</u> nimmt!''<br/><br />
''Die doppelten Anführungszeichen braucht man für Java!''<br />
<br />
==Strategie==<br />
''Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.''<br />
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code><br />
# Im Konstruktor wird der <code>connector</code> erzeugt.<br />
# In der Methode <code>schuelerDerKlasse(String pKlasse)</code> geht man so vor:<br />
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code><br />
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code><br />
## Das Ergebnis der SQL-Abfrage ermitteln: <br/><code>QueryResult queryResult = connector.getCurrentQueryResult()</code><br />
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten.<br />
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code><br />
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für den Namen<br/><code>String name = data[i][0];</code><br />
## ''Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren.''<br />
<br />
==Java-Code==<br />
<code><br />
'''public class DatenbankTest {'''<br />
'''private DatabaseConnector connector;'''<br />
<br />
'''public DatenbankTest() {'''<br />
<font color='blue'><b>// Die Verbindung zur Datenbank aufbauen</b></font><br />
// ip port database user password<br />
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");<br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null) System.err.println(errorMessage);<br />
}<br />
<br />
'''public List<Person> schuelerDerKlasse(String <font color='red'>pKlasse</font>){'''<br />
List<Person> ergebnis = new List<Person>();<br />
<br />
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> <br />
<font color='blue'><b>// Der Paramenter <font color='red'>pKlasse</font> wird "eingebaut". - man muss auf die Leerzeichen achten!!</b></font> <br />
<font color='blue'><b>// Dabei muss man muss auf die <u>Leerzeichen</u> achten...</b></font> <br />
<font color='blue'><b>// ... und die </font><font color='orange'><u>einfachen Anführungszeichen für SQL</u></font><font color='blue'> mitschreiben! </b></font> <br />
<br />
String sqlStatement =<br />
" <font color='grey'>SELECT s.name, s.vorname</font> "+<br />
" <font color='grey'>FROM schueler s JOIN klasse k</font> "+<br />
" <font color='grey'>ON s.klasse_id = k.id</font> "+<br />
" <font color='grey'>WHERE k.name = </font><font color='orange'><b>'</b></font>" +<font color='red'><b> pKlasse </b></font>+ "<font color='orange'><b>'</b></font> ";<br />
<br />
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> <br />
System.out.println(sqlStatement);<br />
<br />
<font color='blue'><b>// Das SQL-Statement ausführen</b></font> <br />
connector.executeStatement(sqlStatement);<br />
<br />
<font color='blue'><b>// Abbruchbedingung für einen Error</b></font> <br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null)<br />
{<br />
<font color='blue'><b>// Die Fehlernachricht ausgeben</b></font> <br />
System.err.println(errorMessage);<br />
return null;<br />
}<br />
<br />
<font color='blue'><b>// Das Ergebnis der Datenbankabfrage ermitteln:</b></font> <br />
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> <br />
QueryResult queryResult = connector.getCurrentQueryResult();<br />
<br />
<font color='blue'><b>// Die Daten aus QueryResult auslesen</b></font> <br />
<font color='blue'><b>// Die Daten werden als 2-dim. Array wiedergegeben:</b></font> <br />
<font color='blue'><b>// 1. Dimension: <u>Zeile</u> des Ergebnisses</b></font> <br />
<font color='blue'><b>// 2. Dimension: <u>Spalte</u> des Ergebnisses (in der Reihenfolge wie im SQL-Statement</b></font> <br />
String[][] data = queryResult.getData();<br />
<br />
<font color='blue'><b>// Die <u>Zeilen</u> durchlaufen </b></font> <br />
for (int i = 0; i < data.length; i++) {<br />
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> <br />
String name = data[i][0];<br />
String vorname = data[i][1];<br />
<br />
<font color='blue'><b>// ein Person-Objekt erzeugen ...</b></font> <br />
Person p = new Person(name, vorname);<br />
<br />
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> <br />
ergebnis.append(p);<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public static void main(String[] args) {'''<br />
new GUI(new DatenbankTest());<br />
}<br />
}<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java-SQL&diff=3676Java-SQL2024-02-06T17:28:46Z<p>Akaibel: /* Datenbankmodell */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.<br />
<br />
<b>Einschränkung der Allgemeingültigkeit dieser Seite:</b><br/><br />
Hier werden die Klassen <code>DatabaseConnector.java</code> und <code>QueryResult.java</code> verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist<br />
<br />
=Erklärvideo=<br />
<br />
[https://youtu.be/2wwpp27AM3s Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)]<br />
<br />
=Fachbegriffe=<br />
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)<br />
<br />
=Schnittstelle des Zentralabitur=<br />
<br />
[[Datei:DatabaseConnector_QueryResult_Abi_2018.pdf]]<br />
<br />
=Beispiel=<br />
<br />
==Vorüberlegungen==<br />
Das folgende Beispiel bezieht sich auf die Datenbank Schule, die auch im Unterricht häufig zum Einsatz kommt. <br/><br />
Das Datenbank-Modell und alle Daten der Datenbank finden sich hier:<br />
<br />
'''[[Datenbank#Beispieldatenbank_Schule|Beispieldatenbank Schule]]'''<br />
<br />
<br />
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler der 8B als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt.<br/>Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können.<br />
<br />
D.h. die Methodenkopf soll wie folgt aussehen:<br />
<code><br />
public List<Person> schuelerDerKlasse(String pKlasse)<br />
</code><br />
<br />
''(Die Klasse Person hat einen Konstruktor <code>public Person(String pName, String pVorname)</code> - mehr muss man über die Klasse Person hier nicht wissen.)''<br />
<br />
==Datenbank-Abfrage==<br />
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.name = '<font color='red'>8B</font>'<br />
</code><br />
<br />
Diese Datenbank-Abfrage sollte man vorab entwickelt und getestet haben.<br />
<br />
''Es ist besser, wenn man für die SQL-Abfrage <u>einfach Anführungszeichen</u> nimmt!''<br/><br />
''Die doppelten Anführungszeichen braucht man für Java!''<br />
<br />
==Strategie==<br />
''Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.''<br />
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code><br />
# Im Konstruktor wird der <code>connector</code> erzeugt.<br />
# In der Methode <code>schuelerDerKlasse(String pKlasse)</code> geht man so vor:<br />
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code><br />
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code><br />
## Das Ergebnis der SQL-Abfrage ermitteln: <br/><code>QueryResult queryResult = connector.getCurrentQueryResult()</code><br />
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten.<br />
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code><br />
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für den Namen<br/><code>String name = data[i][0];</code><br />
## ''Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren.''<br />
<br />
==Java-Code==<br />
<code><br />
'''public class DatenbankTest {'''<br />
'''private DatabaseConnector connector;'''<br />
<br />
'''public DatenbankTest() {'''<br />
<font color='blue'><b>// Die Verbindung zur Datenbank aufbauen</b></font><br />
// ip port database user password<br />
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");<br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null) System.err.println(errorMessage);<br />
}<br />
<br />
'''public List<Person> schuelerDerKlasse(String <font color='red'>pKlasse</font>){'''<br />
List<Person> ergebnis = new List<Person>();<br />
<br />
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> <br />
<font color='blue'><b>// Der Paramenter <font color='red'>pKlasse</font> wird "eingebaut". - man muss auf die Leerzeichen achten!!</b></font> <br />
<font color='blue'><b>// Dabei muss man muss auf die <u>Leerzeichen</u> achten...</b></font> <br />
<font color='blue'><b>// ... und die </font><font color='orange'><u>einfachen Anführungszeichen für SQL</u></font><font color='blue'> mitschreiben! </b></font> <br />
<br />
String sqlStatement =<br />
" <font color='grey'>SELECT s.name, s.vorname</font> "+<br />
" <font color='grey'>FROM schueler s JOIN klasse k</font> "+<br />
" <font color='grey'>ON s.klasse_id = k.id</font> "+<br />
" <font color='grey'>WHERE k.name = </font><font color='orange'><b>'</b></font>" +<font color='red'><b> pKlasse </b></font>+ "<font color='orange'><b>'</b></font> ";<br />
<br />
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> <br />
System.out.println(sqlStatement);<br />
<br />
<font color='blue'><b>// Das SQL-Statement ausführen</b></font> <br />
connector.executeStatement(sqlStatement);<br />
<br />
<font color='blue'><b>// Abbruchbedingung für einen Error</b></font> <br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null)<br />
{<br />
<font color='blue'><b>// Die Fehlernachricht ausgeben</b></font> <br />
System.err.println(errorMessage);<br />
return null;<br />
}<br />
<br />
<font color='blue'><b>// Das Ergebnis der Datenbankabfrage ermitteln:</b></font> <br />
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> <br />
QueryResult queryResult = connector.getCurrentQueryResult();<br />
<br />
<font color='blue'><b>// Die Daten aus QueryResult auslesen</b></font> <br />
<font color='blue'><b>// Die Daten werden als 2-dim. Array wiedergegeben:</b></font> <br />
<font color='blue'><b>// 1. Dimension: <u>Zeile</u> des Ergebnisses</b></font> <br />
<font color='blue'><b>// 2. Dimension: <u>Spalte</u> des Ergebnisses (in der Reihenfolge wie im SQL-Statement</b></font> <br />
String[][] data = queryResult.getData();<br />
<br />
<font color='blue'><b>// Die <u>Zeilen</u> durchlaufen </b></font> <br />
for (int i = 0; i < data.length; i++) {<br />
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> <br />
String name = data[i][0];<br />
String vorname = data[i][1];<br />
<br />
<font color='blue'><b>// ein Person-Objekt erzeugen ...</b></font> <br />
Person p = new Person(name, vorname);<br />
<br />
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> <br />
ergebnis.append(p);<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public static void main(String[] args) {'''<br />
new GUI(new DatenbankTest());<br />
}<br />
}<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java-SQL&diff=3675Java-SQL2024-02-06T17:28:32Z<p>Akaibel: /* Java-Code */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.<br />
<br />
<b>Einschränkung der Allgemeingültigkeit dieser Seite:</b><br/><br />
Hier werden die Klassen <code>DatabaseConnector.java</code> und <code>QueryResult.java</code> verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist<br />
<br />
=Erklärvideo=<br />
<br />
[https://youtu.be/2wwpp27AM3s Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)]<br />
<br />
=Fachbegriffe=<br />
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)<br />
<br />
=Schnittstelle des Zentralabitur=<br />
<br />
[[Datei:DatabaseConnector_QueryResult_Abi_2018.pdf]]<br />
<br />
=Beispiel=<br />
<br />
==Vorüberlegungen==<br />
Das folgende Beispiel bezieht sich auf die Datenbank Schule, die auch im Unterricht häufig zum Einsatz kommt. <br/><br />
Das Datenbank-Modell und alle Daten der Datenbank finden sich hier:<br />
<br />
'''[[Datenbank#Beispieldatenbank_Schule|Beispieldatenbank Schule]]'''<br />
<br />
<br />
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler der 8B als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt.<br/>Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können.<br />
<br />
D.h. die Methodenkopf soll wie folgt aussehen:<br />
<code><br />
public List<Person> schuelerDerKlasse(String pKlasse)<br />
</code><br />
<br />
''(Die Klasse Person hat einen Konstruktor <code>public Person(String pName, String pVorname)</code> - mehr muss man über die Klasse Person hier nicht wissen.)''<br />
<br />
==Datenbank-Abfrage==<br />
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.name = '<font color='red'>8B</font>'<br />
</code><br />
<br />
Diese Datenbank-Abfrage sollte man vorab entwickelt und getestet haben.<br />
<br />
''Es ist besser, wenn man für die SQL-Abfrage <u>einfach Anführungszeichen</u> nimmt!''<br/><br />
''Die doppelten Anführungszeichen braucht man für Java!''<br />
<br />
==Strategie==<br />
''Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.''<br />
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code><br />
# Im Konstruktor wird der <code>connector</code> erzeugt.<br />
# In der Methode <code>schuelerDerKlasse(String pKlasse)</code> geht man so vor:<br />
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code><br />
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code><br />
## Das Ergebnis der SQL-Abfrage ermitteln: <br/><code>QueryResult queryResult = connector.getCurrentQueryResult()</code><br />
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten.<br />
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code><br />
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für den Namen<br/><code>String name = data[i][0];</code><br />
## ''Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren.''<br />
<br />
==Java-Code==<br />
<code><br />
'''public class DatenbankTest {'''<br />
'''private DatabaseConnector connector;'''<br />
<br />
'''public DatenbankTest() {'''<br />
<font color='blue'><b>// Die Verbindung zur Datenbank aufbauen</b></font><br />
// ip port database user password<br />
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");<br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null) System.err.println(errorMessage);<br />
}<br />
<br />
'''public List<Person> schuelerDerKlasse(String <font color='red'>pKlasse</font>){'''<br />
List<Person> ergebnis = new List<Person>();<br />
<br />
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> <br />
<font color='blue'><b>// Der Paramenter <font color='red'>pKlasse</font> wird "eingebaut". - man muss auf die Leerzeichen achten!!</b></font> <br />
<font color='blue'><b>// Dabei muss man muss auf die <u>Leerzeichen</u> achten...</b></font> <br />
<font color='blue'><b>// ... und die </font><font color='orange'><u>einfachen Anführungszeichen für SQL</u></font><font color='blue'> mitschreiben! </b></font> <br />
<br />
String sqlStatement =<br />
" <font color='grey'>SELECT s.name, s.vorname</font> "+<br />
" <font color='grey'>FROM schueler s JOIN klasse k</font> "+<br />
" <font color='grey'>ON s.klasse_id = k.id</font> "+<br />
" <font color='grey'>WHERE k.name = </font><font color='orange'><b>'</b></font>" +<font color='red'><b> pKlasse </b></font>+ "<font color='orange'><b>'</b></font> ";<br />
<br />
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> <br />
System.out.println(sqlStatement);<br />
<br />
<font color='blue'><b>// Das SQL-Statement ausführen</b></font> <br />
connector.executeStatement(sqlStatement);<br />
<br />
<font color='blue'><b>// Abbruchbedingung für einen Error</b></font> <br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null)<br />
{<br />
<font color='blue'><b>// Die Fehlernachricht ausgeben</b></font> <br />
System.err.println(errorMessage);<br />
return null;<br />
}<br />
<br />
<font color='blue'><b>// Das Ergebnis der Datenbankabfrage ermitteln:</b></font> <br />
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> <br />
QueryResult queryResult = connector.getCurrentQueryResult();<br />
<br />
<font color='blue'><b>// Die Daten aus QueryResult auslesen</b></font> <br />
<font color='blue'><b>// Die Daten werden als 2-dim. Array wiedergegeben:</b></font> <br />
<font color='blue'><b>// 1. Dimension: <u>Zeile</u> des Ergebnisses</b></font> <br />
<font color='blue'><b>// 2. Dimension: <u>Spalte</u> des Ergebnisses (in der Reihenfolge wie im SQL-Statement</b></font> <br />
String[][] data = queryResult.getData();<br />
<br />
<font color='blue'><b>// Die <u>Zeilen</u> durchlaufen </b></font> <br />
for (int i = 0; i < data.length; i++) {<br />
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> <br />
String name = data[i][0];<br />
String vorname = data[i][1];<br />
<br />
<font color='blue'><b>// ein Person-Objekt erzeugen ...</b></font> <br />
Person p = new Person(name, vorname);<br />
<br />
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> <br />
ergebnis.append(p);<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public static void main(String[] args) {'''<br />
new GUI(new DatenbankTest());<br />
}<br />
}<br />
</code><br />
<br />
==Datenbankmodell==<br />
<br />
[[Datei:Datenbank-Modell-Videodatenbank.png]].</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java-SQL&diff=3674Java-SQL2024-02-06T17:13:52Z<p>Akaibel: /* Strategie */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.<br />
<br />
<b>Einschränkung der Allgemeingültigkeit dieser Seite:</b><br/><br />
Hier werden die Klassen <code>DatabaseConnector.java</code> und <code>QueryResult.java</code> verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist<br />
<br />
=Erklärvideo=<br />
<br />
[https://youtu.be/2wwpp27AM3s Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)]<br />
<br />
=Fachbegriffe=<br />
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)<br />
<br />
=Schnittstelle des Zentralabitur=<br />
<br />
[[Datei:DatabaseConnector_QueryResult_Abi_2018.pdf]]<br />
<br />
=Beispiel=<br />
<br />
==Vorüberlegungen==<br />
Das folgende Beispiel bezieht sich auf die Datenbank Schule, die auch im Unterricht häufig zum Einsatz kommt. <br/><br />
Das Datenbank-Modell und alle Daten der Datenbank finden sich hier:<br />
<br />
'''[[Datenbank#Beispieldatenbank_Schule|Beispieldatenbank Schule]]'''<br />
<br />
<br />
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler der 8B als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt.<br/>Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können.<br />
<br />
D.h. die Methodenkopf soll wie folgt aussehen:<br />
<code><br />
public List<Person> schuelerDerKlasse(String pKlasse)<br />
</code><br />
<br />
''(Die Klasse Person hat einen Konstruktor <code>public Person(String pName, String pVorname)</code> - mehr muss man über die Klasse Person hier nicht wissen.)''<br />
<br />
==Datenbank-Abfrage==<br />
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.name = '<font color='red'>8B</font>'<br />
</code><br />
<br />
Diese Datenbank-Abfrage sollte man vorab entwickelt und getestet haben.<br />
<br />
''Es ist besser, wenn man für die SQL-Abfrage <u>einfach Anführungszeichen</u> nimmt!''<br/><br />
''Die doppelten Anführungszeichen braucht man für Java!''<br />
<br />
==Strategie==<br />
''Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.''<br />
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code><br />
# Im Konstruktor wird der <code>connector</code> erzeugt.<br />
# In der Methode <code>schuelerDerKlasse(String pKlasse)</code> geht man so vor:<br />
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code><br />
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code><br />
## Das Ergebnis der SQL-Abfrage ermitteln: <br/><code>QueryResult queryResult = connector.getCurrentQueryResult()</code><br />
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten.<br />
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code><br />
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für den Namen<br/><code>String name = data[i][0];</code><br />
## ''Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren.''<br />
<br />
==Java-Code==<br />
<code><br />
'''public class DatenbankTest {'''<br />
'''private DatabaseConnector connector;'''<br />
<br />
'''public DatenbankTest() {'''<br />
<font color='blue'><b>// Die Verbindung zur Datenbank aufbauen</b></font><br />
// ip port database user password<br />
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");<br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null) System.err.println(errorMessage);<br />
}<br />
<br />
'''public List<Film> zehnFilmeMit(String <font color='red'>pDarsteller</font>){'''<br />
List<Film> ergebnis = new List<Film>();<br />
<br />
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> <br />
<font color='blue'><b>// Der Paramenter pDarsteller wird eingebaut - man muss auf die Leerzeichen achten!!</b></font> <br />
String sqlStatement =<br />
" <font color='grey'>SELECT h.name AS hauptdarstellername, f.name AS filmname, f.oscars AS oscars</font> "+<br />
" <font color='grey'>FROM film f, film_has_hauptdarsteller fh, hauptdarsteller h</font> "+<br />
" <font color='grey'>WHERE f.id = fh.film_id</font> "+<br />
" <font color='grey'>AND h.id = fh.hauptdarsteller_id</font> "+<br />
" <font color='grey'>AND h.name LIKE '%</font>" +<font color='red'><b> pDarsteller </b></font>+ "<font color='grey'>%'</font> "+<br />
" <font color='grey'>LIMIT 10</font> ";<br />
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> <br />
System.out.println(sqlStatement);<br />
<br />
<font color='blue'><b>// Das SQL-Statement ausführen</b></font> <br />
connector.executeStatement(sqlStatement);<br />
<br />
<font color='blue'><b>// Abbruchbedingung für einen Error</b></font> <br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null)<br />
{<br />
<font color='blue'><b>// Die Fehlernachricht ausgeben</b></font> <br />
System.err.println(errorMessage);<br />
return null;<br />
}<br />
<br />
<font color='blue'><b>// Das Ergebnis der Datenbankabfrae ermitteln:</b></font> <br />
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> <br />
QueryResult queryResult = connector.getCurrentQueryResult();<br />
<br />
<font color='blue'><b>// Die Daten aus QueryResult auslesen</b></font> <br />
<font color='blue'><b>// Die Daten werden als 2-dim. Array wiedergegeben:</b></font> <br />
<font color='blue'><b>// 1. Dimension: <u>Zeile</u> des Ergebnisses</b></font> <br />
<font color='blue'><b>// 2. Dimension: <u>Spalte</u> des Ergebnisses (in der Reihenfolge wie im SQL-Statement</b></font> <br />
String[][] data = queryResult.getData();<br />
<br />
<font color='blue'><b>// Die <u>Zeilen</u> durchlaufen </b></font> <br />
for (int i = 0; i < data.length; i++) {<br />
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> <br />
String hauptdarsteller = data[i][0];<br />
String filmName = data[i][1];<br />
<font color='blue'><b>// Daten sind grundsätzlich vom Typ String!</b></font> <br />
String oscarsString = data[i][2];<br />
<font color='blue'><b>// in int konvertieren</b></font> <br />
int oscars = Integer.parseInt(oscarsString);<br />
<br />
<font color='blue'><b>// ein Film-Objekt erzeugen</b></font> <br />
Film f = new Film(filmName, hauptdarsteller,oscars);<br />
System.out.println(f.toString());<br />
<br />
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> <br />
ergebnis.append(f);<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public static void main(String[] args) {'''<br />
new GUI(new DatenbankTest());<br />
}<br />
}<br />
</code><br />
<br />
==Datenbankmodell==<br />
<br />
[[Datei:Datenbank-Modell-Videodatenbank.png]].</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java-SQL&diff=3673Java-SQL2024-02-06T17:11:33Z<p>Akaibel: /* Vorüberlegungen */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.<br />
<br />
<b>Einschränkung der Allgemeingültigkeit dieser Seite:</b><br/><br />
Hier werden die Klassen <code>DatabaseConnector.java</code> und <code>QueryResult.java</code> verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist<br />
<br />
=Erklärvideo=<br />
<br />
[https://youtu.be/2wwpp27AM3s Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)]<br />
<br />
=Fachbegriffe=<br />
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)<br />
<br />
=Schnittstelle des Zentralabitur=<br />
<br />
[[Datei:DatabaseConnector_QueryResult_Abi_2018.pdf]]<br />
<br />
=Beispiel=<br />
<br />
==Vorüberlegungen==<br />
Das folgende Beispiel bezieht sich auf die Datenbank Schule, die auch im Unterricht häufig zum Einsatz kommt. <br/><br />
Das Datenbank-Modell und alle Daten der Datenbank finden sich hier:<br />
<br />
'''[[Datenbank#Beispieldatenbank_Schule|Beispieldatenbank Schule]]'''<br />
<br />
<br />
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler der 8B als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt.<br/>Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können.<br />
<br />
D.h. die Methodenkopf soll wie folgt aussehen:<br />
<code><br />
public List<Person> schuelerDerKlasse(String pKlasse)<br />
</code><br />
<br />
''(Die Klasse Person hat einen Konstruktor <code>public Person(String pName, String pVorname)</code> - mehr muss man über die Klasse Person hier nicht wissen.)''<br />
<br />
==Datenbank-Abfrage==<br />
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.name = '<font color='red'>8B</font>'<br />
</code><br />
<br />
Diese Datenbank-Abfrage sollte man vorab entwickelt und getestet haben.<br />
<br />
''Es ist besser, wenn man für die SQL-Abfrage <u>einfach Anführungszeichen</u> nimmt!''<br/><br />
''Die doppelten Anführungszeichen braucht man für Java!''<br />
<br />
==Strategie==<br />
''Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.''<br />
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code><br />
# Im Konstruktor wird der <code>connector</code> erzeugt.<br />
# In der Methode <code>zehnFilmeMit(String pDarsteller)</code> geht man so vor:<br />
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code><br />
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code><br />
## Das Ergebnis der SQL-Abfrage ermitteln: <br/><code>QueryResult queryResult = connector.getCurrentQueryResult()</code><br />
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten.<br />
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code><br />
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für die Oscars<br/><code>String oscarsString = data[i][2];</code><br />
## Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren, z.B. mit<br/><code>int oscars = Integer.parseInt(oscarsString);</code><br />
<br />
==Java-Code==<br />
<code><br />
'''public class DatenbankTest {'''<br />
'''private DatabaseConnector connector;'''<br />
<br />
'''public DatenbankTest() {'''<br />
<font color='blue'><b>// Die Verbindung zur Datenbank aufbauen</b></font><br />
// ip port database user password<br />
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");<br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null) System.err.println(errorMessage);<br />
}<br />
<br />
'''public List<Film> zehnFilmeMit(String <font color='red'>pDarsteller</font>){'''<br />
List<Film> ergebnis = new List<Film>();<br />
<br />
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> <br />
<font color='blue'><b>// Der Paramenter pDarsteller wird eingebaut - man muss auf die Leerzeichen achten!!</b></font> <br />
String sqlStatement =<br />
" <font color='grey'>SELECT h.name AS hauptdarstellername, f.name AS filmname, f.oscars AS oscars</font> "+<br />
" <font color='grey'>FROM film f, film_has_hauptdarsteller fh, hauptdarsteller h</font> "+<br />
" <font color='grey'>WHERE f.id = fh.film_id</font> "+<br />
" <font color='grey'>AND h.id = fh.hauptdarsteller_id</font> "+<br />
" <font color='grey'>AND h.name LIKE '%</font>" +<font color='red'><b> pDarsteller </b></font>+ "<font color='grey'>%'</font> "+<br />
" <font color='grey'>LIMIT 10</font> ";<br />
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> <br />
System.out.println(sqlStatement);<br />
<br />
<font color='blue'><b>// Das SQL-Statement ausführen</b></font> <br />
connector.executeStatement(sqlStatement);<br />
<br />
<font color='blue'><b>// Abbruchbedingung für einen Error</b></font> <br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null)<br />
{<br />
<font color='blue'><b>// Die Fehlernachricht ausgeben</b></font> <br />
System.err.println(errorMessage);<br />
return null;<br />
}<br />
<br />
<font color='blue'><b>// Das Ergebnis der Datenbankabfrae ermitteln:</b></font> <br />
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> <br />
QueryResult queryResult = connector.getCurrentQueryResult();<br />
<br />
<font color='blue'><b>// Die Daten aus QueryResult auslesen</b></font> <br />
<font color='blue'><b>// Die Daten werden als 2-dim. Array wiedergegeben:</b></font> <br />
<font color='blue'><b>// 1. Dimension: <u>Zeile</u> des Ergebnisses</b></font> <br />
<font color='blue'><b>// 2. Dimension: <u>Spalte</u> des Ergebnisses (in der Reihenfolge wie im SQL-Statement</b></font> <br />
String[][] data = queryResult.getData();<br />
<br />
<font color='blue'><b>// Die <u>Zeilen</u> durchlaufen </b></font> <br />
for (int i = 0; i < data.length; i++) {<br />
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> <br />
String hauptdarsteller = data[i][0];<br />
String filmName = data[i][1];<br />
<font color='blue'><b>// Daten sind grundsätzlich vom Typ String!</b></font> <br />
String oscarsString = data[i][2];<br />
<font color='blue'><b>// in int konvertieren</b></font> <br />
int oscars = Integer.parseInt(oscarsString);<br />
<br />
<font color='blue'><b>// ein Film-Objekt erzeugen</b></font> <br />
Film f = new Film(filmName, hauptdarsteller,oscars);<br />
System.out.println(f.toString());<br />
<br />
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> <br />
ergebnis.append(f);<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public static void main(String[] args) {'''<br />
new GUI(new DatenbankTest());<br />
}<br />
}<br />
</code><br />
<br />
==Datenbankmodell==<br />
<br />
[[Datei:Datenbank-Modell-Videodatenbank.png]].</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java-SQL&diff=3672Java-SQL2024-02-06T17:10:50Z<p>Akaibel: /* Vorüberlegungen */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.<br />
<br />
<b>Einschränkung der Allgemeingültigkeit dieser Seite:</b><br/><br />
Hier werden die Klassen <code>DatabaseConnector.java</code> und <code>QueryResult.java</code> verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist<br />
<br />
=Erklärvideo=<br />
<br />
[https://youtu.be/2wwpp27AM3s Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)]<br />
<br />
=Fachbegriffe=<br />
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)<br />
<br />
=Schnittstelle des Zentralabitur=<br />
<br />
[[Datei:DatabaseConnector_QueryResult_Abi_2018.pdf]]<br />
<br />
=Beispiel=<br />
<br />
==Vorüberlegungen==<br />
Das folgende Beispiel bezieht sich auf die Datenbank Schule, die auch im Unterricht häufig zum Einsatz kommt. <br/><br />
Das Datenbank-Modell und alle Daten der Datenbank finden sich hier:<br />
<br />
'''[[Datenbank#Beispieldatenbank_Schule|Beispieldatenbank Schule]]'''<br />
<br />
<br />
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler der 8B als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt.<br/>Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können.<br />
<br />
D.h. die Methodenkopf soll wie folgt aussehen:<br />
<code><br />
public List<Person> schuelerDerKlasse(String pKlasse)<br />
</code><br />
<br />
''(Die Klasse Person hat einen Konstruktor <code>public Person(String pName, String pVorname)</code> - mehr muss man über die Klasse Person hier nicht wissen.)''<br />
<br />
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.name = '<font color='red'>8B</font>'<br />
</code><br />
<br />
Diese Datenbank-Abfrage sollte man vorab entwickelt und getestet haben.<br />
<br />
''Es ist besser, wenn man für die SQL-Abfrage <u>einfach Anführungszeichen</u> nimmt!''<br/><br />
''Die doppelten Anführungszeichen braucht man für Java!''<br />
<br />
==Strategie==<br />
''Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.''<br />
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code><br />
# Im Konstruktor wird der <code>connector</code> erzeugt.<br />
# In der Methode <code>zehnFilmeMit(String pDarsteller)</code> geht man so vor:<br />
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code><br />
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code><br />
## Das Ergebnis der SQL-Abfrage ermitteln: <br/><code>QueryResult queryResult = connector.getCurrentQueryResult()</code><br />
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten.<br />
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code><br />
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für die Oscars<br/><code>String oscarsString = data[i][2];</code><br />
## Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren, z.B. mit<br/><code>int oscars = Integer.parseInt(oscarsString);</code><br />
<br />
==Java-Code==<br />
<code><br />
'''public class DatenbankTest {'''<br />
'''private DatabaseConnector connector;'''<br />
<br />
'''public DatenbankTest() {'''<br />
<font color='blue'><b>// Die Verbindung zur Datenbank aufbauen</b></font><br />
// ip port database user password<br />
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");<br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null) System.err.println(errorMessage);<br />
}<br />
<br />
'''public List<Film> zehnFilmeMit(String <font color='red'>pDarsteller</font>){'''<br />
List<Film> ergebnis = new List<Film>();<br />
<br />
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> <br />
<font color='blue'><b>// Der Paramenter pDarsteller wird eingebaut - man muss auf die Leerzeichen achten!!</b></font> <br />
String sqlStatement =<br />
" <font color='grey'>SELECT h.name AS hauptdarstellername, f.name AS filmname, f.oscars AS oscars</font> "+<br />
" <font color='grey'>FROM film f, film_has_hauptdarsteller fh, hauptdarsteller h</font> "+<br />
" <font color='grey'>WHERE f.id = fh.film_id</font> "+<br />
" <font color='grey'>AND h.id = fh.hauptdarsteller_id</font> "+<br />
" <font color='grey'>AND h.name LIKE '%</font>" +<font color='red'><b> pDarsteller </b></font>+ "<font color='grey'>%'</font> "+<br />
" <font color='grey'>LIMIT 10</font> ";<br />
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> <br />
System.out.println(sqlStatement);<br />
<br />
<font color='blue'><b>// Das SQL-Statement ausführen</b></font> <br />
connector.executeStatement(sqlStatement);<br />
<br />
<font color='blue'><b>// Abbruchbedingung für einen Error</b></font> <br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null)<br />
{<br />
<font color='blue'><b>// Die Fehlernachricht ausgeben</b></font> <br />
System.err.println(errorMessage);<br />
return null;<br />
}<br />
<br />
<font color='blue'><b>// Das Ergebnis der Datenbankabfrae ermitteln:</b></font> <br />
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> <br />
QueryResult queryResult = connector.getCurrentQueryResult();<br />
<br />
<font color='blue'><b>// Die Daten aus QueryResult auslesen</b></font> <br />
<font color='blue'><b>// Die Daten werden als 2-dim. Array wiedergegeben:</b></font> <br />
<font color='blue'><b>// 1. Dimension: <u>Zeile</u> des Ergebnisses</b></font> <br />
<font color='blue'><b>// 2. Dimension: <u>Spalte</u> des Ergebnisses (in der Reihenfolge wie im SQL-Statement</b></font> <br />
String[][] data = queryResult.getData();<br />
<br />
<font color='blue'><b>// Die <u>Zeilen</u> durchlaufen </b></font> <br />
for (int i = 0; i < data.length; i++) {<br />
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> <br />
String hauptdarsteller = data[i][0];<br />
String filmName = data[i][1];<br />
<font color='blue'><b>// Daten sind grundsätzlich vom Typ String!</b></font> <br />
String oscarsString = data[i][2];<br />
<font color='blue'><b>// in int konvertieren</b></font> <br />
int oscars = Integer.parseInt(oscarsString);<br />
<br />
<font color='blue'><b>// ein Film-Objekt erzeugen</b></font> <br />
Film f = new Film(filmName, hauptdarsteller,oscars);<br />
System.out.println(f.toString());<br />
<br />
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> <br />
ergebnis.append(f);<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public static void main(String[] args) {'''<br />
new GUI(new DatenbankTest());<br />
}<br />
}<br />
</code><br />
<br />
==Datenbankmodell==<br />
<br />
[[Datei:Datenbank-Modell-Videodatenbank.png]].</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java-SQL&diff=3671Java-SQL2024-02-06T17:05:23Z<p>Akaibel: /* Vorüberlegungen */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.<br />
<br />
<b>Einschränkung der Allgemeingültigkeit dieser Seite:</b><br/><br />
Hier werden die Klassen <code>DatabaseConnector.java</code> und <code>QueryResult.java</code> verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist<br />
<br />
=Erklärvideo=<br />
<br />
[https://youtu.be/2wwpp27AM3s Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)]<br />
<br />
=Fachbegriffe=<br />
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)<br />
<br />
=Schnittstelle des Zentralabitur=<br />
<br />
[[Datei:DatabaseConnector_QueryResult_Abi_2018.pdf]]<br />
<br />
=Beispiel=<br />
<br />
==Vorüberlegungen==<br />
Das folgende Beispiel bezieht sich auf die Datenbank Schule, die auch im Unterricht häufig zum Einsatz kommt. <br/><br />
Das Datenbank-Modell und alle Daten der Datenbank finden sich hier:<br />
<br />
'''[[Datenbank#Beispieldatenbank_Schule|Beispieldatenbank Schule]]'''<br />
<br />
<br />
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler der 8B als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt.<br/>Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können.<br />
<br />
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.name = '<font color='red'>8B</font>'<br />
</code><br />
<br />
Diese Datenbank-Abfrage sollte man vorab entwickelt und getestet haben.<br />
<br />
''Es ist besser, wenn man für die SQL-Abfrage <u>einfach Anführungszeichen</u> nimmt!''<br/><br />
''Die doppelten Anführungszeichen braucht man für Java!''<br />
<br />
==Strategie==<br />
''Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.''<br />
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code><br />
# Im Konstruktor wird der <code>connector</code> erzeugt.<br />
# In der Methode <code>zehnFilmeMit(String pDarsteller)</code> geht man so vor:<br />
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code><br />
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code><br />
## Das Ergebnis der SQL-Abfrage ermitteln: <br/><code>QueryResult queryResult = connector.getCurrentQueryResult()</code><br />
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten.<br />
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code><br />
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für die Oscars<br/><code>String oscarsString = data[i][2];</code><br />
## Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren, z.B. mit<br/><code>int oscars = Integer.parseInt(oscarsString);</code><br />
<br />
==Java-Code==<br />
<code><br />
'''public class DatenbankTest {'''<br />
'''private DatabaseConnector connector;'''<br />
<br />
'''public DatenbankTest() {'''<br />
<font color='blue'><b>// Die Verbindung zur Datenbank aufbauen</b></font><br />
// ip port database user password<br />
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");<br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null) System.err.println(errorMessage);<br />
}<br />
<br />
'''public List<Film> zehnFilmeMit(String <font color='red'>pDarsteller</font>){'''<br />
List<Film> ergebnis = new List<Film>();<br />
<br />
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> <br />
<font color='blue'><b>// Der Paramenter pDarsteller wird eingebaut - man muss auf die Leerzeichen achten!!</b></font> <br />
String sqlStatement =<br />
" <font color='grey'>SELECT h.name AS hauptdarstellername, f.name AS filmname, f.oscars AS oscars</font> "+<br />
" <font color='grey'>FROM film f, film_has_hauptdarsteller fh, hauptdarsteller h</font> "+<br />
" <font color='grey'>WHERE f.id = fh.film_id</font> "+<br />
" <font color='grey'>AND h.id = fh.hauptdarsteller_id</font> "+<br />
" <font color='grey'>AND h.name LIKE '%</font>" +<font color='red'><b> pDarsteller </b></font>+ "<font color='grey'>%'</font> "+<br />
" <font color='grey'>LIMIT 10</font> ";<br />
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> <br />
System.out.println(sqlStatement);<br />
<br />
<font color='blue'><b>// Das SQL-Statement ausführen</b></font> <br />
connector.executeStatement(sqlStatement);<br />
<br />
<font color='blue'><b>// Abbruchbedingung für einen Error</b></font> <br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null)<br />
{<br />
<font color='blue'><b>// Die Fehlernachricht ausgeben</b></font> <br />
System.err.println(errorMessage);<br />
return null;<br />
}<br />
<br />
<font color='blue'><b>// Das Ergebnis der Datenbankabfrae ermitteln:</b></font> <br />
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> <br />
QueryResult queryResult = connector.getCurrentQueryResult();<br />
<br />
<font color='blue'><b>// Die Daten aus QueryResult auslesen</b></font> <br />
<font color='blue'><b>// Die Daten werden als 2-dim. Array wiedergegeben:</b></font> <br />
<font color='blue'><b>// 1. Dimension: <u>Zeile</u> des Ergebnisses</b></font> <br />
<font color='blue'><b>// 2. Dimension: <u>Spalte</u> des Ergebnisses (in der Reihenfolge wie im SQL-Statement</b></font> <br />
String[][] data = queryResult.getData();<br />
<br />
<font color='blue'><b>// Die <u>Zeilen</u> durchlaufen </b></font> <br />
for (int i = 0; i < data.length; i++) {<br />
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> <br />
String hauptdarsteller = data[i][0];<br />
String filmName = data[i][1];<br />
<font color='blue'><b>// Daten sind grundsätzlich vom Typ String!</b></font> <br />
String oscarsString = data[i][2];<br />
<font color='blue'><b>// in int konvertieren</b></font> <br />
int oscars = Integer.parseInt(oscarsString);<br />
<br />
<font color='blue'><b>// ein Film-Objekt erzeugen</b></font> <br />
Film f = new Film(filmName, hauptdarsteller,oscars);<br />
System.out.println(f.toString());<br />
<br />
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> <br />
ergebnis.append(f);<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public static void main(String[] args) {'''<br />
new GUI(new DatenbankTest());<br />
}<br />
}<br />
</code><br />
<br />
==Datenbankmodell==<br />
<br />
[[Datei:Datenbank-Modell-Videodatenbank.png]].</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java-SQL&diff=3670Java-SQL2024-02-06T17:03:24Z<p>Akaibel: /* Vorüberlegungen */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.<br />
<br />
<b>Einschränkung der Allgemeingültigkeit dieser Seite:</b><br/><br />
Hier werden die Klassen <code>DatabaseConnector.java</code> und <code>QueryResult.java</code> verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist<br />
<br />
=Erklärvideo=<br />
<br />
[https://youtu.be/2wwpp27AM3s Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)]<br />
<br />
=Fachbegriffe=<br />
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)<br />
<br />
=Schnittstelle des Zentralabitur=<br />
<br />
[[Datei:DatabaseConnector_QueryResult_Abi_2018.pdf]]<br />
<br />
=Beispiel=<br />
<br />
==Vorüberlegungen==<br />
Das folgende Beispiel bezieht sich auf die Datenbank Schule, die auch im Unterricht häufig zum Einsatz kommt. <br/><br />
Das Datenbank-Modell und alle Daten der Datenbank finden sich hier:<br />
<br />
'''[[Datenbank#Beispieldatenbank_Schule|Beispieldatenbank Schule]]'''<br />
<br />
<br />
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler der 8B als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt.<br/>Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können.<br />
<br />
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.name = '8B'<br />
</code><br />
<br />
==Strategie==<br />
''Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.''<br />
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code><br />
# Im Konstruktor wird der <code>connector</code> erzeugt.<br />
# In der Methode <code>zehnFilmeMit(String pDarsteller)</code> geht man so vor:<br />
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code><br />
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code><br />
## Das Ergebnis der SQL-Abfrage ermitteln: <br/><code>QueryResult queryResult = connector.getCurrentQueryResult()</code><br />
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten.<br />
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code><br />
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für die Oscars<br/><code>String oscarsString = data[i][2];</code><br />
## Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren, z.B. mit<br/><code>int oscars = Integer.parseInt(oscarsString);</code><br />
<br />
==Java-Code==<br />
<code><br />
'''public class DatenbankTest {'''<br />
'''private DatabaseConnector connector;'''<br />
<br />
'''public DatenbankTest() {'''<br />
<font color='blue'><b>// Die Verbindung zur Datenbank aufbauen</b></font><br />
// ip port database user password<br />
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");<br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null) System.err.println(errorMessage);<br />
}<br />
<br />
'''public List<Film> zehnFilmeMit(String <font color='red'>pDarsteller</font>){'''<br />
List<Film> ergebnis = new List<Film>();<br />
<br />
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> <br />
<font color='blue'><b>// Der Paramenter pDarsteller wird eingebaut - man muss auf die Leerzeichen achten!!</b></font> <br />
String sqlStatement =<br />
" <font color='grey'>SELECT h.name AS hauptdarstellername, f.name AS filmname, f.oscars AS oscars</font> "+<br />
" <font color='grey'>FROM film f, film_has_hauptdarsteller fh, hauptdarsteller h</font> "+<br />
" <font color='grey'>WHERE f.id = fh.film_id</font> "+<br />
" <font color='grey'>AND h.id = fh.hauptdarsteller_id</font> "+<br />
" <font color='grey'>AND h.name LIKE '%</font>" +<font color='red'><b> pDarsteller </b></font>+ "<font color='grey'>%'</font> "+<br />
" <font color='grey'>LIMIT 10</font> ";<br />
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> <br />
System.out.println(sqlStatement);<br />
<br />
<font color='blue'><b>// Das SQL-Statement ausführen</b></font> <br />
connector.executeStatement(sqlStatement);<br />
<br />
<font color='blue'><b>// Abbruchbedingung für einen Error</b></font> <br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null)<br />
{<br />
<font color='blue'><b>// Die Fehlernachricht ausgeben</b></font> <br />
System.err.println(errorMessage);<br />
return null;<br />
}<br />
<br />
<font color='blue'><b>// Das Ergebnis der Datenbankabfrae ermitteln:</b></font> <br />
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> <br />
QueryResult queryResult = connector.getCurrentQueryResult();<br />
<br />
<font color='blue'><b>// Die Daten aus QueryResult auslesen</b></font> <br />
<font color='blue'><b>// Die Daten werden als 2-dim. Array wiedergegeben:</b></font> <br />
<font color='blue'><b>// 1. Dimension: <u>Zeile</u> des Ergebnisses</b></font> <br />
<font color='blue'><b>// 2. Dimension: <u>Spalte</u> des Ergebnisses (in der Reihenfolge wie im SQL-Statement</b></font> <br />
String[][] data = queryResult.getData();<br />
<br />
<font color='blue'><b>// Die <u>Zeilen</u> durchlaufen </b></font> <br />
for (int i = 0; i < data.length; i++) {<br />
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> <br />
String hauptdarsteller = data[i][0];<br />
String filmName = data[i][1];<br />
<font color='blue'><b>// Daten sind grundsätzlich vom Typ String!</b></font> <br />
String oscarsString = data[i][2];<br />
<font color='blue'><b>// in int konvertieren</b></font> <br />
int oscars = Integer.parseInt(oscarsString);<br />
<br />
<font color='blue'><b>// ein Film-Objekt erzeugen</b></font> <br />
Film f = new Film(filmName, hauptdarsteller,oscars);<br />
System.out.println(f.toString());<br />
<br />
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> <br />
ergebnis.append(f);<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public static void main(String[] args) {'''<br />
new GUI(new DatenbankTest());<br />
}<br />
}<br />
</code><br />
<br />
==Datenbankmodell==<br />
<br />
[[Datei:Datenbank-Modell-Videodatenbank.png]].</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Datenbank&diff=3669Datenbank2024-02-06T17:01:07Z<p>Akaibel: /* Beispieldatenbank Schule */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Q1]]<br />
[[Kategorie:Informatik-09]]<br />
[[Kategorie:Informatik]]<br />
==Grundlagen zum Thema Datenbank==<br />
* Informationen des Zentralabiturs (PDF): [[Datei:Datenbanken-Abi-2012.pdf]]<br />
==Beispieldatenbank Schule==<br />
* An der Beispieldatenbank Schule können alle möglichen Datenbankabfragen durchprobiert werden.<br />
* Die Beispieldatenbank ist mit Absicht sehr schmal gehalten, damit man die Ergebnisse von SQL-Abfragen noch überprüfen kann.<br />
* Testen kann man SQL-Abfragen auf der Beispieldatenbank Schule: '''[http://sibiwiki.de/sql/ hier klicken]'''.<br/> Die Zugangsdaten gibt's bei Herrn Kaibel<br />
** ''Wer nicht am SIBI ist, kann hier einen SQL-Dump der Beispieldatenbank Schule herunterladen: <br/>[[Datei:Beispieldatenbank-schule.zip]]''<br />
<br />
[[Datei:Beispieldatenbank-schule.jpg]]<br />
<br />
==relationales Datenmodell==<br />
<code><br />
schueler(<u>id</u>,↑klasse_id,name,vorname)<br />
klasse(<u>id</u>,↑klassenlehrer_id,name)<br />
lehrer(<u>id</u>,name,vorname)<br />
unterricht(<u>id</u>,↑klasse_id,↑lehrer_id,↑raum_id,fach,stunden)<br />
raum(<u>id</u>,nummer,etage,plaetze)<br />
ag(<u>id</u>,↑lehrer_id,name)<br />
teilnahme(<u>↑schueler_id</u>,<u>↑ag_id</u>)<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java-SQL&diff=3668Java-SQL2024-02-06T16:58:00Z<p>Akaibel: /* Vorüberlegungen */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird erklärt, wie man aus Java heraus SQL-Abfragen auf einer Datenbank ausführen kann.<br />
<br />
<b>Einschränkung der Allgemeingültigkeit dieser Seite:</b><br/><br />
Hier werden die Klassen <code>DatabaseConnector.java</code> und <code>QueryResult.java</code> verwendet, deren Schnittstelle vom Zentralabitur NRW vorgegeben ist<br />
<br />
=Erklärvideo=<br />
<br />
[https://youtu.be/2wwpp27AM3s Mit Java auf Datenbanken zugreifen (gemäß Schnittstelle NRW-Zentralabitur)]<br />
<br />
=Fachbegriffe=<br />
SQL-Abfrage, Parameter, QueryResult, 2-dimensionales Array, Zeile und Spalte(im 2-dim. Array)<br />
<br />
=Schnittstelle des Zentralabitur=<br />
<br />
[[Datei:DatabaseConnector_QueryResult_Abi_2018.pdf]]<br />
<br />
=Beispiel=<br />
<br />
==Vorüberlegungen==<br />
Das folgende Beispiel bezieht sich auf die Video-Datenbank, die auch im Unterricht häufig zum Einsatz kommt. <br/><br />
Das Datenbank-Modell kann man [[Java-SQL#Datenbankmodell|unten auf dieser Seite]] anschauen.<br />
<br />
Es soll jetzt eine Java-Methode entwickelt werden, die alle Schüler der 8B als eine Liste vom Inhaltstyp <code>Person</code> zurückgibt. Die Klasse soll man als Parameter <code>pKlasse</code> übergeben können.<br />
<br />
Die '''Datenbank-Abfrage''', die das ermöglicht, ist die folgende - hier aufgezeigt am Beispiel der 8B:<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.name = '8B'<br />
</code><br />
<br />
==Strategie==<br />
''Die möglichen Fehlerbehandlungen werden in der Strategie nicht berücksichtigt.''<br />
# Es gibt ein Attribut <code>connector</code> vom Typ <code>DatabaseConnector</code><br />
# Im Konstruktor wird der <code>connector</code> erzeugt.<br />
# In der Methode <code>zehnFilmeMit(String pDarsteller)</code> geht man so vor:<br />
## SQL-Statement "zusammenbauen": <br/><code>String sqlStatement = " SELECT ..."</code><br />
## SQL-Statement ausführen: <br/><code>connector.executeStatement(sqlStatement);</code><br />
## Das Ergebnis der SQL-Abfrage ermitteln: <br/><code>QueryResult queryResult = connector.getCurrentQueryResult()</code><br />
## Die Daten des Ergebnisses ermitteln: <br/><code>String[][] data = queryResult.getData();</code><br/>Man erhält ein 2-dimensionales Array. <br/>Dabei ist die erste Dimension für die Zeilen, die zweite Dimension für die Spalten.<br />
## Die Zeilen werden mit einer <code>for</code>-Schleife durchlaufen: <br/><code>for (int i = 0; i < data.length; i++)</code><br />
## Jetzt liest man die einzelnen Werte nach Spaltennummer aus, z.B. für die Oscars<br/><code>String oscarsString = data[i][2];</code><br />
## Man erhält grundsätzlich Objekte vom Typ <code>String</code>. <br/>Evtl. muss man sie noch in einen richtigen Datentyp konvertieren, z.B. mit<br/><code>int oscars = Integer.parseInt(oscarsString);</code><br />
<br />
==Java-Code==<br />
<code><br />
'''public class DatenbankTest {'''<br />
'''private DatabaseConnector connector;'''<br />
<br />
'''public DatenbankTest() {'''<br />
<font color='blue'><b>// Die Verbindung zur Datenbank aufbauen</b></font><br />
// ip port database user password<br />
connector = new DatabaseConnector("localhost", 3306, "demo", "admin", "geheim");<br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null) System.err.println(errorMessage);<br />
}<br />
<br />
'''public List<Film> zehnFilmeMit(String <font color='red'>pDarsteller</font>){'''<br />
List<Film> ergebnis = new List<Film>();<br />
<br />
<font color='blue'><b>//Das SQL-Statement zusammenbauen</b></font> <br />
<font color='blue'><b>// Der Paramenter pDarsteller wird eingebaut - man muss auf die Leerzeichen achten!!</b></font> <br />
String sqlStatement =<br />
" <font color='grey'>SELECT h.name AS hauptdarstellername, f.name AS filmname, f.oscars AS oscars</font> "+<br />
" <font color='grey'>FROM film f, film_has_hauptdarsteller fh, hauptdarsteller h</font> "+<br />
" <font color='grey'>WHERE f.id = fh.film_id</font> "+<br />
" <font color='grey'>AND h.id = fh.hauptdarsteller_id</font> "+<br />
" <font color='grey'>AND h.name LIKE '%</font>" +<font color='red'><b> pDarsteller </b></font>+ "<font color='grey'>%'</font> "+<br />
" <font color='grey'>LIMIT 10</font> ";<br />
<font color='blue'><b>// Zur Kontrolle das SQL-Statement ausgeben</b></font> <br />
System.out.println(sqlStatement);<br />
<br />
<font color='blue'><b>// Das SQL-Statement ausführen</b></font> <br />
connector.executeStatement(sqlStatement);<br />
<br />
<font color='blue'><b>// Abbruchbedingung für einen Error</b></font> <br />
String errorMessage = connector.getErrorMessage();<br />
if(errorMessage != null)<br />
{<br />
<font color='blue'><b>// Die Fehlernachricht ausgeben</b></font> <br />
System.err.println(errorMessage);<br />
return null;<br />
}<br />
<br />
<font color='blue'><b>// Das Ergebnis der Datenbankabfrae ermitteln:</b></font> <br />
<font color='blue'><b>// Man erhält ein Objekt vom Typ QueryResult</b></font> <br />
QueryResult queryResult = connector.getCurrentQueryResult();<br />
<br />
<font color='blue'><b>// Die Daten aus QueryResult auslesen</b></font> <br />
<font color='blue'><b>// Die Daten werden als 2-dim. Array wiedergegeben:</b></font> <br />
<font color='blue'><b>// 1. Dimension: <u>Zeile</u> des Ergebnisses</b></font> <br />
<font color='blue'><b>// 2. Dimension: <u>Spalte</u> des Ergebnisses (in der Reihenfolge wie im SQL-Statement</b></font> <br />
String[][] data = queryResult.getData();<br />
<br />
<font color='blue'><b>// Die <u>Zeilen</u> durchlaufen </b></font> <br />
for (int i = 0; i < data.length; i++) {<br />
<font color='blue'><b>// Die einzelnen <u>Spalten</u> einer Zeile abfragen </b></font> <br />
String hauptdarsteller = data[i][0];<br />
String filmName = data[i][1];<br />
<font color='blue'><b>// Daten sind grundsätzlich vom Typ String!</b></font> <br />
String oscarsString = data[i][2];<br />
<font color='blue'><b>// in int konvertieren</b></font> <br />
int oscars = Integer.parseInt(oscarsString);<br />
<br />
<font color='blue'><b>// ein Film-Objekt erzeugen</b></font> <br />
Film f = new Film(filmName, hauptdarsteller,oscars);<br />
System.out.println(f.toString());<br />
<br />
<font color='blue'><b>// ... und an die Liste ergebnis anhaengen</b></font> <br />
ergebnis.append(f);<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public static void main(String[] args) {'''<br />
new GUI(new DatenbankTest());<br />
}<br />
}<br />
</code><br />
<br />
==Datenbankmodell==<br />
<br />
[[Datei:Datenbank-Modell-Videodatenbank.png]].</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=SQL&diff=3667SQL2024-02-04T18:34:00Z<p>Akaibel: /* Beispieldatenbank Schule */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
<font color='red'>'''''Diese Seite ist für die Oberstufe (Jahrgang 11-13). Für SQL in der 10. Klasse hier klicken: [[SQL-09]]'''''</font><br />
<br />
Hier finden sich Erläuterungen zu allen SQL-Techniken, die für das Zentralabitur wichtig sind.<br />
<br />
Zu diesen Techniken gibt es auch '''[[SQL-Aufgaben|Aufgaben]]''', die man zur Übung selber bearbeiten kann.<br />
<br />
=Erklärvideos=<br />
* [https://youtu.be/J425xx6PVxs Abfragen mit GROUP BY (06:15min)]<br />
<br />
* [https://youtu.be/ZPna0CmGuQg Abfragen über mehrere Tabellen]<br />
<br />
* [https://youtu.be/rUkVjvlX2Eg Abfragen mit NOT IN bzw. mit IN]<br />
<br />
* [https://youtu.be/TZjt6gvRfl8 Abfrage über selbstdefinierte Tabellen]<br />
<br />
* [https://youtu.be/GohWF9SnhWM ChatGPT nutzen, um SQL zu schreiben]<br />
<br />
=Fachbegriffe=<br />
Vereinigung, Differenz, kartesisches Produkt, Abgleich der Tabellen über..., geschachtelte Abfrage, äußere Abfrage, innere Abfrage<br/><br />
<br />
Außerdem die SQL-Sprachelemente (s.u.)<br />
<br />
==SQL-Sprachelemente im Zentralabitur==<br />
<br />
Informationen des Zentralabiturs (PDF): [[Datei:Datenbanken-Abi-2012.pdf]]<br />
<br />
'''Die folgenden SQL-Befehle muss man im Zentralabitur beherrschen:'''<br />
* SELECT, SELECT DISTINCT, FROM, WHERE, GROUP BY, ORDER BY, ASC, DESC, JOIN, LEFT JOIN, RIGHT JOIN, ON, UNION, AS<br />
* Vergleichsoperatoren: =, !=, >, <, >=, <=, LIKE, BETWEEN, IN, NOT IN, IS NULL<br />
* Logische Operatoren: AND, OR, NOT<br />
* Funktionen: COUNT, SUM, MAX, MIN, AVG<br />
<br />
* sonstiges: Die Joker % und *<br />
<br />
'''Was man noch können muss:'''<br />
* '''[[SQL#Abfragen_über_mehrere_Tabellen|Abfragen über mehrere Tabellen]]''' formulieren:<br />
** mit '''[[SQL#Kartesisches_Produkt|kartesischem Produkt]]''' und '''[[SQL#Abgleich_zwischen_mehreren_Tabellen|Abgleich]]'''<br />
** mit '''[[SQL#Join|JOIN]]''' bzw. '''LEFT JOIN''' und '''RIGHT JOIN'''<br />
** mit '''[[SQL#Differenz_(NOT_IN)|Differenz (NOT IN)]]'''<br />
* '''[[SQL#Geschachtelte_SQL-Ausdrücke|Geschachtelte SQL-Ausdrücke]]'''<br />
* '''[[SQL#SQL_analysieren|SQL analysieren]]''': Häufig sind das geschachtelte SQL-Abfragen.<br />
<br />
==Beispieldatenbank Schule==<br />
* An der Beispieldatenbank Schule können alle möglichen Datenbankabfragen durchprobiert werden.<br />
* Die Beispieldatenbank ist mit Absicht sehr schmal gehalten, damit man die Ergebnisse von SQL-Abfragen noch überprüfen kann.<br />
* Testen kann man SQL-Abfragen auf der Datenbank Schule: '''[http://sibiwiki.de/sql/ hier klicken]'''.<br/>Die Zugangsdaten gibt's bei Herrn Kaibel<br />
** ''Wer nicht am SIBI ist, kann hier einen SQL-Dump der Beispieldatenbank Schule herunterladen: <br/>[[Datei:Beispieldatenbank-schule.zip]]''<br />
<br />
[[Datei:Beispieldatenbank-schule.jpg]]<br />
<br/><br />
===relationales Datenmodell der Datenbank Schule===<br />
<code><br />
schueler(<u>id</u>,↑klasse_id,name,vorname)<br />
klasse(<u>id</u>,↑klassenlehrer_id,name)<br />
lehrer(<u>id</u>,name,vorname)<br />
unterricht(<u>id</u>,↑klasse_id,↑lehrer_id,↑raum_id,fach,stunden)<br />
raum(<u>id</u>,nummer,etage,plaetze)<br />
ag(<u>id</u>,↑lehrer_id,name)<br />
teilnahme(<u>↑schueler_id</u>,<u>↑ag_id</u>)<br />
</code><br />
<br />
==Aufbau von SQL-Abfragen==<br />
Für den Aufbau von SQL-Abfragen gilt folgende Reihenfolge:<br />
<code><br />
'''SELECT ...'''<br />
'''FROM ...'''<br />
WHERE ...<br />
GROUP BY ...<br />
ORDER BY ...<br />
LIMIT ...<br />
</code><br />
<br />
<code>SELECT</code> und <code>FROM</code> müssen auf jeden Fall dabei sein, die anderen Teile sind optional.<br />
<br />
=Abfragen über <u>eine</u> Tabelle =<br />
''Begriffsklärung: Relation: (hier:) Tabelle''<br />
<br />
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.<br />
<br />
===Selektion (SELECT)===<br />
Selektion bedeutet, dass Datensätze (=Zeilen) ausgewählt werden, die eine bestimmte Bedingung erfüllen.<br />
<br />
Formuliere eine Selektionsabfrage, die alle Nummern der Räume mit mindestens 30 Plätzen zurückgibt.<br />
<br />
<code><br />
SELECT r.nummer<br />
FROM raum r<br />
<u>'''WHERE'''</u> r.plaetze >= 30<br />
</code><br />
<br />
''Beachte: Das entscheidende Schlüsselwort für die Selektion ist <code>WHERE</code>, denn hier wird die Bedingung festgelegt.''<br />
<br />
Formuliere eine Selektionsabfrage, die <u>alle</u> Informationen zu Räumen mit mindestens 30 Plätzen zurückgibt.<br />
<br />
<code><br />
SELECT <u>*</u><br />
FROM raum r<br />
<u>'''WHERE'''</u> r.plaetze >= 30<br />
</code><br />
<br />
''Beachte: Mit dem Joker * im SELECT-Teil der Abfrage werden alle Attribute ausgewählt.''<br />
<br />
===Projektion (DISTINCT) ===<br />
Unter Projektion versteht man die Reduktion der Informationen in dem Ergebnis auf ein oder mehrere Attribute (=Spalten). <br/><br />
Doppelte Zeilen werden dabei entfernt. Dafür braucht man das Schlüsselwort <code>DISTINCT</code>.<br />
<br />
'''Beispiel:'''<br />
<br />
Formuliere für die Tabelle <code>raum</code> eine Projektionsabfrage, die die Etagen mit Projektion wiedergibt.<br />
<br />
<code><br />
SELECT <u>'''DISTINCT r.etage'''</u><br />
FROM raum r<br />
</code><br />
<br />
''Beachte: Entscheidend für die Projektion ist es, dass man bei <code>SELECT</code> einzelne Attribute angibt.''<br />
<br />
=Erläuterung einzelner SQL-Befehle=<br />
Im folgenden werden einzelne SQL-Befehle jeweils am Beispiel erläutert.<br />
<br />
== Aggregat-Funktionen (COUNT, MAX, MIN, SUM, AVG) ==<br />
Mit den sog. Aggregat-Funktionen kann man Attributwerte aus mehreren Zeilen zusammenfassen.<br />
<br />
=== Kurze Erklärung ===<br />
* '''COUNT''': <u>zählt</u><br />
* '''SUM''': <u>addiert</u><br />
* '''AVG''': berechnet den Durchschnitt (average)<br />
* '''MAX''': bestimmt das Maximum<br />
* '''MIN''': bestimmt das Minimum<br />
<br />
===Beispiele===<br />
<br />
'''Beispiel 1:'''<br />
<br />
Mit der folgenden Abfrage kann man ermitteln, wie viele Schüler es gibt.<br/><br />
Man <u>zählt</u> die Zeilen; deswegen braucht man COUNT (und nicht SUM).<br />
<br />
<code><br />
SELECT <u>'''COUNT(*)'''</u><br />
FROM schueler s<br />
</code><br />
<br />
Hinweis:<br/> <br />
COUNT(*) übersetzt sich am einfachsten als "Zähle die Zeilen". <br/><br />
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).<br />
<br />
'''Beispiel 2:'''<br />
<br />
Mit der folgenden Abfrage kann man ermitteln, wie viele Stunden Sport unterrichtet werden.<br/><br />
Hier muss man die Attributwerte <code>stunden</code> <u>addieren</u>, deswegen braucht man SUM.<br />
<br />
<code><br />
SELECT <u>'''SUM(u.stunden)'''</u><br />
FROM unterricht u<br />
WHERE u.fach = 'Sport'<br />
</code><br />
<br />
'''Beispiel 3:'''<br />
<br />
Mit der folgenden Abfrage ermittelt man...<br />
* die maximale Zahl der Plätze in einem Raum,<br />
* die minimale Zahl der Plätze in einem Raum,<br />
* die durchschnittliche Zahl der Plätze in allen Räumen.<br />
<br />
<code><br />
SELECT <u>'''MAX(r.plaetze)''', '''MIN(r.plaetze)''', '''AVG(r.plaetze)'''</u><br />
FROM raum r<br />
</code><br />
<br />
=== Wann braucht man COUNT(...) und wann braucht man SUM(...) ?! ===<br />
COUNT und SUM werden leicht verwechselt!<br />
<br />
Als Faustregel kann man sagen:<br />
* COUNT, wenn <u>gezählt</u> wird,<br />
* SUM, wenn <u>addiert</u> wird.<br />
<br />
Das ist aus der Aufgabenstellung nicht immer offensichtlich!<br />
<br />
Beispiel 1:<br/><br />
Man hätte gerne die Anzahl der Plätze in allen Räumen.<br />
<br />
Beispiel 2:<br/><br />
Man hätte gerne die Anzahl der Räume.<br />
<br />
Lösung:<br />
* in Beispiel 1 wird die Anzahl der Plätze (im Attribut plaetze) <u>addiert</u>, deswegen SUM(r.plaetze)<br />
* in Beispiel 2 wird die Anzahl der Räume <u>gezählt</u>, deswegen COUNT(r.id) oder COUNT(*)<br />
<br />
===COUNT(DISTINCT ...)===<br />
'''Beispiel:'''<br/><br />
Wie viele Fächer gibt es?<br />
<code><br />
SELECT COUNT(DISTINCT u.fach)<br />
FROM unterrricht u<br />
</code><br />
<br />
Durch DISTINCT wird jedes Fach nur einmal berücksichtigt!<br />
<br />
==LIKE und der %-Joker==<br />
Der %-Joker kann in einer Abfrage beliebige Zeichen ersetzen.<br />
<br />
Den %-Joker darf man nicht mit dem exakten Vergleich (=) einsetzen; stattdessen nimmt man für den Vergleich das Schlüsselwort '''<code>LIKE</code>'''.<br />
<br />
'''Beispiel:'''<br />
<br />
Eine Liste aller Schüler, die ein Doppel-n ('nn') im Vornamen haben.<br />
<br />
<code><br />
SELECT s.vorname AS vorname, s.name AS name<br />
FROM schueler s<br />
WHERE s.vorname <u>LIKE '%nn%'</u><br />
</code><br />
<br />
''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.<br />
<br />
==GROUP BY==<br />
Mit <code>GROUP BY</code> kann man Zeilen, die einen gemeinsamen Attributwert aufweisen, zusammenfassen.<br />
<br />
'''Beispiel:'''<br />
<br />
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.<br />
<br />
<code><br />
SELECT r.etage, SUM(plaetze)<br />
FROM raum r<br />
<u>'''GROUP BY'''</u> r.etage<br />
</code><br />
<br />
''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.''<br />
<br />
''Dadurch, dass man so zusammenfasst, kann jetzt für jede Etage die Summe der Plätze berechnet werden.''<br />
<p><br />
<b>[https://youtu.be/J425xx6PVxs Erklärvideo zu GROUP BY (06:15min)]</b><br />
</p><br />
<br />
==Umbenennung (AS)==<br />
Attribute können umbenannt werden. <br />
<br />
'''Beispiel 1:'''<br />
<br />
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.<br />
<br />
<code><br />
SELECT u.klasse_id '''AS''' klassennr,u.lehrer_id '''AS''' Lehrernr,u.raum_id '''AS''' Raumnr,u.fach,u.stunden '''AS''' stunden<br />
FROM unterricht u<br />
</code><br />
<br />
'''Beispiel 2:'''<br />
<br />
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.<br />
<u>Die Liste soll nach der Anzahl der Plätze sortiert sein</u>.<br />
<br />
<code><br />
SELECT r.etage, SUM(plaetze) <u>AS PlaetzeInEtage</u><br />
FROM raum r<br />
GROUP BY r.etage<br />
<u>ORDER BY PlaetzeInEtage</u><br />
</code><br />
<br />
''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!''<br />
<br />
==Mehrere Bedingungen: AND, OR, BETWEEN==<br />
In SQL-Abfragen kann man mehrere Bedingungen kombinieren. Dafür gibt es die Schlüsselwörter AND, OR und BETWEEN<br />
<br />
===AND / OR===<br />
Mit AND / OR kann man zwei Bedingungen verknüpfen.<br />
<br />
'''Beispiel:'''<br />
<br />
<code><br />
SELECT r.nummer, r.plaetze<br />
FROM raum r<br />
WHERE r.etage = 'unten' <u>'''OR'''</u> r.etage = 'Mitte'<br />
</code><br />
<br />
===BETWEEN===<br />
Mit BETWEEN ... AND kann man Intervalle angeben.<br />
<br />
'''Beispiel:'''<br />
<br />
<code><br />
SELECT r.nummer, r.plaetze<br />
FROM raum r<br />
WHERE r.plaetze <u>'''BETWEEN'''</u> 30 '''AND''' 50<br />
</code><br />
<br />
===LIMIT===<br />
Mit LIMIT kann man angeben, wie viele Zeilen ausgegeben werden.<br />
<br />
'''Beispiel:'''<br />
Die folgende SQL-Anweisung gibt den Raum (Nummer, Platzanzahl) mit den meisten Plätzen aus.<br />
<br />
Es wird eine Liste von allen Räumen erstellt, aber nur die erste Zeile der Liste<br />
(d.h. der Raum mit den meisten Plätzen) wird ausgegeben.<br />
<br />
<code><br />
SELECT r.nummer, r.plaetze<br />
FROM raum r<br />
ORDER BY r.plaetze DESC<br />
<u>'''LIMIT 1'''</u><br />
</code><br />
<br />
=Abfragen über <u>mehrere</u> Tabellen=<br />
<br />
===Vereinigung (UNION)===<br />
Vereinigung bedeutet, dass die Ergebnis-Datensätze von zwei Abfragen zu einem Ergebnis zusammengefügt werden. <br/>Voraussetzung dafür ist, dass beide Abfragen <u>gleich viele</u> Attribute abfragen.<br />
<br />
Formuliere eine Abfrage, die Name und Vorname von allen Lehrern UND Schülern wiedergibt.<br />
<br />
<code><br />
SELECT l.name, l.vorname<br />
FROM lehrer l<br />
<u>'''UNION'''</u><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
</code><br />
<br />
===Differenz (NOT IN) ===<br />
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.<br />
<br />
Formuliere eine Abfrage, die alle Klassen ausgibt, die KEIN Mathematik haben.<br />
<br />
Idee: Die Klassen, die Mathematik haben, von allen Klassen abziehen.<br />
<br />
<code><br />
SELECT k.name<br />
FROM klasse k<br />
WHERE k.id <u>'''NOT IN'''</u><br />
(<br />
SELECT u.klasse_id <br />
FROM unterricht u <br />
WHERE u.fach='Mathe'<br />
)<br />
</code><br />
<br />
===IN===<br />
Das logische Gegenteil zu NOT IN ist entsprechend IN.<br />
Dieses Schlüsselwort kann man u.a. verwenden, wenn man in einer Abfrage zwei Datensätze einer Entitätsmenge hat.<br />
Beispiel: Welche Schüler sind in der selben Klasse wie Anne Ebert?<br />
<br />
Idee: In der äußeren Abfrage werden die Schüler gesucht; mit IN kann man dann die klasse_id von Anne Ebert angeben.<br />
<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
WHERE s.klasse_id <u>'''IN'''</u><br />
(<br />
SELECT s2.klasse_id<br />
FROM schueler s2<br />
WHERE s2.name = 'Ebert'<br />
)<br />
</code><br />
<br />
===Kartesisches Produkt===<br />
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.<br />
<br />
''Kurz: Jeder mit jedem''.<br />
<br />
Formuliere eine Abfrage für das kartesische Produkt von den Tabellen klasse und schueler. <br />
<br />
<code><br />
SELECT *<br />
FROM <u>'''klasse k, schueler s'''</u> <br />
</code><br />
<br />
Diese Abfrage liefert als Ergebnis "Jeder mit jedem". Inhaltlich ist das nicht sinnvoll.<br />
<br />
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]]<br />
<br />
<br />
===Abgleich zwischen mehreren Tabellen===<br />
Formuliere eine Abfrage, die angibt, in welchen Räumen die Klasse 8a unterrichtet wird.<br />
Die Abfrage läuft über die Tabellen klasse, unterricht und raum.<br />
<br />
<code><br />
SELECT r.nummer<br />
FROM klasse k, unterricht u, raum r <br />
<u>'''WHERE r.id=u.raum_id'''</u><br />
<u>'''AND u.klasse_id=k.id'''</u><br />
AND k.name = '8a'<br />
</code><br />
<br />
'''Wichtig:''' bei Abfragen über mehrere Tabellen braucht man einen Abgleich weniger als man Tabellen abfragt.<br />
<br />
Im Beispiel werden drei Tabellen abgefragt; deswegen braucht man zwei Abgleiche.<br />
<br />
===Join===<br />
Join ist die Bildung eines [[SQL#Kartesisches_Produkt|kartesischen Produktes]] gefolgt von einer Selektion, die den (richtigen) Abgleich zwischen den beiden Tabellen leistet.<br />
<br />
Beispiel: Eine Liste der Schüler, in der für jeden Schüler vermerkt wird, in welcher Klasse er ist.<br />
<br />
<code><br />
SELECT s.name AS schuelername, k.name AS klassename<br />
FROM schueler s <u>'''JOIN'''</u> klasse k<br />
'''ON''' s.klasse_id = k.id<br />
</code><br />
<br />
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.<br />
<br />
Der Join entspricht der [[SQL#SQL-Abfrage über mehrere verknüpfte Tabellen|SQL-Abfrage über mehrere verknüpfte Tabellen]]<br />
<br />
===Left-Join===<br />
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.<br />
<br />
Formuliere eine Abfrage, die einen Left-Join zwischen den Tabellen klasse und schueler durchführt.<br />
Bewerte das Ergebnis inhaltlich: In welchen Zusammenhängen braucht man Left-Join?<br />
<br />
<code><br />
SELECT s.name AS schuelername, k.name AS klassename<br />
FROM schueler s <u>'''LEFT JOIN'''</u> klasse k<br />
<u>'''ON'''</u> s.klasse_id = k.id<br />
</code><br />
<br />
Beim LEFT JOIN werden ALLE Daten der LINKEN Entitätsmenge angezeigt. Im Beispiel werden also auch die Schüler angezeigt, die keine Klasse haben.<br />
<br />
===Right-Join===<br />
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.<br />
<br />
Formuliere eine Abfrage, die einen Right-Join zwischen den Tabellen klasse und schueler durchführt. <br />
<br />
<code><br />
SELECT s.name AS schuelername, k.name AS klassename<br />
FROM schueler s <u>'''RIGHT JOIN'''</u> klasse k<br />
<u>'''ON'''</u> s.klasse_id = k.id<br />
</code><br />
<br />
Beim RIGHT JOIN werden ALLE Daten der RECHTEN Entitätsmenge angezeigt. Im Beispiel werden also auch die Klassen angezeigt, die keine Schüler haben.<br />
<br />
===LEFT JOIN (bzw. RIGHT JOIN) über 3 oder mehr Tabellen ===<br />
Wenn man einen LEFT JOIN über insgesamt 3 Tabellen machen will, verwendet man am einfachsten zwei LEFT JOIN. <br/><br />
<br />
Beispiel: Eine Liste <u>aller</u> Schüler, in der steht, welche AGs sie belegen.<br />
<code><br />
SELECT s.name as schueler, a.name as ag<br />
FROM schueler s<br />
LEFT JOIN teilnahme t<br />
ON s.id = t.schueler_id<br />
LEFT JOIN ag a<br />
ON t.ag_id = a.id<br />
</code><br />
<br />
===IS NULL===<br />
Formuliere eine Abfrage, die alle Schüler zurückgibt, die keine Klasse haben.<br />
<br />
<code><br />
SELECT s.name AS schuelername, k.name AS klassename<br />
FROM schueler s LEFT JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.id <u>'''IS NULL'''</u><br />
</code><br />
<br />
Beim LEFT JOIN werden ALLE Daten der LINKEN Entitätsmenge angezeigt, also auch die Schüler, die keine Klasse haben.<br />
Diese Schüler werden durch <code>k.id IS NULL ausgewählt</code>.<br />
<br />
===Abfragen, bei denen man mehrere Variablen einer Entitätsmenge braucht===<br />
Formuliere eine Abfrage, die alle Räume wiedergibt, die mehr Plätze haben als Raum R203.<br />
<br />
''Idee: ''<br />
* ''Man hat den <u>bekannten</u> Raum r1 mit der Nummer "R203".''<br />
* ''Außerdem hat man den <u>gesuchten</u> Raum r2, der mehr Plätze hat als Raum r1.''<br />
<br />
<code><br />
SELECT r2.nummer<br />
FROM <u>'''raum r1'''</u>, <u>'''raum r2'''</u><br />
WHERE r1.nummer = "R203"<br />
AND r2.plaetze > r1.plaetze<br />
</code><br />
<br />
=Abfragen über selbstdefinierte Tabellen=<br />
<br />
'''Man kann die Tabellen, die man bei FROM angibt, durch eigene SELECT-Anfrage selber definieren.'''<br />
<br />
Die selbstdefinierten Tabellen müssen <u>mit einem Alias benannt</u> und <u>durch ein Komma voneinander getrennt</u> werden.<br/>Dann können sie wie "normale" Tabellen genutzt werden.<br />
<br />
<br />
'''Beispiel:'''<br />
''Eine Liste der Klassen, in der steht, wieviel Prozent Sportunterricht sie haben.''<br />
<br />
<code><br />
SELECT gesamtstunden.klasse AS klasse, sportstunden.stunden/gesamtstunden.stunden * 100 AS prozent<br />
FROM<br />
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden<br />
FROM klasse k LEFT JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
GROUP BY k.name<br />
) <u>AS gesamtstunden</u><br />
<u>'''LEFT JOIN'''</u><br />
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden<br />
FROM klasse k, unterricht u<br />
WHERE k.id = u.klasse_id<br />
AND u.fach = 'Sport'<br />
GROUP BY k.name<br />
) <u>AS sportstunden</u>'''<br />
<u>'''ON sportstunden.klasse = gesamtstunden.klasse'''</u><br />
</code><br />
<br />
<br />
'''Erläuterung:'''<br />
<br />
* In FROM werden zwei Tabellen definiert: Die Tabelle '''gesamtstunden''' und die Tabelle '''sportstunden'''.<br />
* Diese Tabellen werden mit einem '''LEFT JOIN ... ON''' verknüpft.<br />
* Außerdem erhalten sie mithilfe von AS Aliasnamen: '''AS gesamtstunden''' (bzw. '''AS sportstunden''').<br />
* Mithilfe dieser Aliasnamen kann die äußere Abfrage auf die beiden Tabellen zugreifen.<br />
<br />
<br />
'''WICHTIG:'''<br />
Man muss jeder inneren SELECT-Abfrage mithilfe von '''AS''' einen '''Namen''' geben - nur dann ist sie in der äußeren SELECT-Abfrage ansprechbar!<br />
<br />
=SQL analysieren=<br />
In Klausuren (auch im Abi) muss SQL analysiert werden.<br />
<br />
Meistens muss man dabei ein SQL-Statement auf vorliegende Tabellen anwenden; es kann aber auch vorkommen, dass man ein SQL-Statement erläutern muss.<br />
<br />
Dafür wird hier ein '''Beispiel''' gegeben.<br />
<br />
'''SQL-Statement:'''<br />
<br />
<code><br />
SELECT gesamtstunden.klasse AS klasse, sportstunden.stunden/gesamtstunden.stunden * 100 AS prozent<br />
FROM<br />
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden<br />
FROM klasse k LEFT JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
GROUP BY k.name<br />
) <u>AS gesamtstunden</u><br />
<u>'''LEFT JOIN'''</u><br />
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden<br />
FROM klasse k, unterricht u<br />
WHERE k.id = u.klasse_id<br />
AND u.fach = 'Sport'<br />
GROUP BY k.name<br />
) <u>AS sportstunden</u>'''<br />
<u>'''ON sportstunden.klasse = gesamtstunden.klasse'''</u><br />
</code><br />
<br />
'''Aufgaben:'''<br />
# Erläutern Sie die '''Funktionsweise''' dieser SQL-Abfrage.<br />
# Erläutern Sie, welchem '''Zweck''' diese SQL-Abfrage dient.<br />
<br />
Folgendermaßen könnte eine Bearbeitung aussehen; wichtige Schlüsselwörter und Passagen sind <u>unterstrichen</u>.<br />
<br />
'''Funktionsweise:'''<br />
<br />
Die SQL-Abfrage besteht aus einer <u>äußeren Abfrage</u>, die auf <u>zwei selbstdefinierte</u> Tabellen zugreift.<br />
Der ersten selbstdefinierten Tabelle wurde mit "AS gesamtstunden" <u>der Name <code>gesamtstunden</code></u> gegeben, der zweiten selbstdefinierten Tabelle <u>der Name <code>sportstunden</code></u>.<br />
<br />
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.<br />
<br />
<u>In der äußeren Abfrage werden diese beiden selbstdefinierten Tabellen mithilfe eines LEFT JOIN über die Spalten sportstunden.klasse = gesamtstunden.klasse verknüpft.<br />
<br />
So werden in der Ergebnistabellen alle Zeilen der Tabelle <code>gesamtstunden</code> berücksichtigt, aber nicht unbedingt alle Zeilen der Tabelle <code>sportstunden</code>.</u><br />
<br />
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.<br />
<br />
'''Zweck:'''<br />
<br />
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.<br />
<br />
=HAVING=<br />
'''<font color='red'>Nicht abiturrelevant, aber sehr nützlich!</font>'''<br />
<br />
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.<br />
<br />
Das kann man mit <code>WHERE</code> nicht tun, denn <code>WHERE</code> funktioniert nur für "fest" definierte Zahlen!<br />
<br />
Für diesen Fall wurde das Schlüsselwort <code>HAVING</code> entwickelt.<br />
<br />
<br />
'''Beispiel:'''<br />
Eine Liste der Fächer, in der die Gesamtzahl der Stunden vermerkt ist, die sie unterrichtet werden. <u>Es sollen nur Fächer aufgeführt werden, die mehr als 7 Stunden unterrichtet werden</u>.<br />
<br />
''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.''<br />
<br />
''Lösen lässt sich das mit <code>HAVING</code>:<br />
<br />
<code><br />
SELECT u.fach, SUM(u.stunden) AS stunden<br />
FROM unterricht u<br />
GROUP BY u.fach<br />
<u>HAVING stunden > 7</u><br />
ORDER BY stunden DESC<br />
</code><br />
<br />
=Mit Java auf eine SQL-Datenbank zugreifen=<br />
Das wird hier erklärt: [[Java-SQL]]<br />
<br />
=ChatGPT nutzen um SQL zu schreiben=<br />
<br />
''Last not least will ich nicht verheimlichen, dass ChatGPT ein großartiges Hilfsmittel ist, um SQL zu schreiben!''<br />
<br />
==Erklärvideo==<br />
[https://youtu.be/GohWF9SnhWM ChatGPT nutzen, um SQL zu schreiben]<br />
<br />
==Best practices==<br />
''Bei unseren ersten "Gehversuchen" mit der SQL-Programmierung mit ChatGPT haben wir festgestellt:''<br />
* ''ChatGPT kann extrem cool SQL programmieren!!<br/>Es verfügt über einen SQL-Wortschatz, von dem selbst die Informatik-Lehrer noch nie gehört haben!''<br />
* '''''ABER:''' ChatGPT ist ziemlich begriffsstutzig! Man muss sehr genau erklären, was man will.''<br />
<br />
'''Empfehlungen:'''<br />
<br />
# Zu Anfang: '''Kontext herstellen!''' (-> Datenbankschema!)<br />
# '''Genau''' mitteilen, was man will, mit '''Fachbegriffen'''.<br />
# '''Testen''':<br/>Natürlich macht ChatGPT auch beim Programmieren Fehler. <br/>Der große Vorteil ist aber, dass man das - mit gut gewählten Beispielen - direkt überprüfen kann!<br/>Und wenn der SQL-Code einen Fehler hat, dann hilft nur...<br />
# '''„Nachkarten“:'''<br/>''Das ist sehr wichtig! Denn mit etwas Hartnäckigkeit kann man ChatGPT dazu bringen, das Richtige zu tun!''<br/>Für das "Nachkarten" empfiehlt sich:<br />
## Fehlermeldungen von SQL an ChatGPT weiter geben.<br />
## Fachbegriffe verwenden<br />
## Beziehungen klären <br/>z.B.: "Die Tabelle schueler ist über die Tabelle klasse mit der Tabelle unterricht verknüpft."<br/>z.B.: "Fach ist ein Attribut der Tabelle unterricht."<br />
## Gegebenenfalls SQL-Schlüsselwörter vorgeben: <br/>z.B. "Verwende NOT IN"<br />
<br />
==Vorteile==<br />
* ChatGPT steht ein sehr breites SQL-Vokabular zur Verfügung!<br/>Da sind Schlüsselwörter dabei, die man selber höchstens zum "passiven" Wortschatz zählen würde.<br />
* ChatGPT kann (wenn alles gut geht) SQL-Statements von ziemlicher Eleganz entwickeln. <br />
* Wenn man das Datenbankschema mitteilt und die Tabellen und Attribute verständlich benannt hat, dann kann sich ChatGPT auf einen beliebigen Kontext einstellen.<br />
* Außerdem geht es natürlich extrem schnell.<br />
<br />
==Datenbankschema für den Test==<br />
''Das Datenbankschema muss man direkt am Anfang mitteilen!''<br />
<code><br />
schueler(<u>id</u>,↑klasse_id,name,vorname)<br />
klasse(<u>id</u>,↑klassenlehrer_id,name)<br />
lehrer(<u>id</u>,name,vorname)<br />
unterricht(<u>id</u>,↑klasse_id,↑lehrer_id,↑raum_id,fach,stunden)<br />
raum(<u>id</u>,nummer,etage,plaetze)<br />
ag(<u>id</u>,↑lehrer_id,name)<br />
teilnahme(<u>↑schueler_id</u>,<u>↑ag_id</u>)<br />
</code><br />
<br />
Testen kann man wie üblich hier:<br />
<br />
[https://sibiwiki.de/sql/ sibiwiki.de/sql]<br />
<br />
(Zugangsdaten beim Informatik-Lehrer am SIBI.)<br />
<br />
Wer nicht am SIBI ist, kann sich einen Dump der Datenbank Schule hier herunterladen:<br/>[[Datei:Beispieldatenbank-schule.zip]]</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik-Abitur-2024&diff=3666Informatik-Abitur-20242024-02-03T19:38:12Z<p>Akaibel: /* a) Datenbanken */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird alles gesammelt, was für das Abitur 2024 (LK + GK) wichtig ist.<br />
<br />
=Vorgaben für das Zentralabitur 2024=<br />
* '''[[Datei:IF-Abi-2024-Vorgaben.pdf|Vorgaben für das Informatik-Abitur 2024]]'''<br />
* Wesentlich sind die Tabellen auf S. 4 (GK) und S. 5 (LK).<br />
<br />
=Fachbegriffe=<br />
In der Vorabi-Klausur und im Abitur wird auf zuverlässige Anwendung von Fachbegriffen geachtet! <br />
<br />
Fachbegriffe erleichtern das Schreiben, weil man viel schneller und genauer schreiben kann!<br />
<br />
'''[[Informatik Fachbegriffe]]'''<br />
<br />
==Vorabi-Klausur==<br />
<font color='red'><br />
* Im LK gibt es im Vorabi 3 Aufgaben aus den drei unten genannten Bereichen. <br />
* Im GK gibt es nur 2 Aufgaben aus den Bereichen Datenbanken und Automaten. <br />
** Es kann sein, dass im GK noch ein bisschen lineare Datenstrukturen / Objektorientierte Modellierung dazukommt, das wird aber angekündigt.<br />
</font><br />
<br />
===a) Datenbanken===<br />
# [[Entity-Relationship-Modell]] <br />
# [[relationales Datenmodell]]<br />
# [[SQL]]<br />
# [[Normalisierung]]<br />
# [[Java-SQL|mit Java auf SQL zugreifen]]<br />
# Grundprinzipien des [[Datenschutz|Datenschutzes]], und dabei vor allem:<br />
## Verbot mit Erlaubnisvorbehalt<br />
## Erforderlichkeit<br />
<br />
===b) Automaten und Grammatiken:===<br />
# [[Deterministischer Endlicher Automat]] (DEA)<br />
# [[reguläre Grammatik]] (linkslinear bzw. rechtslinear): Anforderungen kennen!<br />
# DEA in reguläre Grammatik umwandeln<br />
# reguläre Grammatik in NEA umwandeln<br />
# [[Potenzmengenkonstruktion]] (um NEA in DEA zu verwandeln)<br />
# Grenzen von DEA: Darf nur endlich viele Zustände haben!<br />
# [[Parser]] für DEA programmieren: Am einfachsten mit if-else<br />
# '''nur LK:''' [[Kellerautomat]] und Parser für Kellerautomat<br />
# '''nur LK:''' [[Kontextfreie Grammatik]] (Anforderungen kennen!)<br />
# '''nur LK:''' [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomat]]<br />
<br />
<br />
===c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung===<br />
# Erstellen / Erweitern von [[Klassen-_und_Implementationsdiagramm|Implementationsdiagrammen]]<br />
# Anwendung von linearen Datenstrukturen in der Programmierung: [[List]], [[Stack]], [[Queue]]<br />
# <font color="red">NEU: </font>Einen [[Algorithmus entwickeln und implementieren]].<br />
# [[Vererbung]] und [[Polymorphie]] <strike>und [[Interface]]</strike><br />
# [[Array|Arrays]]<br />
## eindimensionale Arrays und zweidimensionale Arrays, die Objekte enthalten.<br />
## Arrays, die Objekte enthalten.<br />
## Datenbanken: <i><code>String[][] data = queryResult.getData()</code> und dann das 2-dim Array <code>data</code> mit einer Schleife auswerten.</i><br />
# <s><font color="red">NEU: </font>[[Rekursion]]: <br/>Man muss nur eine rekursive Methode analysieren können, d.h. nicht selber schreiben!</s><br />
# <font color="red">NEU: </font>[[Wrapper-Klassen]]<br />
# <s>Struktogramme für Programmabläufe verstehen/erweitern.</s></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Algorithmus_entwickeln_und_implementieren&diff=3665Algorithmus entwickeln und implementieren2024-02-03T19:36:30Z<p>Akaibel: /* Beispiel 1: Sortieren durch Einfügen */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<br />
Die Aufgabenstellung <br />
<br />
''Entwickeln Sie einen Algorithmus, der ...''<br/><br />
''Implementieren Sie den Algorithmus.''<br />
<br />
ist im Zentralabitur sehr häufig. In der Regel gibt es für die Entwicklung des Algorithmus 40% der Punkte und für die Implementierung 60%.<br />
<br />
Auf dieser Seite werden Beispiele gegeben, wie man die Aufgabe angehen kann.<br />
<br />
'''Hinweis''':<br/><br />
Am SIBI darf man den Algorithmus mit '''Spiegelstrichen''' entwickeln; es müssen keine ganzen Sätze formuliert werden.<br/><br />
Die Darstellung des Algorithmus muss aber '''verständlich sein, ohne dass man die Implementierung anschaut'''!<br />
<br />
=Beispiel 1: Sortieren durch Einfügen=<br />
<br />
'''Aufgabenstellung:'''<br/><br />
Gegeben ist eine Liste <code>teilnehmerListe</code>, die Objekte vom Typ <code>Person</code> enthält.<br/><br />
Diese Liste soll mit dem Insertionsort-Verfahren nach dem Namen der Personen sortiert werden.<br />
<br />
# '''Entwickeln Sie einen Algorithmus, der <code>teilnehmerListe</code> nach dem Namen sortiert.'''<br />
# '''Implementieren Sie den Algorithmus.'''<br />
<br />
<br />
'''Lösung ''Entwickeln Sie einen Algorithmus...'''''<br />
<br />
Zwei Methoden: <br />
* Hilfsmethode <code>anRichtigerStelleEinfügen</code> <br />
* Hauptmethode <code>insertionSort</code><br />
<br />
'''Hilfsmethode <code>anRichtigerStelleEinfuegen</code>:'''<br />
* fügt eine Person an alphabetisch richtigen Stelle in eine Liste ein.<br />
* Die Parameter sind eine Liste <code>pList</code>, in die eingefügt werden soll, und <code>pPerson</code>, die einzufügende Person.<br />
* <code>pList</code> mit einer Schleife durchlaufen.<br />
** Wenn <code>pPerson</code> im Alphabet VOR der Person ist, auf die der Listenzeiger steht, <br/>dann <code>pPerson</code> mit <code>insert</code> VOR dem aktuellen Element einfügen<br/>und die Methode verlassen.<br />
* Wenn das Ende der Schleife erreicht wurde, dann <code>pPerson</code> hinten anhängen.<br />
<br />
'''Hauptmethode <code>insertionSort</code>:'''<br />
* kein Parameter, gibt eine sortierte Liste zurück.<br />
* eine leere Liste <code>ergebnis</code> erzeugen.<br />
* <code>teilnehmerListe</code> mit einer Schleife durchlaufen.<br />
** für jede Person in der Liste die Hilfsmethode <code>anRichtigerStelleEinfuegen</code> aufrufen, um sie an die richtige Stelle in <code>ergebnis</code> einzufügen.<br />
<br />
<br />
'''Lösung: ''Implementieren Sie den Algorithmus.'''''<br />
<br />
<code><br />
private List<Person>teilnehmerListe;<br />
<br />
'''public List<Person> insertionSort(){'''<br />
List<Person> ergebnis = new List<>();<br />
teilnehmerListe.toFirst();<br />
while(teilnehmerListe.hasAccess()){<br />
Person aktuell = teilnehmerListe.getContent();<br />
anRichtigerStelleEinfugen(ergebnis, aktuell);<br />
teilnehmerListe.next();<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public void anRichtigerStelleEinfugen(List<Person> pList, Person pPerson){'''<br />
pList.toFirst();<br />
while(pList.hasAccess()){<br />
Person aktuell = pList.getContent();<br />
// pPerson mit der aktuellen person vergleichen<br />
if(pPerson.getName().compareTo(aktuell.getName()) < 0){<br />
pList.insert(pPerson);<br />
return;<br />
}<br />
pList.next();<br />
}<br />
// pPerson wurde noch nicht eingefuegt!<br />
pList.append(pPerson);<br />
}<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Algorithmus_entwickeln_und_implementieren&diff=3664Algorithmus entwickeln und implementieren2024-02-03T19:34:33Z<p>Akaibel: Die Seite wurde neu angelegt: „Kategorie:Informatik Kategorie:Informatik-Abitur Die Aufgabenstellung ''Entwickeln Sie einen Algorithmus, der ...''<br/> ''Implementieren Sie den Algorithmus.'' ist im Zentralabitur sehr häufig. In der Regel gibt es für die Entwicklung des Algorithmus 40% der Punkte und für die Implementierung 60%. Auf dieser Seite werden Beispiele gegeben, wie man die Aufgabe angehen kann. '''Hinweis''':<br/> Am SIBI darf man den Algorithmus mit '''Spieg…“</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<br />
Die Aufgabenstellung <br />
<br />
''Entwickeln Sie einen Algorithmus, der ...''<br/><br />
''Implementieren Sie den Algorithmus.''<br />
<br />
ist im Zentralabitur sehr häufig. In der Regel gibt es für die Entwicklung des Algorithmus 40% der Punkte und für die Implementierung 60%.<br />
<br />
Auf dieser Seite werden Beispiele gegeben, wie man die Aufgabe angehen kann.<br />
<br />
'''Hinweis''':<br/><br />
Am SIBI darf man den Algorithmus mit '''Spiegelstrichen''' entwickeln; es müssen keine ganzen Sätze formuliert werden.<br/><br />
Die Darstellung des Algorithmus muss aber '''verständlich sein, ohne dass man die Implementierung anschaut'''!<br />
<br />
=Beispiel 1: Sortieren durch Einfügen=<br />
<br />
'''Aufgabenstellung:'''<br/><br />
Gegeben ist eine Liste <code>teilnehmerListe</code>, die Objekte vom Typ <code>Person</code> enthält.<br/><br />
Diese Liste soll mit dem Insertionsort-Verfahren nach dem Namen der Personen sortiert werden.<br />
<br />
# '''Entwickeln Sie einen Algorithmus, der <code>teilnehmerListe</code> nach dem Namen sortiert.'''<br />
# '''Implementieren Sie den Algorithmus.'''<br />
<br />
<br />
'''Lösung ''Entwickeln Sie einen Algorithmus...'''''<br />
<br />
Zwei Methoden: <br />
* Hilfsmethode <code>anRichtigerStelleEinfügen</code> <br />
* Hauptmethode <code>insertionSort</code><br />
<br />
'''Hilfsmethode <code>anRichtigerStelleEinfuegen</code>:'''<br />
* fügt eine Person an alphabetisch richtigen Stelle in eine Liste ein.<br />
* Die Parameter sind eine Liste <code>pList</code>, in die eingefügt werden soll, und <code>pPerson</code>, die einzufügende Person.<br />
* <code>pList</code> mit einer Schleife durchlaufen.<br />
** Wenn <code>pPerson</code> im Alphabet VOR der Person ist, auf die der Listenzeiger steht, <br/>dann <code>pPerson</code> mit <code>insert</code> VOR dem aktuellen Element einfügen<br/>und die Methode verlassen.<br />
* Wenn das Ende der Schleife erreicht wurde, dann <code>pPerson</code> hinten anhängen.<br />
<br />
'''Hauptmethode <code>insertionSort</code>:'''<br />
* kein Parameter, gibt eine sortierte Liste zurück.<br />
* eine leere Liste <code>ergebnis</code> erzeugen.<br />
* <code>teilnehmerListe</code> mit einer Schleife durchlaufen.<br />
** für jede Person in der Liste die Hilfsmethode <code>anRichtigerStelleEinfuegen</code> aufrufen, um sie an die richtige Stelle in <code>ergebnis</code> einzufügen.<br />
<br />
<br />
'''Lösung: ''Implementieren Sie den Algorithmus.'''''<br />
<br />
<code><br />
private List<Person>teilnehmerListe;<br />
<br />
'''public List<Person> sortierenDurchEinfuegen(){'''<br />
List<Person> ergebnis = new List<>();<br />
teilnehmerListe.toFirst();<br />
while(teilnehmerListe.hasAccess()){<br />
Person aktuell = teilnehmerListe.getContent();<br />
anRichtigerStelleEinfugen(ergebnis, aktuell);<br />
teilnehmerListe.next();<br />
}<br />
return ergebnis;<br />
}<br />
<br />
'''public void anRichtigerStelleEinfugen(List<Person> pList, Person pPerson){'''<br />
pList.toFirst();<br />
while(pList.hasAccess()){<br />
Person aktuell = pList.getContent();<br />
// pPerson mit der aktuellen person vergleichen<br />
if(pPerson.getName().compareTo(aktuell.getName()) < 0){<br />
pList.insert(pPerson);<br />
return;<br />
}<br />
pList.next();<br />
}<br />
// pPerson wurde noch nicht eingefuegt!<br />
pList.append(pPerson);<br />
}<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik-Abitur-2024&diff=3663Informatik-Abitur-20242024-02-03T19:04:42Z<p>Akaibel: /* Vorabi-Klausur */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
Auf dieser Seite wird alles gesammelt, was für das Abitur 2024 (LK + GK) wichtig ist.<br />
<br />
=Vorgaben für das Zentralabitur 2024=<br />
* '''[[Datei:IF-Abi-2024-Vorgaben.pdf|Vorgaben für das Informatik-Abitur 2024]]'''<br />
* Wesentlich sind die Tabellen auf S. 4 (GK) und S. 5 (LK).<br />
<br />
=Fachbegriffe=<br />
In der Vorabi-Klausur und im Abitur wird auf zuverlässige Anwendung von Fachbegriffen geachtet! <br />
<br />
Fachbegriffe erleichtern das Schreiben, weil man viel schneller und genauer schreiben kann!<br />
<br />
'''[[Informatik Fachbegriffe]]'''<br />
<br />
==Vorabi-Klausur==<br />
<font color='red'><br />
* Im LK gibt es im Vorabi 3 Aufgaben aus den drei unten genannten Bereichen. <br />
* Im GK gibt es nur 2 Aufgaben aus den Bereichen Datenbanken und Automaten. <br />
** Es kann sein, dass im GK noch ein bisschen lineare Datenstrukturen / Objektorientierte Modellierung dazukommt, das wird aber angekündigt.<br />
</font><br />
<br />
===a) Datenbanken===<br />
# [[Entity-Relationship-Modell]], [[relationales Datenmodell]]<br />
# [[SQL]]<br />
# [[Normalisierung]]<br />
# [[Java-SQL|mit Java auf SQL zugreifen]]<br />
# Grundprinzipien des [[Datenschutz|Datenschutzes]], und dabei vor allem:<br />
## Verbot mit Erlaubnisvorbehalt<br />
## Erforderlichkeit<br />
<br />
<br />
===b) Automaten und Grammatiken:===<br />
# [[Deterministischer Endlicher Automat]] (DEA)<br />
# [[reguläre Grammatik]] (linkslinear bzw. rechtslinear): Anforderungen kennen!<br />
# DEA in reguläre Grammatik umwandeln<br />
# reguläre Grammatik in NEA umwandeln<br />
# [[Potenzmengenkonstruktion]] (um NEA in DEA zu verwandeln)<br />
# Grenzen von DEA: Darf nur endlich viele Zustände haben!<br />
# [[Parser]] für DEA programmieren: Am einfachsten mit if-else<br />
# '''nur LK:''' [[Kellerautomat]] und Parser für Kellerautomat<br />
# '''nur LK:''' [[Kontextfreie Grammatik]] (Anforderungen kennen!)<br />
# '''nur LK:''' [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomat]]<br />
<br />
<br />
===c) lineare Datenstrukturen, Implementationsdiagramme, Vererbung===<br />
# Erstellen / Erweitern von [[Klassen-_und_Implementationsdiagramm|Implementationsdiagrammen]]<br />
# Anwendung von linearen Datenstrukturen in der Programmierung: [[List]], [[Stack]], [[Queue]]<br />
# <font color="red">NEU: </font>Einen [[Algorithmus entwickeln und implementieren]].<br />
# [[Vererbung]] und [[Polymorphie]] <strike>und [[Interface]]</strike><br />
# [[Array|Arrays]]<br />
## eindimensionale Arrays und zweidimensionale Arrays, die Objekte enthalten.<br />
## Arrays, die Objekte enthalten.<br />
## Datenbanken: <i><code>String[][] data = queryResult.getData()</code> und dann das 2-dim Array <code>data</code> mit einer Schleife auswerten.</i><br />
# <s><font color="red">NEU: </font>[[Rekursion]]: <br/>Man muss nur eine rekursive Methode analysieren können, d.h. nicht selber schreiben!</s><br />
# <font color="red">NEU: </font>[[Wrapper-Klassen]]<br />
# <s>Struktogramme für Programmabläufe verstehen/erweitern.</s></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=SQL&diff=3662SQL2024-01-23T17:49:48Z<p>Akaibel: /* Datenbankschema für den Test */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik]]<br />
<br />
<font color='red'>'''''Diese Seite ist für die Oberstufe (Jahrgang 11-13). Für SQL in der 10. Klasse hier klicken: [[SQL-09]]'''''</font><br />
<br />
Hier finden sich Erläuterungen zu allen SQL-Techniken, die für das Zentralabitur wichtig sind.<br />
<br />
Zu diesen Techniken gibt es auch '''[[SQL-Aufgaben|Aufgaben]]''', die man zur Übung selber bearbeiten kann.<br />
<br />
=Erklärvideos=<br />
* [https://youtu.be/J425xx6PVxs Abfragen mit GROUP BY (06:15min)]<br />
<br />
* [https://youtu.be/ZPna0CmGuQg Abfragen über mehrere Tabellen]<br />
<br />
* [https://youtu.be/rUkVjvlX2Eg Abfragen mit NOT IN bzw. mit IN]<br />
<br />
* [https://youtu.be/TZjt6gvRfl8 Abfrage über selbstdefinierte Tabellen]<br />
<br />
* [https://youtu.be/GohWF9SnhWM ChatGPT nutzen, um SQL zu schreiben]<br />
<br />
=Fachbegriffe=<br />
Vereinigung, Differenz, kartesisches Produkt, Abgleich der Tabellen über..., geschachtelte Abfrage, äußere Abfrage, innere Abfrage<br/><br />
<br />
Außerdem die SQL-Sprachelemente (s.u.)<br />
<br />
==SQL-Sprachelemente im Zentralabitur==<br />
<br />
Informationen des Zentralabiturs (PDF): [[Datei:Datenbanken-Abi-2012.pdf]]<br />
<br />
'''Die folgenden SQL-Befehle muss man im Zentralabitur beherrschen:'''<br />
* SELECT, SELECT DISTINCT, FROM, WHERE, GROUP BY, ORDER BY, ASC, DESC, JOIN, LEFT JOIN, RIGHT JOIN, ON, UNION, AS<br />
* Vergleichsoperatoren: =, !=, >, <, >=, <=, LIKE, BETWEEN, IN, NOT IN, IS NULL<br />
* Logische Operatoren: AND, OR, NOT<br />
* Funktionen: COUNT, SUM, MAX, MIN, AVG<br />
<br />
* sonstiges: Die Joker % und *<br />
<br />
'''Was man noch können muss:'''<br />
* '''[[SQL#Abfragen_über_mehrere_Tabellen|Abfragen über mehrere Tabellen]]''' formulieren:<br />
** mit '''[[SQL#Kartesisches_Produkt|kartesischem Produkt]]''' und '''[[SQL#Abgleich_zwischen_mehreren_Tabellen|Abgleich]]'''<br />
** mit '''[[SQL#Join|JOIN]]''' bzw. '''LEFT JOIN''' und '''RIGHT JOIN'''<br />
** mit '''[[SQL#Differenz_(NOT_IN)|Differenz (NOT IN)]]'''<br />
* '''[[SQL#Geschachtelte_SQL-Ausdrücke|Geschachtelte SQL-Ausdrücke]]'''<br />
* '''[[SQL#SQL_analysieren|SQL analysieren]]''': Häufig sind das geschachtelte SQL-Abfragen.<br />
<br />
==Beispieldatenbank Schule==<br />
* An der Beispieldatenbank Schule können alle möglichen Datenbankabfragen durchprobiert werden.<br />
* Die Beispieldatenbank ist mit Absicht sehr schmal gehalten, damit man die Ergebnisse von SQL-Abfragen noch überprüfen kann.<br />
* Testen kann man SQL-Abfragen auf der Datenbank Schule: '''[http://sibiwiki.de/sql/ hier klicken]'''.<br/>Die Zugangsdaten gibt's bei Herrn Kaibel<br />
** ''Wer nicht am SIBI ist, kann hier einen SQL-Dump der Beispieldatenbank Schule herunterladen: <br/>[[Datei:Beispieldatenbank-schule.zip]]''<br />
<br />
[[Datei:Beispieldatenbank-schule.jpg]]<br />
<br />
==Aufbau von SQL-Abfragen==<br />
Für den Aufbau von SQL-Abfragen gilt folgende Reihenfolge:<br />
<code><br />
'''SELECT ...'''<br />
'''FROM ...'''<br />
WHERE ...<br />
GROUP BY ...<br />
ORDER BY ...<br />
LIMIT ...<br />
</code><br />
<br />
<code>SELECT</code> und <code>FROM</code> müssen auf jeden Fall dabei sein, die anderen Teile sind optional.<br />
<br />
=Abfragen über <u>eine</u> Tabelle =<br />
''Begriffsklärung: Relation: (hier:) Tabelle''<br />
<br />
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.<br />
<br />
===Selektion (SELECT)===<br />
Selektion bedeutet, dass Datensätze (=Zeilen) ausgewählt werden, die eine bestimmte Bedingung erfüllen.<br />
<br />
Formuliere eine Selektionsabfrage, die alle Nummern der Räume mit mindestens 30 Plätzen zurückgibt.<br />
<br />
<code><br />
SELECT r.nummer<br />
FROM raum r<br />
<u>'''WHERE'''</u> r.plaetze >= 30<br />
</code><br />
<br />
''Beachte: Das entscheidende Schlüsselwort für die Selektion ist <code>WHERE</code>, denn hier wird die Bedingung festgelegt.''<br />
<br />
Formuliere eine Selektionsabfrage, die <u>alle</u> Informationen zu Räumen mit mindestens 30 Plätzen zurückgibt.<br />
<br />
<code><br />
SELECT <u>*</u><br />
FROM raum r<br />
<u>'''WHERE'''</u> r.plaetze >= 30<br />
</code><br />
<br />
''Beachte: Mit dem Joker * im SELECT-Teil der Abfrage werden alle Attribute ausgewählt.''<br />
<br />
===Projektion (DISTINCT) ===<br />
Unter Projektion versteht man die Reduktion der Informationen in dem Ergebnis auf ein oder mehrere Attribute (=Spalten). <br/><br />
Doppelte Zeilen werden dabei entfernt. Dafür braucht man das Schlüsselwort <code>DISTINCT</code>.<br />
<br />
'''Beispiel:'''<br />
<br />
Formuliere für die Tabelle <code>raum</code> eine Projektionsabfrage, die die Etagen mit Projektion wiedergibt.<br />
<br />
<code><br />
SELECT <u>'''DISTINCT r.etage'''</u><br />
FROM raum r<br />
</code><br />
<br />
''Beachte: Entscheidend für die Projektion ist es, dass man bei <code>SELECT</code> einzelne Attribute angibt.''<br />
<br />
=Erläuterung einzelner SQL-Befehle=<br />
Im folgenden werden einzelne SQL-Befehle jeweils am Beispiel erläutert.<br />
<br />
== Aggregat-Funktionen (COUNT, MAX, MIN, SUM, AVG) ==<br />
Mit den sog. Aggregat-Funktionen kann man Attributwerte aus mehreren Zeilen zusammenfassen.<br />
<br />
=== Kurze Erklärung ===<br />
* '''COUNT''': <u>zählt</u><br />
* '''SUM''': <u>addiert</u><br />
* '''AVG''': berechnet den Durchschnitt (average)<br />
* '''MAX''': bestimmt das Maximum<br />
* '''MIN''': bestimmt das Minimum<br />
<br />
===Beispiele===<br />
<br />
'''Beispiel 1:'''<br />
<br />
Mit der folgenden Abfrage kann man ermitteln, wie viele Schüler es gibt.<br/><br />
Man <u>zählt</u> die Zeilen; deswegen braucht man COUNT (und nicht SUM).<br />
<br />
<code><br />
SELECT <u>'''COUNT(*)'''</u><br />
FROM schueler s<br />
</code><br />
<br />
Hinweis:<br/> <br />
COUNT(*) übersetzt sich am einfachsten als "Zähle die Zeilen". <br/><br />
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).<br />
<br />
'''Beispiel 2:'''<br />
<br />
Mit der folgenden Abfrage kann man ermitteln, wie viele Stunden Sport unterrichtet werden.<br/><br />
Hier muss man die Attributwerte <code>stunden</code> <u>addieren</u>, deswegen braucht man SUM.<br />
<br />
<code><br />
SELECT <u>'''SUM(u.stunden)'''</u><br />
FROM unterricht u<br />
WHERE u.fach = 'Sport'<br />
</code><br />
<br />
'''Beispiel 3:'''<br />
<br />
Mit der folgenden Abfrage ermittelt man...<br />
* die maximale Zahl der Plätze in einem Raum,<br />
* die minimale Zahl der Plätze in einem Raum,<br />
* die durchschnittliche Zahl der Plätze in allen Räumen.<br />
<br />
<code><br />
SELECT <u>'''MAX(r.plaetze)''', '''MIN(r.plaetze)''', '''AVG(r.plaetze)'''</u><br />
FROM raum r<br />
</code><br />
<br />
=== Wann braucht man COUNT(...) und wann braucht man SUM(...) ?! ===<br />
COUNT und SUM werden leicht verwechselt!<br />
<br />
Als Faustregel kann man sagen:<br />
* COUNT, wenn <u>gezählt</u> wird,<br />
* SUM, wenn <u>addiert</u> wird.<br />
<br />
Das ist aus der Aufgabenstellung nicht immer offensichtlich!<br />
<br />
Beispiel 1:<br/><br />
Man hätte gerne die Anzahl der Plätze in allen Räumen.<br />
<br />
Beispiel 2:<br/><br />
Man hätte gerne die Anzahl der Räume.<br />
<br />
Lösung:<br />
* in Beispiel 1 wird die Anzahl der Plätze (im Attribut plaetze) <u>addiert</u>, deswegen SUM(r.plaetze)<br />
* in Beispiel 2 wird die Anzahl der Räume <u>gezählt</u>, deswegen COUNT(r.id) oder COUNT(*)<br />
<br />
===COUNT(DISTINCT ...)===<br />
'''Beispiel:'''<br/><br />
Wie viele Fächer gibt es?<br />
<code><br />
SELECT COUNT(DISTINCT u.fach)<br />
FROM unterrricht u<br />
</code><br />
<br />
Durch DISTINCT wird jedes Fach nur einmal berücksichtigt!<br />
<br />
==LIKE und der %-Joker==<br />
Der %-Joker kann in einer Abfrage beliebige Zeichen ersetzen.<br />
<br />
Den %-Joker darf man nicht mit dem exakten Vergleich (=) einsetzen; stattdessen nimmt man für den Vergleich das Schlüsselwort '''<code>LIKE</code>'''.<br />
<br />
'''Beispiel:'''<br />
<br />
Eine Liste aller Schüler, die ein Doppel-n ('nn') im Vornamen haben.<br />
<br />
<code><br />
SELECT s.vorname AS vorname, s.name AS name<br />
FROM schueler s<br />
WHERE s.vorname <u>LIKE '%nn%'</u><br />
</code><br />
<br />
''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.<br />
<br />
==GROUP BY==<br />
Mit <code>GROUP BY</code> kann man Zeilen, die einen gemeinsamen Attributwert aufweisen, zusammenfassen.<br />
<br />
'''Beispiel:'''<br />
<br />
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.<br />
<br />
<code><br />
SELECT r.etage, SUM(plaetze)<br />
FROM raum r<br />
<u>'''GROUP BY'''</u> r.etage<br />
</code><br />
<br />
''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.''<br />
<br />
''Dadurch, dass man so zusammenfasst, kann jetzt für jede Etage die Summe der Plätze berechnet werden.''<br />
<p><br />
<b>[https://youtu.be/J425xx6PVxs Erklärvideo zu GROUP BY (06:15min)]</b><br />
</p><br />
<br />
==Umbenennung (AS)==<br />
Attribute können umbenannt werden. <br />
<br />
'''Beispiel 1:'''<br />
<br />
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.<br />
<br />
<code><br />
SELECT u.klasse_id '''AS''' klassennr,u.lehrer_id '''AS''' Lehrernr,u.raum_id '''AS''' Raumnr,u.fach,u.stunden '''AS''' stunden<br />
FROM unterricht u<br />
</code><br />
<br />
'''Beispiel 2:'''<br />
<br />
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.<br />
<u>Die Liste soll nach der Anzahl der Plätze sortiert sein</u>.<br />
<br />
<code><br />
SELECT r.etage, SUM(plaetze) <u>AS PlaetzeInEtage</u><br />
FROM raum r<br />
GROUP BY r.etage<br />
<u>ORDER BY PlaetzeInEtage</u><br />
</code><br />
<br />
''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!''<br />
<br />
==Mehrere Bedingungen: AND, OR, BETWEEN==<br />
In SQL-Abfragen kann man mehrere Bedingungen kombinieren. Dafür gibt es die Schlüsselwörter AND, OR und BETWEEN<br />
<br />
===AND / OR===<br />
Mit AND / OR kann man zwei Bedingungen verknüpfen.<br />
<br />
'''Beispiel:'''<br />
<br />
<code><br />
SELECT r.nummer, r.plaetze<br />
FROM raum r<br />
WHERE r.etage = 'unten' <u>'''OR'''</u> r.etage = 'Mitte'<br />
</code><br />
<br />
===BETWEEN===<br />
Mit BETWEEN ... AND kann man Intervalle angeben.<br />
<br />
'''Beispiel:'''<br />
<br />
<code><br />
SELECT r.nummer, r.plaetze<br />
FROM raum r<br />
WHERE r.plaetze <u>'''BETWEEN'''</u> 30 '''AND''' 50<br />
</code><br />
<br />
===LIMIT===<br />
Mit LIMIT kann man angeben, wie viele Zeilen ausgegeben werden.<br />
<br />
'''Beispiel:'''<br />
Die folgende SQL-Anweisung gibt den Raum (Nummer, Platzanzahl) mit den meisten Plätzen aus.<br />
<br />
Es wird eine Liste von allen Räumen erstellt, aber nur die erste Zeile der Liste<br />
(d.h. der Raum mit den meisten Plätzen) wird ausgegeben.<br />
<br />
<code><br />
SELECT r.nummer, r.plaetze<br />
FROM raum r<br />
ORDER BY r.plaetze DESC<br />
<u>'''LIMIT 1'''</u><br />
</code><br />
<br />
=Abfragen über <u>mehrere</u> Tabellen=<br />
<br />
===Vereinigung (UNION)===<br />
Vereinigung bedeutet, dass die Ergebnis-Datensätze von zwei Abfragen zu einem Ergebnis zusammengefügt werden. <br/>Voraussetzung dafür ist, dass beide Abfragen <u>gleich viele</u> Attribute abfragen.<br />
<br />
Formuliere eine Abfrage, die Name und Vorname von allen Lehrern UND Schülern wiedergibt.<br />
<br />
<code><br />
SELECT l.name, l.vorname<br />
FROM lehrer l<br />
<u>'''UNION'''</u><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
</code><br />
<br />
===Differenz (NOT IN) ===<br />
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.<br />
<br />
Formuliere eine Abfrage, die alle Klassen ausgibt, die KEIN Mathematik haben.<br />
<br />
Idee: Die Klassen, die Mathematik haben, von allen Klassen abziehen.<br />
<br />
<code><br />
SELECT k.name<br />
FROM klasse k<br />
WHERE k.id <u>'''NOT IN'''</u><br />
(<br />
SELECT u.klasse_id <br />
FROM unterricht u <br />
WHERE u.fach='Mathe'<br />
)<br />
</code><br />
<br />
===IN===<br />
Das logische Gegenteil zu NOT IN ist entsprechend IN.<br />
Dieses Schlüsselwort kann man u.a. verwenden, wenn man in einer Abfrage zwei Datensätze einer Entitätsmenge hat.<br />
Beispiel: Welche Schüler sind in der selben Klasse wie Anne Ebert?<br />
<br />
Idee: In der äußeren Abfrage werden die Schüler gesucht; mit IN kann man dann die klasse_id von Anne Ebert angeben.<br />
<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
WHERE s.klasse_id <u>'''IN'''</u><br />
(<br />
SELECT s2.klasse_id<br />
FROM schueler s2<br />
WHERE s2.name = 'Ebert'<br />
)<br />
</code><br />
<br />
===Kartesisches Produkt===<br />
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.<br />
<br />
''Kurz: Jeder mit jedem''.<br />
<br />
Formuliere eine Abfrage für das kartesische Produkt von den Tabellen klasse und schueler. <br />
<br />
<code><br />
SELECT *<br />
FROM <u>'''klasse k, schueler s'''</u> <br />
</code><br />
<br />
Diese Abfrage liefert als Ergebnis "Jeder mit jedem". Inhaltlich ist das nicht sinnvoll.<br />
<br />
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]]<br />
<br />
<br />
===Abgleich zwischen mehreren Tabellen===<br />
Formuliere eine Abfrage, die angibt, in welchen Räumen die Klasse 8a unterrichtet wird.<br />
Die Abfrage läuft über die Tabellen klasse, unterricht und raum.<br />
<br />
<code><br />
SELECT r.nummer<br />
FROM klasse k, unterricht u, raum r <br />
<u>'''WHERE r.id=u.raum_id'''</u><br />
<u>'''AND u.klasse_id=k.id'''</u><br />
AND k.name = '8a'<br />
</code><br />
<br />
'''Wichtig:''' bei Abfragen über mehrere Tabellen braucht man einen Abgleich weniger als man Tabellen abfragt.<br />
<br />
Im Beispiel werden drei Tabellen abgefragt; deswegen braucht man zwei Abgleiche.<br />
<br />
===Join===<br />
Join ist die Bildung eines [[SQL#Kartesisches_Produkt|kartesischen Produktes]] gefolgt von einer Selektion, die den (richtigen) Abgleich zwischen den beiden Tabellen leistet.<br />
<br />
Beispiel: Eine Liste der Schüler, in der für jeden Schüler vermerkt wird, in welcher Klasse er ist.<br />
<br />
<code><br />
SELECT s.name AS schuelername, k.name AS klassename<br />
FROM schueler s <u>'''JOIN'''</u> klasse k<br />
'''ON''' s.klasse_id = k.id<br />
</code><br />
<br />
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.<br />
<br />
Der Join entspricht der [[SQL#SQL-Abfrage über mehrere verknüpfte Tabellen|SQL-Abfrage über mehrere verknüpfte Tabellen]]<br />
<br />
===Left-Join===<br />
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.<br />
<br />
Formuliere eine Abfrage, die einen Left-Join zwischen den Tabellen klasse und schueler durchführt.<br />
Bewerte das Ergebnis inhaltlich: In welchen Zusammenhängen braucht man Left-Join?<br />
<br />
<code><br />
SELECT s.name AS schuelername, k.name AS klassename<br />
FROM schueler s <u>'''LEFT JOIN'''</u> klasse k<br />
<u>'''ON'''</u> s.klasse_id = k.id<br />
</code><br />
<br />
Beim LEFT JOIN werden ALLE Daten der LINKEN Entitätsmenge angezeigt. Im Beispiel werden also auch die Schüler angezeigt, die keine Klasse haben.<br />
<br />
===Right-Join===<br />
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.<br />
<br />
Formuliere eine Abfrage, die einen Right-Join zwischen den Tabellen klasse und schueler durchführt. <br />
<br />
<code><br />
SELECT s.name AS schuelername, k.name AS klassename<br />
FROM schueler s <u>'''RIGHT JOIN'''</u> klasse k<br />
<u>'''ON'''</u> s.klasse_id = k.id<br />
</code><br />
<br />
Beim RIGHT JOIN werden ALLE Daten der RECHTEN Entitätsmenge angezeigt. Im Beispiel werden also auch die Klassen angezeigt, die keine Schüler haben.<br />
<br />
===LEFT JOIN (bzw. RIGHT JOIN) über 3 oder mehr Tabellen ===<br />
Wenn man einen LEFT JOIN über insgesamt 3 Tabellen machen will, verwendet man am einfachsten zwei LEFT JOIN. <br/><br />
<br />
Beispiel: Eine Liste <u>aller</u> Schüler, in der steht, welche AGs sie belegen.<br />
<code><br />
SELECT s.name as schueler, a.name as ag<br />
FROM schueler s<br />
LEFT JOIN teilnahme t<br />
ON s.id = t.schueler_id<br />
LEFT JOIN ag a<br />
ON t.ag_id = a.id<br />
</code><br />
<br />
===IS NULL===<br />
Formuliere eine Abfrage, die alle Schüler zurückgibt, die keine Klasse haben.<br />
<br />
<code><br />
SELECT s.name AS schuelername, k.name AS klassename<br />
FROM schueler s LEFT JOIN klasse k<br />
ON s.klasse_id = k.id<br />
WHERE k.id <u>'''IS NULL'''</u><br />
</code><br />
<br />
Beim LEFT JOIN werden ALLE Daten der LINKEN Entitätsmenge angezeigt, also auch die Schüler, die keine Klasse haben.<br />
Diese Schüler werden durch <code>k.id IS NULL ausgewählt</code>.<br />
<br />
===Abfragen, bei denen man mehrere Variablen einer Entitätsmenge braucht===<br />
Formuliere eine Abfrage, die alle Räume wiedergibt, die mehr Plätze haben als Raum R203.<br />
<br />
''Idee: ''<br />
* ''Man hat den <u>bekannten</u> Raum r1 mit der Nummer "R203".''<br />
* ''Außerdem hat man den <u>gesuchten</u> Raum r2, der mehr Plätze hat als Raum r1.''<br />
<br />
<code><br />
SELECT r2.nummer<br />
FROM <u>'''raum r1'''</u>, <u>'''raum r2'''</u><br />
WHERE r1.nummer = "R203"<br />
AND r2.plaetze > r1.plaetze<br />
</code><br />
<br />
=Abfragen über selbstdefinierte Tabellen=<br />
<br />
'''Man kann die Tabellen, die man bei FROM angibt, durch eigene SELECT-Anfrage selber definieren.'''<br />
<br />
Die selbstdefinierten Tabellen müssen <u>mit einem Alias benannt</u> und <u>durch ein Komma voneinander getrennt</u> werden.<br/>Dann können sie wie "normale" Tabellen genutzt werden.<br />
<br />
<br />
'''Beispiel:'''<br />
''Eine Liste der Klassen, in der steht, wieviel Prozent Sportunterricht sie haben.''<br />
<br />
<code><br />
SELECT gesamtstunden.klasse AS klasse, sportstunden.stunden/gesamtstunden.stunden * 100 AS prozent<br />
FROM<br />
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden<br />
FROM klasse k LEFT JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
GROUP BY k.name<br />
) <u>AS gesamtstunden</u><br />
<u>'''LEFT JOIN'''</u><br />
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden<br />
FROM klasse k, unterricht u<br />
WHERE k.id = u.klasse_id<br />
AND u.fach = 'Sport'<br />
GROUP BY k.name<br />
) <u>AS sportstunden</u>'''<br />
<u>'''ON sportstunden.klasse = gesamtstunden.klasse'''</u><br />
</code><br />
<br />
<br />
'''Erläuterung:'''<br />
<br />
* In FROM werden zwei Tabellen definiert: Die Tabelle '''gesamtstunden''' und die Tabelle '''sportstunden'''.<br />
* Diese Tabellen werden mit einem '''LEFT JOIN ... ON''' verknüpft.<br />
* Außerdem erhalten sie mithilfe von AS Aliasnamen: '''AS gesamtstunden''' (bzw. '''AS sportstunden''').<br />
* Mithilfe dieser Aliasnamen kann die äußere Abfrage auf die beiden Tabellen zugreifen.<br />
<br />
<br />
'''WICHTIG:'''<br />
Man muss jeder inneren SELECT-Abfrage mithilfe von '''AS''' einen '''Namen''' geben - nur dann ist sie in der äußeren SELECT-Abfrage ansprechbar!<br />
<br />
=SQL analysieren=<br />
In Klausuren (auch im Abi) muss SQL analysiert werden.<br />
<br />
Meistens muss man dabei ein SQL-Statement auf vorliegende Tabellen anwenden; es kann aber auch vorkommen, dass man ein SQL-Statement erläutern muss.<br />
<br />
Dafür wird hier ein '''Beispiel''' gegeben.<br />
<br />
'''SQL-Statement:'''<br />
<br />
<code><br />
SELECT gesamtstunden.klasse AS klasse, sportstunden.stunden/gesamtstunden.stunden * 100 AS prozent<br />
FROM<br />
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden<br />
FROM klasse k LEFT JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
GROUP BY k.name<br />
) <u>AS gesamtstunden</u><br />
<u>'''LEFT JOIN'''</u><br />
(SELECT k.name AS klasse, SUM(u.stunden) AS stunden<br />
FROM klasse k, unterricht u<br />
WHERE k.id = u.klasse_id<br />
AND u.fach = 'Sport'<br />
GROUP BY k.name<br />
) <u>AS sportstunden</u>'''<br />
<u>'''ON sportstunden.klasse = gesamtstunden.klasse'''</u><br />
</code><br />
<br />
'''Aufgaben:'''<br />
# Erläutern Sie die '''Funktionsweise''' dieser SQL-Abfrage.<br />
# Erläutern Sie, welchem '''Zweck''' diese SQL-Abfrage dient.<br />
<br />
Folgendermaßen könnte eine Bearbeitung aussehen; wichtige Schlüsselwörter und Passagen sind <u>unterstrichen</u>.<br />
<br />
'''Funktionsweise:'''<br />
<br />
Die SQL-Abfrage besteht aus einer <u>äußeren Abfrage</u>, die auf <u>zwei selbstdefinierte</u> Tabellen zugreift.<br />
Der ersten selbstdefinierten Tabelle wurde mit "AS gesamtstunden" <u>der Name <code>gesamtstunden</code></u> gegeben, der zweiten selbstdefinierten Tabelle <u>der Name <code>sportstunden</code></u>.<br />
<br />
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.<br />
<br />
<u>In der äußeren Abfrage werden diese beiden selbstdefinierten Tabellen mithilfe eines LEFT JOIN über die Spalten sportstunden.klasse = gesamtstunden.klasse verknüpft.<br />
<br />
So werden in der Ergebnistabellen alle Zeilen der Tabelle <code>gesamtstunden</code> berücksichtigt, aber nicht unbedingt alle Zeilen der Tabelle <code>sportstunden</code>.</u><br />
<br />
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.<br />
<br />
'''Zweck:'''<br />
<br />
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.<br />
<br />
=HAVING=<br />
'''<font color='red'>Nicht abiturrelevant, aber sehr nützlich!</font>'''<br />
<br />
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.<br />
<br />
Das kann man mit <code>WHERE</code> nicht tun, denn <code>WHERE</code> funktioniert nur für "fest" definierte Zahlen!<br />
<br />
Für diesen Fall wurde das Schlüsselwort <code>HAVING</code> entwickelt.<br />
<br />
<br />
'''Beispiel:'''<br />
Eine Liste der Fächer, in der die Gesamtzahl der Stunden vermerkt ist, die sie unterrichtet werden. <u>Es sollen nur Fächer aufgeführt werden, die mehr als 7 Stunden unterrichtet werden</u>.<br />
<br />
''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.''<br />
<br />
''Lösen lässt sich das mit <code>HAVING</code>:<br />
<br />
<code><br />
SELECT u.fach, SUM(u.stunden) AS stunden<br />
FROM unterricht u<br />
GROUP BY u.fach<br />
<u>HAVING stunden > 7</u><br />
ORDER BY stunden DESC<br />
</code><br />
<br />
=Mit Java auf eine SQL-Datenbank zugreifen=<br />
Das wird hier erklärt: [[Java-SQL]]<br />
<br />
=ChatGPT nutzen um SQL zu schreiben=<br />
<br />
''Last not least will ich nicht verheimlichen, dass ChatGPT ein großartiges Hilfsmittel ist, um SQL zu schreiben!''<br />
<br />
==Erklärvideo==<br />
[https://youtu.be/GohWF9SnhWM ChatGPT nutzen, um SQL zu schreiben]<br />
<br />
==Best practices==<br />
''Bei unseren ersten "Gehversuchen" mit der SQL-Programmierung mit ChatGPT haben wir festgestellt:''<br />
* ''ChatGPT kann extrem cool SQL programmieren!!<br/>Es verfügt über einen SQL-Wortschatz, von dem selbst die Informatik-Lehrer noch nie gehört haben!''<br />
* '''''ABER:''' ChatGPT ist ziemlich begriffsstutzig! Man muss sehr genau erklären, was man will.''<br />
<br />
'''Empfehlungen:'''<br />
<br />
# Zu Anfang: '''Kontext herstellen!''' (-> Datenbankschema!)<br />
# '''Genau''' mitteilen, was man will, mit '''Fachbegriffen'''.<br />
# '''Testen''':<br/>Natürlich macht ChatGPT auch beim Programmieren Fehler. <br/>Der große Vorteil ist aber, dass man das - mit gut gewählten Beispielen - direkt überprüfen kann!<br/>Und wenn der SQL-Code einen Fehler hat, dann hilft nur...<br />
# '''„Nachkarten“:'''<br/>''Das ist sehr wichtig! Denn mit etwas Hartnäckigkeit kann man ChatGPT dazu bringen, das Richtige zu tun!''<br/>Für das "Nachkarten" empfiehlt sich:<br />
## Fehlermeldungen von SQL an ChatGPT weiter geben.<br />
## Fachbegriffe verwenden<br />
## Beziehungen klären <br/>z.B.: "Die Tabelle schueler ist über die Tabelle klasse mit der Tabelle unterricht verknüpft."<br/>z.B.: "Fach ist ein Attribut der Tabelle unterricht."<br />
## Gegebenenfalls SQL-Schlüsselwörter vorgeben: <br/>z.B. "Verwende NOT IN"<br />
<br />
==Vorteile==<br />
* ChatGPT steht ein sehr breites SQL-Vokabular zur Verfügung!<br/>Da sind Schlüsselwörter dabei, die man selber höchstens zum "passiven" Wortschatz zählen würde.<br />
* ChatGPT kann (wenn alles gut geht) SQL-Statements von ziemlicher Eleganz entwickeln. <br />
* Wenn man das Datenbankschema mitteilt und die Tabellen und Attribute verständlich benannt hat, dann kann sich ChatGPT auf einen beliebigen Kontext einstellen.<br />
* Außerdem geht es natürlich extrem schnell.<br />
<br />
==Datenbankschema für den Test==<br />
''Das Datenbankschema muss man direkt am Anfang mitteilen!''<br />
<code><br />
schueler(<u>id</u>,↑klasse_id,name,vorname)<br />
klasse(<u>id</u>,↑klassenlehrer_id,name)<br />
lehrer(<u>id</u>,name,vorname)<br />
unterricht(<u>id</u>,↑klasse_id,↑lehrer_id,↑raum_id,fach,stunden)<br />
raum(<u>id</u>,nummer,etage,plaetze)<br />
ag(<u>id</u>,↑lehrer_id,name)<br />
teilnahme(<u>↑schueler_id</u>,<u>↑ag_id</u>)<br />
</code><br />
<br />
Testen kann man wie üblich hier:<br />
<br />
[https://sibiwiki.de/sql/ sibiwiki.de/sql]<br />
<br />
(Zugangsdaten beim Informatik-Lehrer am SIBI.)<br />
<br />
Wer nicht am SIBI ist, kann sich einen Dump der Datenbank Schule hier herunterladen:<br/>[[Datei:Beispieldatenbank-schule.zip]]</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=SQL-Aufgaben-L%C3%B6sungen&diff=3661SQL-Aufgaben-Lösungen2024-01-23T17:38:38Z<p>Akaibel: /* ORDER BY, GROUP BY, COUNT, SUM, AVG, MAX, MIN, AS */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<br />
Hier finden sich die Lösungen zu den '''[[SQL-Aufgaben]]'''.<br />
<br />
=Beispieldatenbank Schule=<br />
* Die Lösungen beziehen sich auf die Beispieldatenbank ''Schule''.<br />
<br />
* An der Beispieldatenbank Schule können alle möglichen Datenbankabfragen durchprobiert werden.<br />
* Die Beispieldatenbank ist mit Absicht sehr schmal gehalten, damit man die Ergebnisse von SQL-Abfragen noch überprüfen kann.<br />
* Testen kann man SQL-Abfragen auf der '''[http://sibi-wiki.de/sql/ Online-Datenbank "Schule"]'''. <br/>Die Zugangsdaten gibt's bei Herrn Kaibel.<br />
** ''Wer nicht am SIBI ist, kann hier einen SQL-Dump der Beispieldatenbank Schule herunterladen: <br/>[[Datei:Beispieldatenbank-schule.zip]]''<br />
<br />
[[Datei:Beispieldatenbank-schule.jpg]]<br />
<br />
=Eine Tabelle=<br />
Die folgenden Aufgaben beziehen sich auf nur eine Tabelle.<br />
==SELECT, FROM, WHERE, ORDER BY, DISTINCT ==<br />
Die folgenden Abfragen benutzen die Befehle SELECT, FROM, WHERE und ggf. ORDER BY.<br />
* Eine Liste aller Schüler mit Name und Vorname, alphabetisch sortiert nach dem Namen.<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
ORDER BY s.name<br />
</code><br />
<br />
* Eine Liste der Räume: Raumnummer und Anzahl der Plätze, sortiert nach der Anzahl der Plätze und zwar so, dass die großen Räume zuerst kommen.<br />
<code><br />
SELECT r.nummer, r.plaetze<br />
FROM raum r<br />
ORDER BY r.plaetze '''DESC'''<br />
</code><br />
* Eine Liste der Etagen in dem Gebäude; jede Etage soll in der Liste nur einmal erscheinen.<br />
<code><br />
SELECT '''DISTINCT''' r.etage<br />
FROM raum r<br />
</code><br />
<br />
==Aggregatfunktionen: COUNT, SUM, AVG, MAX, MIN==<br />
* Wieviele Schüler gibt es insgesamt?<br />
<code><br />
SELECT '''COUNT(*)'''<br />
FROM schueler s<br />
</code><br />
* Wieviele Stunden Unterricht werden insgesamt erteilt?<br />
<code><br />
SELECT '''SUM(u.stunden)'''<br />
FROM unterricht u<br />
</code><br />
* Wieviele Stunden Sport werden erteilt?<br />
<code><br />
SELECT '''SUM(u.stunden)'''<br />
FROM unterricht u<br />
WHERE u.fach = 'Sport'<br />
</code><br />
* Wieviele Plätze hat der größte Raum?<br />
<code><br />
SELECT '''MAX(r.plaetze)'''<br />
FROM raum r<br />
</code><br />
* Wieviele Plätze haben die Räume in der oberen Etage durchschnittlich?<br />
<code><br />
SELECT '''AVG(r.plaetze)'''<br />
FROM raum r<br />
WHERE r.etage='oben'<br />
</code><br />
<br />
==GROUP BY, AS==<br />
Die folgenden Abfragen benutzen ''zusätzlich'' die Befehle GROUP BY und AS.<br />
*Eine Liste der Etagen, in der vermerkt ist, wieviele Räume es jeweils in der Etage gibt.<br />
<code><br />
SELECT r.etage, COUNT(*)<br />
FROM raum r<br />
'''GROUP BY r.etage'''<br />
</code><br />
<br />
* Eine Liste der Etagen, in der vermerkt ist, wieviele Plätze es jeweils in der Etage gibt.<br />
<code><br />
SELECT r.etage, SUM(r.plaetze)<br />
FROM raum r<br />
'''GROUP BY r.etage'''<br />
</code><br />
<br />
* Eine Liste aller Unterrichtsfächer, in der steht, wieviele Stunden sie jeweils unterrichtet werden; die Unterrichtsfächer mit vielen Stunden sollen oben stehen.<br />
<code><br />
SELECT u.fach, SUM(u.stunden) '''AS summe'''<br />
FROM unterricht u<br />
'''GROUP BY u.fach'''<br />
'''ORDER BY summe DESC'''<br />
</code><br />
<br />
=Mehrere Tabellen=<br />
Die folgenden Abfragen beziehen sich auf mehrere Tabellen. Dafür braucht man folgende Technik: [[SQL#Join|SQL Join]]<br />
<br />
==SELECT, FROM, WHERE==<br />
Hier werden nur die Befehle SELECT, FROM und WHERE benutzt.<br />
*Eine Liste der Schüler, aus der hervorgeht, in welcher Klasse sie jeweils sind.<br />
<code><br />
SELECT s.name, s.vorname, k.name<br />
FROM schueler s<br />
'''JOIN''' klasse k<br />
'''ON''' s.klasse_id = k.id<br />
</code><br />
* Eine Liste der Klassen, jeweils mit Klassenlehrer.<br />
<code><br />
SELECT k.name, l.name<br />
FROM klasse k <br />
'''JOIN''' lehrer l<br />
'''ON''' k.klassenlehrer_id = l.id<br />
</code><br />
* Eine Liste der Unterrichtsfächer der Klasse 8B.<br />
<code><br />
SELECT u.fach<br />
FROM klasse k<br />
'''JOIN''' unterricht u<br />
'''ON''' k.id = u.klasse_id<br />
WHERE k.name = '8B'<br />
</code><br />
* Eine Liste der Räume, in denen die 8B Unterricht hat.<br />
<code><br />
SELECT r.nummer<br />
FROM klasse k <br />
'''JOIN''' unterricht u<br />
'''ON''' k.id = u.klasse_id<br />
'''JOIN''' raum r<br />
'''ON''' u.raum_id = r.id<br />
WHERE k.name = '8B'<br />
</code><br />
* Eine Liste der Schüler, die Unterricht in Raum R112 Unterricht haben.<br />
<code><br />
SELECT s.name<br />
FROM schueler s<br />
'''JOIN''' klasse k<br />
'''ON''' s.klasse_id = k.id<br />
'''JOIN''' unterricht u<br />
'''ON''' k.id = u.klasse_id<br />
'''JOIN''' raum r<br />
'''ON''' u.raum_id = r.id<br />
WHERE r.nummer = 'R112'<br />
</code><br />
<br />
==ORDER BY, GROUP BY, COUNT, SUM, AVG, MAX, MIN, AS==<br />
* Eine Liste der Klassen mit der Anzahl der Schüler; sortiert nach der Anzahl der Schüler.<br />
<code><br />
SELECT k.name, COUNT(s.id)<br />
FROM klasse k JOIN schueler s<br />
ON k.id = s.klasse_id<br />
'''GROUP BY''' k.id<br />
</code><br />
* Eine Liste der Klassen, aus der hervorgeht, wieviele Stunden Unterricht die jeweilige Klasse hat. Die Liste soll nach der Anzahl der Stunden sortiert sein.<br />
<code><br />
SELECT k.name, SUM(u.stunden) '''AS anzahl'''<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
'''GROUP BY''' k.id<br />
ORDER BY anzahl DESC<br />
</code><br />
* Die Klasse, die am meisten Unterricht hat; mit der Anzahl der Unterrichtsstunden.<br/>''Man addiert für jede Klasse die Unterrichtsstunden, sortiert dann nach der Stundenzahl absteigend, und führt dann LIMIT 1 aus, um nur die erste Zeile zu bekommen.''<br />
<code><br />
SELECT k.name, SUM(u.stunden) '''AS anzahl'''<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
GROUP BY k.id<br />
ORDER BY anzahl DESC<br />
'''LIMIT 1'''<br />
</code><br />
* Eine Liste der Räume, aus der hervorgeht, wie viele Stunden Unterricht in jedem Raum erteilt wird.<br />
<code><br />
SELECT r.nummer, SUM(u.stunden) AS anzahl<br />
FROM raum r<br />
LEFT JOIN unterricht u<br />
ON r.id = u.raum_id<br />
GROUP BY r.id<br />
</code><br />
* "Lehrerraumprinzip": Eine Liste der Lehrer, in der für jeden Lehrer vermerkt ist, in welchem Raum er am wie viele Stunden unterrichtet.<br/>''Hinweis: Man braucht ein GROUP BY für zwei Spalten: GROUP BY l.id, r.id''<br />
<code><br />
SELECT l.name, r.nummer, SUM(u.stunden) AS anzahl<br />
FROM lehrer l<br />
JOIN unterricht u<br />
ON l.id = u.lehrer_id<br />
JOIN raum r<br />
ON u.raum_id = r.id<br />
'''GROUP BY l.id, r.id'''<br />
ORDER BY l.name, r.nummer<br />
</code><br />
<br />
==UNION==<br />
* Eine Liste, in der Vor- und Nachnamen von Lehrern und Schülern auftauchen.<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
'''UNION'''<br />
SELECT l.name, l.vorname<br />
FROM lehrer l<br />
</code><br />
* Disziplinarkonferenz für Schüler Schmidt: Eingeladen werden seine Fachlehrer und alle Klassenlehrer.<br />
<code><br />
SELECT l.name, l.vorname<br />
FROM lehrer l<br />
JOIN unterricht u<br />
ON l.id = u.lehrer_id<br />
JOIN klasse k<br />
ON u.klasse_id = k.id<br />
JOIN schueler s<br />
ON k.id = s.klasse_id<br />
WHERE s.name = 'Schmidt'<br />
'''UNION'''<br />
SELECT l.name, l.vorname<br />
FROM lehrer l<br />
JOIN klasse k<br />
ON l.id = k.klassenlehrer_id<br />
JOIN schueler s<br />
ON k.id = s.klasse_id<br />
WHERE s.name = 'Schmidt'<br />
</code><br />
* "Die Sportler: " Eine Liste, in der alle Schüler und Lehrer vermerkt werden, die mit Sport etwas zu tun haben.<br />
<code>TODO</code><br />
<br />
==IN, NOT IN==<br />
* Welche Klassen haben keinen Sportunterricht?<br />
<code><br />
SELECT k.name<br />
FROM klasse k<br />
WHERE k.id '''NOT IN'''<br />
(<br />
SELECT u.klasse_id<br />
FROM unterricht u<br />
WHERE u.fach = 'Sport'<br />
)<br />
</code><br />
* In welchen Räumen findet nie Sport statt?<br />
<code><br />
SELECT r.nummer <br />
FROM raum r<br />
WHERE r.id '''NOT IN'''<br />
(<br />
SELECT u.raum_id<br />
FROM unterricht u<br />
WHERE u.fach = 'Sport'<br />
)<br />
</code><br />
* Welche Schüler sind Klassenkameraden von Anne Ebert?<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
WHERE s.klasse_id '''IN'''<br />
(<br />
SELECT s2.klasse_id<br />
FROM schueler s2<br />
WHERE s2.name = 'Ebert'<br />
)<br />
</code><br />
* Welche Lehrer sind Fachkollegen von Josef Zimmermann? (Es reicht, dass sie ein gemeinsames Fach haben.)<br />
<code><br />
SELECT DISTINCT l.name<br />
FROM lehrer l<br />
JOIN unterricht u<br />
ON l.id = u.lehrer_id<br />
WHERE u.fach '''IN'''<br />
(<br />
SELECT u2.fach<br />
FROM lehrer l2<br />
JOIN unterricht u2<br />
ON l2.id = u2.lehrer_id<br />
WHERE l2.name = 'Zimmermann'<br />
)<br />
</code><br />
<br />
=LEFT JOIN, RIGHT JOIN=<br />
Jetzt sollen bei der Abfrage über mehrere Tabellen auch die Datensätze berücksichtigt werden, die keine Entsprechung in der anderen Tabelle haben, wie z.B. der Schüler Wiesenhoff, der in keiner Klasse ist. Dafür braucht man folgende Technik: '''[[SQL#Left-Join|Left Join / Right Join]]'''<br />
* Eine Liste ALLER Schüler, aus der hervorgeht, in welcher Klasse sie jeweils sind. Auch Schüler ohne Klasse (z.B. Wiesenhoff) sollen aufgeführt werden.<br />
<br />
<code><br />
SELECT s.name, s.vorname, k.name<br />
FROM schueler s<br />
'''LEFT JOIN''' klasse k<br />
ON s.klasse_id = k.id<br />
</code><br />
* Eine Liste ALLER Klassen, jeweils mit Klassenlehrer.<br />
<code> TODO</code><br />
==LEFT JOIN, RIGHT JOIN und UNION==<br />
Manchmal braucht man für jeden Eintrag in der Liste eine Zahl, auch wenn die Entsprechung in einer Tabelle fehlt.<br />
<br />
Dann muss man zwei SQL-Abfragen mit UNION kombinieren:<br/><br />
- eine Abfrage über mehrere Tabellen<br/><br />
<br />
-einen LEFT JOIN für die Datensätze, denen die Entsprechung fehlt.<br/><br />
*Eine Liste ALLER Schüler, in der steht, wieviel Unterricht sie haben. Für die Schüler Zimmermann und Wiesenhoff soll in dieser Übersicht als Stundenzahl '0' erscheinen.<br />
<br />
<code><br />
SELECT s.name, SUM(u.stunden) AS anzahl<br />
FROM schueler s '''JOIN''' unterricht u<br />
ON s.klasse_id = u.klasse_id<br />
GROUP BY s.id<br />
'''UNION'''<br />
SELECT s.name, '''0 AS anzahl'''<br />
FROM schueler s '''LEFT JOIN''' unterricht u<br />
ON s.klasse_id = u.klasse_id<br />
'''WHERE u.klasse_id IS NULL'''<br />
</code><br />
* Eine Liste aller Räume, in der steht, wie viele verschiedene Klassen dort Unterricht haben. Bei Räumen, in denen kein Unterricht stattfindet, soll eine 0 stehen.<br />
<code> TODO</code><br />
<br />
==IS NULL==<br />
Hier sollen die "Drückeberger" gesucht werden, d.h. man ist nur an Datensätzen interessiert, die keine Entsprechung in der anderen Tabelle haben.<br />
* Eine Liste der Schüler, die keine Klasse haben.<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s LEFT JOIN unterricht u<br />
ON s.klasse_id = u.klasse_id<br />
'''WHERE u.klasse_id IS NULL'''<br />
</code><br />
* Eine Liste der Lehrer, die nicht unterrichten.<br />
<code> TODO</code><br />
* Eine Liste der Räume, in denen kein Unterricht stattfindet.<br />
<code> TODO</code><br />
<br />
=Abfragen mit mehreren Variablen für eine Tabelle=<br />
* Welche Schüler sind in der Klasse von Anne Ebert?<br/>''Es gibt zwei Schüler: Anne Ebert (s1) und der "unbekannte Schüler" aus ihrer Klasse (s2).''<br />
<code><br />
SELECT s2.name, s2.vorname<br />
FROM schueler s1 JOIN schueler s2<br />
ON s1.klasse_id = s2.klasse_id<br />
WHERE s1.name = 'Ebert' AND s1.vorname = 'Anne'<br />
AND s2.id != s1.id<br />
</code><br />
* Welche Fachlehrer unterrichten in der Klasse von Lehrer Buttenmüller?<br/>''Es gibt zwei Lehrer: Den Lehrer Buttenmüller (l1) und den "unbekannten Fachlehrer" seiner Klasse (l2).<br />
<code><br />
SELECT l2.name, l2.vorname<br />
FROM lehrer l2<br />
JOIN unterricht u<br />
ON l2.id = u.lehrer_id<br />
JOIN klasse k<br />
ON u.klasse_id = k.id<br />
JOIN lehrer l1<br />
ON k.klassenlehrer_id = l1.id<br />
WHERE l1.name = 'Buttenmüller'<br />
</code><br />
<br />
=SQL-Abfragen über selbstdefinierte Tabellen=<br />
Für die folgenden Fragen braucht man [[SQL#SQL-Abfragen über selbstdefinierte Tabellen|SQL-Abfragen über selbstdefinierte Tabellen]].<br />
* Eine Liste aller Klassen, in der für jede Klasse vermerkt ist, wie viele Stunden Geschichte und wie viele Stunden Deutsch sie hat. (D.h. 3 Spalten)<br/>''Es gibt eine innere Abfrage für Deutsch und eine für Geschichte.''<br />
<code><br />
SELECT deutsch.klasse AS klasse, deutsch.stunden AS deutsch, geschichte.stunden AS geschichte<br />
FROM<br />
(<br />
SELECT k.name '''AS klasse''', SUM(u.stunden) '''AS stunden'''<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
WHERE u.fach = 'deutsch'<br />
GROUP BY k.id<br />
) '''AS deutsch , '''<br />
(<br />
SELECT k.name '''AS klasse''', SUM(u.stunden) '''AS stunden'''<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
WHERE u.fach = 'geschichte'<br />
GROUP BY k.id<br />
) '''AS geschichte '''<br />
'''WHERE geschichte.klasse = deutsch.klasse'''<br />
</code><br />
* Eine Liste aller Klassen, in der angezeigt wird, wieviel Prozent Sport sie haben.<br />
<code>TODO</code><br />
* Eine Liste aller Schüler, in der für jeden Schüler steht, wie viele AGs er belegt hat. Es sollen auch Schüler ohne AGs aufgeführt werden.<br/>''Innere Abfrage: ein LEFT JOIN über die Tabellen schueler und teilnahme''<br />
<code>TODO</code><br />
* Eine Liste der Fächer, in der die Anzahl der Unterrichtsstunden und der Prozentsatz am gesamt erteilten Unterricht aufgeführt ist. ''(Innere Tabelle: die Summe der Unterrichtsstunden)''<br />
<code>TODO</code><br />
* Wieviele Stunden Unterricht haben die Klassen durchschnittlich?<br/>''Als innere Tabelle hat man eine Liste der Klassen mit ihrer Stundenzahl. In dieser muss man ein UNION verwenden, damit die 8D, die gar keinen Unterricht hat, mitgezählt wird.''<br />
<code><br />
SELECT AVG(klassentabelle.gesamt)FROM<br />
(<br />
SELECT k.name AS name, SUM(u.stunden) AS gesamt<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
GROUP BY k.id<br />
UNION<br />
SELECT k.name AS name, 0 AS gesamt<br />
FROM klasse k LEFT JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
WHERE u.klasse_id IS NULL<br />
) '''AS klassentabelle'''</code><br />
* Die "Streber-Klassen": Welche Klassen haben überdurchschnittlich viele Stunden Unterricht?<br />
<code>TODO</code><br />
* Das Fach, das am meisten unterrichtet wird, mit Anzahl der Stunden.<br>''Zur Kontrolle: Deutsch.''<br />
<code>TODO</code><br />
* Eine Liste aller Schüler, in der für jeden Schüler vermerkt ist, wie viele Stunden er weniger hat als der Schüler mit der maximalen Stundenanzahl. <br> ''Zur Kontrolle: Die meisten Stunden hat Schwarzmüller mit 13 Stunden''<br />
<code>TODO</code><br />
<br />
=Weitere schwierige Abfragen=<br />
Für die folgenden Fragen muss man geeignete SQL-Sprachelemente kombinieren.<br />
# Raum R112 sieht immer furchtbar aus. Der Direktor möchte deswegen mit den Klassenlehrern von allen Klassen sprechen, die in R112 Unterricht haben.<br/>''JOIN über die Tabellen raum, unterricht, klasse, lehrer''<br />
# Wieviel Prozent der insgesamt erteilten Unterrichtsstunden sind Sportstunden?<br/>''zwei innere Abfragen: eine für die Gesamtzahl der Stunden, eine für den Sportunterricht.''<br />
# Welcher Lehrer unterrichtet am meisten? (Mit Angabe der Stundenzahl.)<br/>''GROUP BY , ORDER BY anzahl DESC und LIMIT 1''<br />
# Der Direktor hätte gerne eine Liste der Lehrer, in der aufgeführt wird, wie viele Unterrichtsstunden sie erteilen. Auch die "Drückeberger" sollen in der Liste aufgeführt werden (mit 0 Stunden).<br/>''Die "Drückeberger" muss man mit UNION anfügen. Für die Drückeberger braucht man LEFT JOIN und IS NULL.''<br />
# Eine Liste der Etagen mit den durchschnittlichen Raumgrößen. Die Liste soll nach den Durchschnittswerten sortiert werden.<br/>''AVG, GROUP BY, ORDER BY durchschnitt DESC<br />
# Eine Liste der Schüler, die nie in Raum R112 Unterricht haben.<br/>''NOT IN''<br />
# Eine Liste aller Schüler und Lehrer, die in Raum R112 Unterricht haben / unterrichten.<br/>''UNION''<br />
# In welchem Raum finden die meisten Unterrichtsstunden statt?<br/>''GROUP BY, ORDER BY anzahl DESC, LIMIT 1''<br />
# In welchen Räumen finden weniger Unterrichtsstunden statt als in Raum R112? Die Liste soll auch die Räume einschließen, in denen kein Unterricht stattfindet.<br/>''Zwei Räume: r1 ist Raum R112, r2 ist ein Raum, in dem weniger Unterricht ist.<br/>Die Räume, in denen gar kein Unterricht stattfindet muss man mit UNION anhängen.''<br />
# Eine Liste der Unterrichtsfächer, in der für jedes Fach vermerkt ist, wie viele Stunden in der unteren, in der mittleren bzw. in der oberen Etage unterrichtet werden.<br/>''GROUP BY über zwei Attribute''<br />
<code><br />
SELECT u.fach, r.etage, SUM(u.stunden)<br />
FROM unterricht u JOIN raum r<br />
ON u.raum_id = r.id<br />
'''GROUP BY u.fach, r.etage'''<br />
ORDER BY u.fach, r.etage<br />
</code><br />
<br />
=Gemischte Aufgaben (schwierig bis sehr schwierig)=<br />
<br />
Eine Liste der Klassen, die in Raum R112 Unterricht haben.<br/>''Ergebnis: 8A, 8C.''<br />
<code><br />
''JOIN über 3 Tabellen''<br />
<br />
SELECT k.name<br />
FROM klasse k JOIN unterricht u JOIN raum r<br />
ON k.id = u.klasse_id AND u.raum_id = r.id<br />
WHERE r.nummer = 'R112'<br />
</code><br />
Eine Liste aller AGs mit Teilnehmerzahl. <br/>''Ergebnis: Z.B. Fotografie 2<br/>''<br />
<br />
''JOIN über 2 Tabellen und GROUP BY''<br />
<code><br />
SELECT a.name, COUNT(t.schueler_id) AS anzahl<br />
FROM ag a JOIN teilnahme t<br />
ON a.id = t.ag_id<br />
GROUP BY a.id<br />
</code><br />
Eine Liste der Räume, in denen nie Deutsch stattfindet.<br/>''Ergebnis: R110, R306, Sporthalle (=wenig erstaunlich...), R208, R101''<br />
<br />
''Differenz''<br />
<code><br />
SELECT r.nummer<br />
FROM raum r<br />
WHERE r.id NOT IN<br />
( SELECT u.raum_id<br />
FROM unterricht u<br />
WHERE u.fach = 'Deutsch'<br />
)<br />
</code><br />
Eine Liste der Fachkollegen von Josef Zimmermann.<br/><br />
''Ergebnis: Erika Huber und Josef Zimmermann selber.''<br />
<br />
''Zwei Variablen für eine Entitätsmenge:''<br/><br />
''l1 = der gesuchte Lehrer; u1 = sein Unterricht''<br/><br />
''l2 = Lehrer Zimmermann; u2 = sein Unterricht''<br />
<code><br />
SELECT DISTINCT l1.name<br />
FROM lehrer l1<br />
JOIN unterricht u1<br />
JOIN unterricht u2<br />
JOIN lehrer l2<br />
ON l1.id = u1.lehrer_id<br />
AND u1.fach = u2.fach<br />
AND u2.lehrer_id = l2.id<br />
WHERE l2.name = 'Zimmermann'<br />
</code><br />
<br />
Eine Liste aller Schüler, in der aufgeführt wird, an welchen AGs sie teilnehmen. <br/><br />
Wenn ein Schüler an mehreren AGs teilnimmt, dann soll er mehrfach aufgeführt werden. <br/><br />
Schüler, die an keiner AG teilnehmen, sollen nicht aufgeführt werden.<br/><br />
''Ergebnis: Z.B. Johannes Meyer nimmt an Holzwerken und Fotografie teil.'' <br/><br />
''Die Schüler Zimmermann und Wiesenhoff tauchen in der Liste nicht auf.''<br />
<br />
''2x JOIN''<br />
<code><br />
SELECT s.name, a.name<br />
FROM schueler s JOIN teilnahme t JOIN ag a<br />
ON s.id = t.schueler_id AND t.ag_id = a.id<br />
</code><br />
Wie die vorhergehende Abfrage, aber: Auch Schüler, die an keiner AG teilnehmen, sollen aufgeführt werden.<br/><br />
''Ergebnis: Jetzt sollen die Schüler Zimmermann und Wiesenhoff auftauchen.''<br />
<br />
''1x LEFT JOIN, dann JOIN''<br />
<br />
<code><br />
SELECT s.name, a.name<br />
FROM schueler s LEFT JOIN (teilnahme t JOIN ag a)<br />
ON s.id = t.schueler_id AND t.ag_id = a.id<br />
</code><br />
Es soll eine Liste erstellt werden, aus der hervorgeht, wie viele Stunden jeder Lehrer arbeitet! <br/><br />
Dabei zählen die Unterrichtsstunden normal und jede AG, die ein Lehrer leitet, zählt 1 Stunde.<br/><br />
''Ergebnis: Z.B. für den Lehrer Zimmermann: 1AG + 4Deutsch + 4Deutsch + 2Geschichte = 11''<br />
<br />
''2 innere Abfragen.''<br />
''Es werden hier nur die Lehrer aufgeführt, die sowohl unterrichten als auch AGs haben.''<br />
<br />
<code><br />
SELECT ustunden.name AS name, ustunden.anzahl + agstunden.anzahl AS anzahl<br />
FROM<br />
( SELECT l.name AS name, SUM(u.stunden) AS anzahl<br />
FROM lehrer l, unterricht u<br />
WHERE l.id = u.lehrer_id<br />
GROUP BY l.name<br />
) AS ustunden<br />
,<br />
( SELECT l.name AS name, COUNT(*) AS anzahl<br />
FROM lehrer l, ag a<br />
WHERE l.id = a.lehrer_id<br />
GROUP BY l.name<br />
) AS agstunden<br />
WHERE ustunden.name = agstunden.name<br />
</code><br />
<br />
<br />
Eine Liste, in der alle Räume aufgeführt sind. <br/><br />
Zu jedem Raum soll in einer Spalte angegeben werden, wie viele Stunden Deutsch dort unterrichtet wird <br/><br />
und in einer zweiten Spalte, wie viele Stunden Englisch.<br/><br />
''Ergebnis: Z.B. R112: 4 Deutsch, 4 Englisch''<br />
<br />
''2 innere Abfragen''<br />
<br />
<code><br />
SELECT deutsch.raum, deutsch.stunden, englisch.stunden<br />
FROM<br />
(<br />
SELECT r.nummer AS raum, SUM(u.stunden) AS stunden<br />
FROM raum r JOIN unterricht u<br />
ON r.id = u.raum_id<br />
WHERE u.fach = 'deutsch'<br />
UNION<br />
SELECT r.nummer AS raum, 0 AS stunden<br />
FROM raum r<br />
WHERE r.id NOT IN<br />
(<br />
SELECT u.raum_id FROM unterricht u WHERE u.fach = 'deutsch'<br />
)<br />
) '''AS deutsch ,'''<br />
(<br />
SELECT r.nummer AS raum, SUM(u.stunden) AS stunden<br />
FROM raum r LEFT JOIN unterricht u<br />
ON r.id = u.raum_id<br />
WHERE u.fach = 'englisch'<br />
UNION<br />
SELECT r.nummer AS raum, 0 AS stunden<br />
FROM raum r<br />
WHERE r.id NOT IN<br />
(<br />
SELECT u.raum_id FROM unterricht u WHERE u.fach = 'englisch'<br />
)<br />
) '''AS englisch'''<br />
'''where deutsch.raum = englisch.raum'''<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=SQL-Aufgaben-L%C3%B6sungen&diff=3660SQL-Aufgaben-Lösungen2024-01-23T17:34:13Z<p>Akaibel: /* IN, NOT IN */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<br />
Hier finden sich die Lösungen zu den '''[[SQL-Aufgaben]]'''.<br />
<br />
=Beispieldatenbank Schule=<br />
* Die Lösungen beziehen sich auf die Beispieldatenbank ''Schule''.<br />
<br />
* An der Beispieldatenbank Schule können alle möglichen Datenbankabfragen durchprobiert werden.<br />
* Die Beispieldatenbank ist mit Absicht sehr schmal gehalten, damit man die Ergebnisse von SQL-Abfragen noch überprüfen kann.<br />
* Testen kann man SQL-Abfragen auf der '''[http://sibi-wiki.de/sql/ Online-Datenbank "Schule"]'''. <br/>Die Zugangsdaten gibt's bei Herrn Kaibel.<br />
** ''Wer nicht am SIBI ist, kann hier einen SQL-Dump der Beispieldatenbank Schule herunterladen: <br/>[[Datei:Beispieldatenbank-schule.zip]]''<br />
<br />
[[Datei:Beispieldatenbank-schule.jpg]]<br />
<br />
=Eine Tabelle=<br />
Die folgenden Aufgaben beziehen sich auf nur eine Tabelle.<br />
==SELECT, FROM, WHERE, ORDER BY, DISTINCT ==<br />
Die folgenden Abfragen benutzen die Befehle SELECT, FROM, WHERE und ggf. ORDER BY.<br />
* Eine Liste aller Schüler mit Name und Vorname, alphabetisch sortiert nach dem Namen.<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
ORDER BY s.name<br />
</code><br />
<br />
* Eine Liste der Räume: Raumnummer und Anzahl der Plätze, sortiert nach der Anzahl der Plätze und zwar so, dass die großen Räume zuerst kommen.<br />
<code><br />
SELECT r.nummer, r.plaetze<br />
FROM raum r<br />
ORDER BY r.plaetze '''DESC'''<br />
</code><br />
* Eine Liste der Etagen in dem Gebäude; jede Etage soll in der Liste nur einmal erscheinen.<br />
<code><br />
SELECT '''DISTINCT''' r.etage<br />
FROM raum r<br />
</code><br />
<br />
==Aggregatfunktionen: COUNT, SUM, AVG, MAX, MIN==<br />
* Wieviele Schüler gibt es insgesamt?<br />
<code><br />
SELECT '''COUNT(*)'''<br />
FROM schueler s<br />
</code><br />
* Wieviele Stunden Unterricht werden insgesamt erteilt?<br />
<code><br />
SELECT '''SUM(u.stunden)'''<br />
FROM unterricht u<br />
</code><br />
* Wieviele Stunden Sport werden erteilt?<br />
<code><br />
SELECT '''SUM(u.stunden)'''<br />
FROM unterricht u<br />
WHERE u.fach = 'Sport'<br />
</code><br />
* Wieviele Plätze hat der größte Raum?<br />
<code><br />
SELECT '''MAX(r.plaetze)'''<br />
FROM raum r<br />
</code><br />
* Wieviele Plätze haben die Räume in der oberen Etage durchschnittlich?<br />
<code><br />
SELECT '''AVG(r.plaetze)'''<br />
FROM raum r<br />
WHERE r.etage='oben'<br />
</code><br />
<br />
==GROUP BY, AS==<br />
Die folgenden Abfragen benutzen ''zusätzlich'' die Befehle GROUP BY und AS.<br />
*Eine Liste der Etagen, in der vermerkt ist, wieviele Räume es jeweils in der Etage gibt.<br />
<code><br />
SELECT r.etage, COUNT(*)<br />
FROM raum r<br />
'''GROUP BY r.etage'''<br />
</code><br />
<br />
* Eine Liste der Etagen, in der vermerkt ist, wieviele Plätze es jeweils in der Etage gibt.<br />
<code><br />
SELECT r.etage, SUM(r.plaetze)<br />
FROM raum r<br />
'''GROUP BY r.etage'''<br />
</code><br />
<br />
* Eine Liste aller Unterrichtsfächer, in der steht, wieviele Stunden sie jeweils unterrichtet werden; die Unterrichtsfächer mit vielen Stunden sollen oben stehen.<br />
<code><br />
SELECT u.fach, SUM(u.stunden) '''AS summe'''<br />
FROM unterricht u<br />
'''GROUP BY u.fach'''<br />
'''ORDER BY summe DESC'''<br />
</code><br />
<br />
=Mehrere Tabellen=<br />
Die folgenden Abfragen beziehen sich auf mehrere Tabellen. Dafür braucht man folgende Technik: [[SQL#Join|SQL Join]]<br />
<br />
==SELECT, FROM, WHERE==<br />
Hier werden nur die Befehle SELECT, FROM und WHERE benutzt.<br />
*Eine Liste der Schüler, aus der hervorgeht, in welcher Klasse sie jeweils sind.<br />
<code><br />
SELECT s.name, s.vorname, k.name<br />
FROM schueler s<br />
'''JOIN''' klasse k<br />
'''ON''' s.klasse_id = k.id<br />
</code><br />
* Eine Liste der Klassen, jeweils mit Klassenlehrer.<br />
<code><br />
SELECT k.name, l.name<br />
FROM klasse k <br />
'''JOIN''' lehrer l<br />
'''ON''' k.klassenlehrer_id = l.id<br />
</code><br />
* Eine Liste der Unterrichtsfächer der Klasse 8B.<br />
<code><br />
SELECT u.fach<br />
FROM klasse k<br />
'''JOIN''' unterricht u<br />
'''ON''' k.id = u.klasse_id<br />
WHERE k.name = '8B'<br />
</code><br />
* Eine Liste der Räume, in denen die 8B Unterricht hat.<br />
<code><br />
SELECT r.nummer<br />
FROM klasse k <br />
'''JOIN''' unterricht u<br />
'''ON''' k.id = u.klasse_id<br />
'''JOIN''' raum r<br />
'''ON''' u.raum_id = r.id<br />
WHERE k.name = '8B'<br />
</code><br />
* Eine Liste der Schüler, die Unterricht in Raum R112 Unterricht haben.<br />
<code><br />
SELECT s.name<br />
FROM schueler s<br />
'''JOIN''' klasse k<br />
'''ON''' s.klasse_id = k.id<br />
'''JOIN''' unterricht u<br />
'''ON''' k.id = u.klasse_id<br />
'''JOIN''' raum r<br />
'''ON''' u.raum_id = r.id<br />
WHERE r.nummer = 'R112'<br />
</code><br />
<br />
==ORDER BY, GROUP BY, COUNT, SUM, AVG, MAX, MIN, AS==<br />
* Eine Liste der Klassen mit der Anzahl der Schüler; sortiert nach der Anzahl der Schüler.<br />
<code><br />
SELECT k.name, COUNT(s.id)<br />
FROM klasse k JOIN schueler s<br />
ON k.id = s.klasse_id<br />
'''GROUP BY''' k.id<br />
</code><br />
* Eine Liste der Klassen, aus der hervorgeht, wieviele Stunden Unterricht die jeweilige Klasse hat. Die Liste soll nach der Anzahl der Stunden sortiert sein.<br />
<code><br />
SELECT k.name, SUM(u.stunden) '''AS anzahl'''<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
'''GROUP BY''' k.id<br />
ORDER BY anzahl DESC<br />
</code><br />
* Die Klasse, die am meisten Unterricht hat; mit der Anzahl der Unterrichtsstunden.<br/>''Man addiert für jede Klasse die Unterrichtsstunden, sortiert dann nach der Stundenzahl absteigend, und führt dann LIMIT 1 aus, um nur die erste Zeile zu bekommen.''<br />
<code><br />
SELECT k.name, SUM(u.stunden) '''AS anzahl'''<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
GROUP BY k.id<br />
ORDER BY anzahl DESC<br />
'''LIMIT 1'''<br />
</code><br />
* Eine Liste der Räume, aus der hervorgeht, wie viele Stunden Unterricht in jedem Raum erteilt wird.<br />
<code>TODO</code><br />
* "Lehrerraumprinzip": Eine Liste der Lehrer, in der für jeden Lehrer vermerkt ist, in welchem Raum er am wie viele Stunden unterrichtet.<br/>''Hinweis: Man braucht ein GROUP BY für zwei Spalten: GROUP BY l.id, r.id''<br />
<code><br />
SELECT l.name, r.nummer, SUM(u.stunden) AS anzahl<br />
FROM lehrer l<br />
JOIN unterricht u<br />
ON l.id = u.lehrer_id<br />
JOIN raum r<br />
ON u.raum_id = r.id<br />
'''GROUP BY l.id, r.id'''<br />
ORDER BY l.name, r.nummer<br />
</code><br />
<br />
==UNION==<br />
* Eine Liste, in der Vor- und Nachnamen von Lehrern und Schülern auftauchen.<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
'''UNION'''<br />
SELECT l.name, l.vorname<br />
FROM lehrer l<br />
</code><br />
* Disziplinarkonferenz für Schüler Schmidt: Eingeladen werden seine Fachlehrer und alle Klassenlehrer.<br />
<code><br />
SELECT l.name, l.vorname<br />
FROM lehrer l<br />
JOIN unterricht u<br />
ON l.id = u.lehrer_id<br />
JOIN klasse k<br />
ON u.klasse_id = k.id<br />
JOIN schueler s<br />
ON k.id = s.klasse_id<br />
WHERE s.name = 'Schmidt'<br />
'''UNION'''<br />
SELECT l.name, l.vorname<br />
FROM lehrer l<br />
JOIN klasse k<br />
ON l.id = k.klassenlehrer_id<br />
JOIN schueler s<br />
ON k.id = s.klasse_id<br />
WHERE s.name = 'Schmidt'<br />
</code><br />
* "Die Sportler: " Eine Liste, in der alle Schüler und Lehrer vermerkt werden, die mit Sport etwas zu tun haben.<br />
<code>TODO</code><br />
<br />
==IN, NOT IN==<br />
* Welche Klassen haben keinen Sportunterricht?<br />
<code><br />
SELECT k.name<br />
FROM klasse k<br />
WHERE k.id '''NOT IN'''<br />
(<br />
SELECT u.klasse_id<br />
FROM unterricht u<br />
WHERE u.fach = 'Sport'<br />
)<br />
</code><br />
* In welchen Räumen findet nie Sport statt?<br />
<code><br />
SELECT r.nummer <br />
FROM raum r<br />
WHERE r.id '''NOT IN'''<br />
(<br />
SELECT u.raum_id<br />
FROM unterricht u<br />
WHERE u.fach = 'Sport'<br />
)<br />
</code><br />
* Welche Schüler sind Klassenkameraden von Anne Ebert?<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s<br />
WHERE s.klasse_id '''IN'''<br />
(<br />
SELECT s2.klasse_id<br />
FROM schueler s2<br />
WHERE s2.name = 'Ebert'<br />
)<br />
</code><br />
* Welche Lehrer sind Fachkollegen von Josef Zimmermann? (Es reicht, dass sie ein gemeinsames Fach haben.)<br />
<code><br />
SELECT DISTINCT l.name<br />
FROM lehrer l<br />
JOIN unterricht u<br />
ON l.id = u.lehrer_id<br />
WHERE u.fach '''IN'''<br />
(<br />
SELECT u2.fach<br />
FROM lehrer l2<br />
JOIN unterricht u2<br />
ON l2.id = u2.lehrer_id<br />
WHERE l2.name = 'Zimmermann'<br />
)<br />
</code><br />
<br />
=LEFT JOIN, RIGHT JOIN=<br />
Jetzt sollen bei der Abfrage über mehrere Tabellen auch die Datensätze berücksichtigt werden, die keine Entsprechung in der anderen Tabelle haben, wie z.B. der Schüler Wiesenhoff, der in keiner Klasse ist. Dafür braucht man folgende Technik: '''[[SQL#Left-Join|Left Join / Right Join]]'''<br />
* Eine Liste ALLER Schüler, aus der hervorgeht, in welcher Klasse sie jeweils sind. Auch Schüler ohne Klasse (z.B. Wiesenhoff) sollen aufgeführt werden.<br />
<br />
<code><br />
SELECT s.name, s.vorname, k.name<br />
FROM schueler s<br />
'''LEFT JOIN''' klasse k<br />
ON s.klasse_id = k.id<br />
</code><br />
* Eine Liste ALLER Klassen, jeweils mit Klassenlehrer.<br />
<code> TODO</code><br />
==LEFT JOIN, RIGHT JOIN und UNION==<br />
Manchmal braucht man für jeden Eintrag in der Liste eine Zahl, auch wenn die Entsprechung in einer Tabelle fehlt.<br />
<br />
Dann muss man zwei SQL-Abfragen mit UNION kombinieren:<br/><br />
- eine Abfrage über mehrere Tabellen<br/><br />
<br />
-einen LEFT JOIN für die Datensätze, denen die Entsprechung fehlt.<br/><br />
*Eine Liste ALLER Schüler, in der steht, wieviel Unterricht sie haben. Für die Schüler Zimmermann und Wiesenhoff soll in dieser Übersicht als Stundenzahl '0' erscheinen.<br />
<br />
<code><br />
SELECT s.name, SUM(u.stunden) AS anzahl<br />
FROM schueler s '''JOIN''' unterricht u<br />
ON s.klasse_id = u.klasse_id<br />
GROUP BY s.id<br />
'''UNION'''<br />
SELECT s.name, '''0 AS anzahl'''<br />
FROM schueler s '''LEFT JOIN''' unterricht u<br />
ON s.klasse_id = u.klasse_id<br />
'''WHERE u.klasse_id IS NULL'''<br />
</code><br />
* Eine Liste aller Räume, in der steht, wie viele verschiedene Klassen dort Unterricht haben. Bei Räumen, in denen kein Unterricht stattfindet, soll eine 0 stehen.<br />
<code> TODO</code><br />
<br />
==IS NULL==<br />
Hier sollen die "Drückeberger" gesucht werden, d.h. man ist nur an Datensätzen interessiert, die keine Entsprechung in der anderen Tabelle haben.<br />
* Eine Liste der Schüler, die keine Klasse haben.<br />
<code><br />
SELECT s.name, s.vorname<br />
FROM schueler s LEFT JOIN unterricht u<br />
ON s.klasse_id = u.klasse_id<br />
'''WHERE u.klasse_id IS NULL'''<br />
</code><br />
* Eine Liste der Lehrer, die nicht unterrichten.<br />
<code> TODO</code><br />
* Eine Liste der Räume, in denen kein Unterricht stattfindet.<br />
<code> TODO</code><br />
<br />
=Abfragen mit mehreren Variablen für eine Tabelle=<br />
* Welche Schüler sind in der Klasse von Anne Ebert?<br/>''Es gibt zwei Schüler: Anne Ebert (s1) und der "unbekannte Schüler" aus ihrer Klasse (s2).''<br />
<code><br />
SELECT s2.name, s2.vorname<br />
FROM schueler s1 JOIN schueler s2<br />
ON s1.klasse_id = s2.klasse_id<br />
WHERE s1.name = 'Ebert' AND s1.vorname = 'Anne'<br />
AND s2.id != s1.id<br />
</code><br />
* Welche Fachlehrer unterrichten in der Klasse von Lehrer Buttenmüller?<br/>''Es gibt zwei Lehrer: Den Lehrer Buttenmüller (l1) und den "unbekannten Fachlehrer" seiner Klasse (l2).<br />
<code><br />
SELECT l2.name, l2.vorname<br />
FROM lehrer l2<br />
JOIN unterricht u<br />
ON l2.id = u.lehrer_id<br />
JOIN klasse k<br />
ON u.klasse_id = k.id<br />
JOIN lehrer l1<br />
ON k.klassenlehrer_id = l1.id<br />
WHERE l1.name = 'Buttenmüller'<br />
</code><br />
<br />
=SQL-Abfragen über selbstdefinierte Tabellen=<br />
Für die folgenden Fragen braucht man [[SQL#SQL-Abfragen über selbstdefinierte Tabellen|SQL-Abfragen über selbstdefinierte Tabellen]].<br />
* Eine Liste aller Klassen, in der für jede Klasse vermerkt ist, wie viele Stunden Geschichte und wie viele Stunden Deutsch sie hat. (D.h. 3 Spalten)<br/>''Es gibt eine innere Abfrage für Deutsch und eine für Geschichte.''<br />
<code><br />
SELECT deutsch.klasse AS klasse, deutsch.stunden AS deutsch, geschichte.stunden AS geschichte<br />
FROM<br />
(<br />
SELECT k.name '''AS klasse''', SUM(u.stunden) '''AS stunden'''<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
WHERE u.fach = 'deutsch'<br />
GROUP BY k.id<br />
) '''AS deutsch , '''<br />
(<br />
SELECT k.name '''AS klasse''', SUM(u.stunden) '''AS stunden'''<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
WHERE u.fach = 'geschichte'<br />
GROUP BY k.id<br />
) '''AS geschichte '''<br />
'''WHERE geschichte.klasse = deutsch.klasse'''<br />
</code><br />
* Eine Liste aller Klassen, in der angezeigt wird, wieviel Prozent Sport sie haben.<br />
<code>TODO</code><br />
* Eine Liste aller Schüler, in der für jeden Schüler steht, wie viele AGs er belegt hat. Es sollen auch Schüler ohne AGs aufgeführt werden.<br/>''Innere Abfrage: ein LEFT JOIN über die Tabellen schueler und teilnahme''<br />
<code>TODO</code><br />
* Eine Liste der Fächer, in der die Anzahl der Unterrichtsstunden und der Prozentsatz am gesamt erteilten Unterricht aufgeführt ist. ''(Innere Tabelle: die Summe der Unterrichtsstunden)''<br />
<code>TODO</code><br />
* Wieviele Stunden Unterricht haben die Klassen durchschnittlich?<br/>''Als innere Tabelle hat man eine Liste der Klassen mit ihrer Stundenzahl. In dieser muss man ein UNION verwenden, damit die 8D, die gar keinen Unterricht hat, mitgezählt wird.''<br />
<code><br />
SELECT AVG(klassentabelle.gesamt)FROM<br />
(<br />
SELECT k.name AS name, SUM(u.stunden) AS gesamt<br />
FROM klasse k JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
GROUP BY k.id<br />
UNION<br />
SELECT k.name AS name, 0 AS gesamt<br />
FROM klasse k LEFT JOIN unterricht u<br />
ON k.id = u.klasse_id<br />
WHERE u.klasse_id IS NULL<br />
) '''AS klassentabelle'''</code><br />
* Die "Streber-Klassen": Welche Klassen haben überdurchschnittlich viele Stunden Unterricht?<br />
<code>TODO</code><br />
* Das Fach, das am meisten unterrichtet wird, mit Anzahl der Stunden.<br>''Zur Kontrolle: Deutsch.''<br />
<code>TODO</code><br />
* Eine Liste aller Schüler, in der für jeden Schüler vermerkt ist, wie viele Stunden er weniger hat als der Schüler mit der maximalen Stundenanzahl. <br> ''Zur Kontrolle: Die meisten Stunden hat Schwarzmüller mit 13 Stunden''<br />
<code>TODO</code><br />
<br />
=Weitere schwierige Abfragen=<br />
Für die folgenden Fragen muss man geeignete SQL-Sprachelemente kombinieren.<br />
# Raum R112 sieht immer furchtbar aus. Der Direktor möchte deswegen mit den Klassenlehrern von allen Klassen sprechen, die in R112 Unterricht haben.<br/>''JOIN über die Tabellen raum, unterricht, klasse, lehrer''<br />
# Wieviel Prozent der insgesamt erteilten Unterrichtsstunden sind Sportstunden?<br/>''zwei innere Abfragen: eine für die Gesamtzahl der Stunden, eine für den Sportunterricht.''<br />
# Welcher Lehrer unterrichtet am meisten? (Mit Angabe der Stundenzahl.)<br/>''GROUP BY , ORDER BY anzahl DESC und LIMIT 1''<br />
# Der Direktor hätte gerne eine Liste der Lehrer, in der aufgeführt wird, wie viele Unterrichtsstunden sie erteilen. Auch die "Drückeberger" sollen in der Liste aufgeführt werden (mit 0 Stunden).<br/>''Die "Drückeberger" muss man mit UNION anfügen. Für die Drückeberger braucht man LEFT JOIN und IS NULL.''<br />
# Eine Liste der Etagen mit den durchschnittlichen Raumgrößen. Die Liste soll nach den Durchschnittswerten sortiert werden.<br/>''AVG, GROUP BY, ORDER BY durchschnitt DESC<br />
# Eine Liste der Schüler, die nie in Raum R112 Unterricht haben.<br/>''NOT IN''<br />
# Eine Liste aller Schüler und Lehrer, die in Raum R112 Unterricht haben / unterrichten.<br/>''UNION''<br />
# In welchem Raum finden die meisten Unterrichtsstunden statt?<br/>''GROUP BY, ORDER BY anzahl DESC, LIMIT 1''<br />
# In welchen Räumen finden weniger Unterrichtsstunden statt als in Raum R112? Die Liste soll auch die Räume einschließen, in denen kein Unterricht stattfindet.<br/>''Zwei Räume: r1 ist Raum R112, r2 ist ein Raum, in dem weniger Unterricht ist.<br/>Die Räume, in denen gar kein Unterricht stattfindet muss man mit UNION anhängen.''<br />
# Eine Liste der Unterrichtsfächer, in der für jedes Fach vermerkt ist, wie viele Stunden in der unteren, in der mittleren bzw. in der oberen Etage unterrichtet werden.<br/>''GROUP BY über zwei Attribute''<br />
<code><br />
SELECT u.fach, r.etage, SUM(u.stunden)<br />
FROM unterricht u JOIN raum r<br />
ON u.raum_id = r.id<br />
'''GROUP BY u.fach, r.etage'''<br />
ORDER BY u.fach, r.etage<br />
</code><br />
<br />
=Gemischte Aufgaben (schwierig bis sehr schwierig)=<br />
<br />
Eine Liste der Klassen, die in Raum R112 Unterricht haben.<br/>''Ergebnis: 8A, 8C.''<br />
<code><br />
''JOIN über 3 Tabellen''<br />
<br />
SELECT k.name<br />
FROM klasse k JOIN unterricht u JOIN raum r<br />
ON k.id = u.klasse_id AND u.raum_id = r.id<br />
WHERE r.nummer = 'R112'<br />
</code><br />
Eine Liste aller AGs mit Teilnehmerzahl. <br/>''Ergebnis: Z.B. Fotografie 2<br/>''<br />
<br />
''JOIN über 2 Tabellen und GROUP BY''<br />
<code><br />
SELECT a.name, COUNT(t.schueler_id) AS anzahl<br />
FROM ag a JOIN teilnahme t<br />
ON a.id = t.ag_id<br />
GROUP BY a.id<br />
</code><br />
Eine Liste der Räume, in denen nie Deutsch stattfindet.<br/>''Ergebnis: R110, R306, Sporthalle (=wenig erstaunlich...), R208, R101''<br />
<br />
''Differenz''<br />
<code><br />
SELECT r.nummer<br />
FROM raum r<br />
WHERE r.id NOT IN<br />
( SELECT u.raum_id<br />
FROM unterricht u<br />
WHERE u.fach = 'Deutsch'<br />
)<br />
</code><br />
Eine Liste der Fachkollegen von Josef Zimmermann.<br/><br />
''Ergebnis: Erika Huber und Josef Zimmermann selber.''<br />
<br />
''Zwei Variablen für eine Entitätsmenge:''<br/><br />
''l1 = der gesuchte Lehrer; u1 = sein Unterricht''<br/><br />
''l2 = Lehrer Zimmermann; u2 = sein Unterricht''<br />
<code><br />
SELECT DISTINCT l1.name<br />
FROM lehrer l1<br />
JOIN unterricht u1<br />
JOIN unterricht u2<br />
JOIN lehrer l2<br />
ON l1.id = u1.lehrer_id<br />
AND u1.fach = u2.fach<br />
AND u2.lehrer_id = l2.id<br />
WHERE l2.name = 'Zimmermann'<br />
</code><br />
<br />
Eine Liste aller Schüler, in der aufgeführt wird, an welchen AGs sie teilnehmen. <br/><br />
Wenn ein Schüler an mehreren AGs teilnimmt, dann soll er mehrfach aufgeführt werden. <br/><br />
Schüler, die an keiner AG teilnehmen, sollen nicht aufgeführt werden.<br/><br />
''Ergebnis: Z.B. Johannes Meyer nimmt an Holzwerken und Fotografie teil.'' <br/><br />
''Die Schüler Zimmermann und Wiesenhoff tauchen in der Liste nicht auf.''<br />
<br />
''2x JOIN''<br />
<code><br />
SELECT s.name, a.name<br />
FROM schueler s JOIN teilnahme t JOIN ag a<br />
ON s.id = t.schueler_id AND t.ag_id = a.id<br />
</code><br />
Wie die vorhergehende Abfrage, aber: Auch Schüler, die an keiner AG teilnehmen, sollen aufgeführt werden.<br/><br />
''Ergebnis: Jetzt sollen die Schüler Zimmermann und Wiesenhoff auftauchen.''<br />
<br />
''1x LEFT JOIN, dann JOIN''<br />
<br />
<code><br />
SELECT s.name, a.name<br />
FROM schueler s LEFT JOIN (teilnahme t JOIN ag a)<br />
ON s.id = t.schueler_id AND t.ag_id = a.id<br />
</code><br />
Es soll eine Liste erstellt werden, aus der hervorgeht, wie viele Stunden jeder Lehrer arbeitet! <br/><br />
Dabei zählen die Unterrichtsstunden normal und jede AG, die ein Lehrer leitet, zählt 1 Stunde.<br/><br />
''Ergebnis: Z.B. für den Lehrer Zimmermann: 1AG + 4Deutsch + 4Deutsch + 2Geschichte = 11''<br />
<br />
''2 innere Abfragen.''<br />
''Es werden hier nur die Lehrer aufgeführt, die sowohl unterrichten als auch AGs haben.''<br />
<br />
<code><br />
SELECT ustunden.name AS name, ustunden.anzahl + agstunden.anzahl AS anzahl<br />
FROM<br />
( SELECT l.name AS name, SUM(u.stunden) AS anzahl<br />
FROM lehrer l, unterricht u<br />
WHERE l.id = u.lehrer_id<br />
GROUP BY l.name<br />
) AS ustunden<br />
,<br />
( SELECT l.name AS name, COUNT(*) AS anzahl<br />
FROM lehrer l, ag a<br />
WHERE l.id = a.lehrer_id<br />
GROUP BY l.name<br />
) AS agstunden<br />
WHERE ustunden.name = agstunden.name<br />
</code><br />
<br />
<br />
Eine Liste, in der alle Räume aufgeführt sind. <br/><br />
Zu jedem Raum soll in einer Spalte angegeben werden, wie viele Stunden Deutsch dort unterrichtet wird <br/><br />
und in einer zweiten Spalte, wie viele Stunden Englisch.<br/><br />
''Ergebnis: Z.B. R112: 4 Deutsch, 4 Englisch''<br />
<br />
''2 innere Abfragen''<br />
<br />
<code><br />
SELECT deutsch.raum, deutsch.stunden, englisch.stunden<br />
FROM<br />
(<br />
SELECT r.nummer AS raum, SUM(u.stunden) AS stunden<br />
FROM raum r JOIN unterricht u<br />
ON r.id = u.raum_id<br />
WHERE u.fach = 'deutsch'<br />
UNION<br />
SELECT r.nummer AS raum, 0 AS stunden<br />
FROM raum r<br />
WHERE r.id NOT IN<br />
(<br />
SELECT u.raum_id FROM unterricht u WHERE u.fach = 'deutsch'<br />
)<br />
) '''AS deutsch ,'''<br />
(<br />
SELECT r.nummer AS raum, SUM(u.stunden) AS stunden<br />
FROM raum r LEFT JOIN unterricht u<br />
ON r.id = u.raum_id<br />
WHERE u.fach = 'englisch'<br />
UNION<br />
SELECT r.nummer AS raum, 0 AS stunden<br />
FROM raum r<br />
WHERE r.id NOT IN<br />
(<br />
SELECT u.raum_id FROM unterricht u WHERE u.fach = 'englisch'<br />
)<br />
) '''AS englisch'''<br />
'''where deutsch.raum = englisch.raum'''<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java_Basis-Sprachelemente&diff=3659Java Basis-Sprachelemente2024-01-16T18:29:52Z<p>Akaibel: /* Methodendeklaration / Methodenkopf */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik-EF]]<br />
[[Kategorie:Informatik-Q1]]<br />
<br />
=Allgemeines=<br />
Hier werden die grundlegenden Sprachelemente von Java '''im Detail''' erklärt.<br />
<br />
Wer wissen möchte, wie eine '''ganze Klasse''' aussieht:<br />
* [[Klasse]]<br />
==Erklärvideos==<br />
<br />
* '''[https://www.youtube.com/watch?v=dEFJUra_3ZA Java-Crashkurs Teil 1 (28min)] '''<br/>In Teil 1 des Crash-Kurses geht es um Grundlagen der Programmierung einer Klasse, d.h.<br/>Klasse, Attribut, Konstruktor, Methode, Parameter, lokale Variable etc.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner.txt Programmiervorlage für den Taschenrechner]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-Dokumentation.pdf|Cheat sheet für Teil 1 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[[Medium:Taschenrechner-Fehlersuche.pdf|Taschenrechner Fehlersuche zum Ausdrucken (PDF)]]'''<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner-mit-Fehlern.txt Java-Quelltext für die Fehlersuche]'''<br/>Den Quelltext kann man in [https://www.jdoodle.com/online-java-compiler/ jdoodle] packen und dann die Fehlermeldungen durchklicken!<br />
&nbsp;<br />
* '''[https://youtu.be/IimFb4cEhUU Java-Crashkurs Teil 2 (40min)] '''<br/>In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner2.txt Programmiervorlage für den Taschenrechner (mit allem für Teil 2)]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-2-Dokumentation.pdf|Cheat sheet für Teil 2 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[https://youtu.be/JVeAUGX60-A Erklärvideo zu Klassen, Objekten, Attritbuten & Methoden (17:08min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br/>[[Medium:VAB-01 Informatik10 KlassenObjekteAttributeMethoden.pdf|Arbeitsblatt zum Video (PDF)]]. <br/>Zu Teilen der Aufgaben gibt es die Lösung im Video, die anderen Aufgaben werden erst im Unterricht besprochen.<br/>&nbsp;<br />
<br />
= Anforderungen Zentralabitur =<br />
Das Zentralabitur fordert die Kenntnis von bestimmten Basis-Sprachelementen, die hier aufgeführt sind.<br />
<br />
Im folgenden werden diese und weitere Basis-Sprachelemente erläutert.<br />
<br />
'''Stand: 2012 (im April 2013 noch aktuell)'''<br />
<br />
* Klassendefinitionen<br />
* Beziehungen zwischen Klassen<br />
** gerichtetete Assoziation<br />
** Vererbung<br />
* Attribute und Methoden (mit Parametern und Rückgabewerten)<br />
* Wertzuweisungen<br />
* Verzweigungen (if, switch)<br />
* Schleifen (while, for, do-while)<br />
<br />
= Klasse, Objekt, Klassendefinition =<br />
''Auf dieser Seite werden Klassen, Objekte etc. Schritt für Schritt erklärt.<br />
<br />
''Den erläuterten kompletten Quellcode einer Java-Klasse findet man hier: [[Klasse in Java]]''<br />
<br />
* Von einer '''Klasse''' können viele '''Objekte''' erzeugt werden.<br />
* Beispiel: Es gibt eine Klasse <code>Baum</code>, von der man viele einzelne Objekte erzeugen kann.<br />
* Java: Definiton einer Klasse:<br />
<code> <br />
'''public class Baum'''<br />
{<br />
// Attribute<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Attribute =<br />
* Attribute beschreiben, welche Eigenschaften bzw. Teil-Objekte die Objekte einer Klasse haben.<br />
* Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den <u>Attribut-Wert</u> haben.<br />
** Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.<br />
* Attribute haben einen <u>Attribut-Typ</u>. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa <code>int</code> für ganze Zahlen oder <code>double</code> für Kommazahlen. Für Namen eignet sich <code>String</code>.<br/>Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Java:<br />
** Attribute werden direkt nach der Klassen-Deklaration notiert.<br />
** Attribute sind in der Regel <code>private</code>, d.h. sie können nicht ohne Weiteres von Außen verändert werden.<br />
<br />
'''Beispiel 1:'''<br />
<br />
Objekte der Klasse <code>Auto</code> können unterschiedlichen Tankstand haben.<br />
<br />
Dafür gibt es das Attribut <code>tankstand</code>. Dieses hat den Datentyp <code>double</code>, weil es eine Kommazahl sein kann.<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
'''private double tankstand;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
'''Beispiel 2:'''<br />
<br />
Objekte der Klasse <code>Baum</code> bestehen aus einem <code>Quadrat</code> (für den Stamm) und einem <code>Kreis</code> (für die Krone). <br/>''Die Klassen <code>Quadrat</code> und <code>Kreis</code> müssen natürlich schon im Projekt enthalten sein!!''<br />
<br />
<code><br />
public class Baum<br />
{<br />
// Attribute<br />
'''private Quadrat stamm;'''<br />
'''private Kreis krone;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Konstruktor =<br />
'''Aufruf des Konstruktors:'''<br />
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:<br />
* Java: <code>Auto neuesAuto = '''new Auto()''';</code><br />
<br />
<br />
'''Deklaration des Konstruktors:'''<br />
* In der Deklaration des Konstruktors wird festgelegt, was passiert, wenn ein Objekt der Klasse erzeugt wird.<br />
* Der Konstruktor heißt genauso wie die Klasse.<br />
* Der Konstruktor hat '''keinen''' Rückgabetyp, also auch kein <code>void</code>.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private int tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto()'''<br />
'''{'''<br />
'''tankstand = 5.0;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch bekommt jedes Auto bei der Erzeugung einen Tankstand von 5.0, d.h. es kann direkt losfahren.<br />
<br />
== Konstruktor mit Parameter ==<br />
Man kann im Konstruktor einen Parameter übergeben, z.B. um direkt bei der Erzeugung die Eigenschaft eines Objektes festzulegen.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto(<u>double pTankstand</u>)'''<br />
'''{'''<br />
'''tankstand = <u>pTankstand</u>;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen.<br />
<br />
'''Aufgerufen''' wird dieser Konstruktor dann z.B. so:<br />
<br />
<code>Auto neuesAuto = '''new Auto(7.0)''';</code><br />
<br />
Damit hat <code>neuesAuto</code> den Tankstand 7.0<br />
<br />
= Methoden =<br />
In Methoden wird festgelegt, was man mit einem Objekt der Klasse machen kann.<br />
<br />
'''Beispiel:'''<br />
Für ein Objekt der Klasse Auto soll es die Methode <code>tanken</code> geben. Außerdem soll man den Tankstand mit der Methode <code>gibTankstand()</code> auslesen können.<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
public Auto()<br />
{<br />
tanstand = 5.0;<br />
}<br />
<br />
// Methoden<br />
'''public void tanken(double pLiter)'''<br />
'''{'''<br />
'''tankstand = tankstand + pLiter;'''<br />
'''}'''<br />
<br />
'''public double gibTankstand()''' <br />
'''{'''<br />
'''return tankstand;'''<br />
'''}'''<br />
}<br />
</code><br />
<br />
== Methodendeklaration / Methodenkopf ==<br />
Methoden werden durch den '''Methodenkopf (auch: die Methodensignatur)''' deklariert.<br />
<br />
D.h. für Objekte der Klasse kann man dann die Methode aufrufen.<br />
<br />
'''Erklärvideo'''<br />
<br />
'''[https://youtu.be/YPVhVxL67xo Erklärvideo zu Methodensignaturen (11:42min)]'''. <br/>'' (Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.)<br />
<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
private int preisstufe;<br />
<br />
//Konstruktor<br />
public Automat()<br />
{<br />
preisstufe = 0;<br />
eingeworfen = 0;<br />
}<br />
<br />
//Methoden<br />
<br />
'''public void preisstufeWaehlen(int pPreisstufe)'''<br />
{<br />
preisstufe = pPreisstufe;<br />
}<br />
<br />
'''public int gibPreisstufe()'''<br />
{<br />
int ergebnis = preisstufe;<br />
return ergebnis;<br />
}<br />
<br />
'''public void geldEinwerfen(int betragInCent)'''<br />
{<br />
eingeworfen = eingeworfen + betragInCent;<br />
}<br />
<br />
'''private double steuern(int betrag)'''<br />
{<br />
double ergebnis = betrag * 0.19;<br />
return ergebnis;<br />
}<br />
<br />
'''public int geldZurueckGeben()'''<br />
{<br />
int ergebnis = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
Der '''Methodenkopf''' ist immer gleich aufgebaut:<br />
# '''Zugriffsmodifikator''': <code>public</code> oder <code>private</code>.<br />
## Auf <code>public</code>-Methoden darf man auch von außen zugreifen; sie sind '''öffentlich'''.<br />
## Auf <code>private</code>-Methoden darf nur die Klasse selbst zugreifen, d.h. von außen ist diese Methode nicht sichtbar! Das ist z.B. sinnvoll für Hilfsmethoden, die nicht jeder benutzen soll.<br />
# '''Rückgabetyp''': <code>void</code> für ''nichts'' bzw. ein Datentyp (wie z.B. <code>int</code>) oder auch eine Klasse.<br />
## Im Rückgabetyp wird festgelegt, ob und was die Methode zurückgibt. So sollten Methoden, die etwas berechnen, das Ergebnis auch zurückgeben.<br />
## Die Methode <code>public '''void''' geldEinwerfen(int betragInCent)</code> gibt ''nichts'' zurück. <code>'''void'''</code> ist das Schlüsselwort für ''nichts''.<br />
## Die Methode <code>public '''int''' summe(int a, int b) </code> gibt <code>int</code> zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein '''return-Statement''', z.B.: <code>return ergebnis;</code><br />
# '''Methodenname''': Methodennamen sind Verben, denn Methoden bezeichnen Tätigkeiten! Außerdem ist es üblich, Methodennamen '''klein''' zu schreiben.<br />
# '''Parameter''': In der Klammer nach dem Methodenname findet sich der (bzw. die Parameter).<br />
## Bei den Parametern wird erst der '''Parameter-Typ''' (z.B. <code>int</code>) und dann der '''Parameter-Name''' angegeben.<br />
## Mehrere Parameter werden durch Komma getrennt, z.B. <code>public int summe('''int a, int b''')</code><br />
## Methoden ohne Parameter haben leere Klammern, z.B.: <code>public int geldZurueckGeben'''()'''</code><br />
<br />
== Parameter ==<br />
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.<br />
* Das ist hier der Fall bei der Methode <code>geldEinwerfen</code>: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie viel Geld man einwirft.<br />
* Dafür haben Methoden '''Parameter''', in diesem Fall <code>betragInCent</code>.<br />
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von '''Parameter-Typ'''.<br />
** Der Parameter-Typ von <code>betragInCent</code> ist <code>int</code>, also eine ganze Zahl.<br />
** Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den <u>Parameter übergeben</u>. <br />
<code><br />
Automat derAutomat = new Automat();<br />
// jetzt kommt der Methodenaufruf mit Parameterübergabe!<br />
derAutomat.geldEinwerfen('''50''');<br />
</code><br />
* Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur <code>()</code>. Das ist wichtig, um sie von Attribute zu unterscheiden!<br />
<br />
== Rückgabetyp einer Methode ==<br />
Für eine Methode wird immer der Rückgabetyp festgelegt.<br />
* '''<code>void</code>''': Wenn die Methode '''nichts''' zurückgibt (bei einer verändernden Methode).<br />
** Beispiel: <code>public '''void''' geldEinwerfen(int betragInCent)</code><br />
* '''<code>int</code>''': Wenn die Methode eine ganze Zahl (<code>int</code>) zurückgibt.<br />
** Beispiel: <code>public '''int''' geldZurueckGeben()</code><br />
* Statt <code>int</code> kann auch jeder andere Typ oder auch eine Klasse (z.B. <code>Automat</code>) der Rückgabe-Typ einer Methode sein.<br />
** Beispiel: <code>public '''Automat''' gibKopie()</code> : Diese Methode würde eine Kopie des Automaten (also ein Objekt der Klasse <code>Automat</code>) zurückgeben.<br />
<br />
Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
<br />
== sondierende Methode / verändernde Methode ==<br />
* '''sondierende Methode (=get-Methode)''': Dieser Methodentyp ''gibt eine Information über das Objekt zurück''. Diese Methode braucht einen Rückgabetyp (d.h. nicht <code>void</code>) und ein return-Statement.<br />
** Beispiel: <code>public '''int''' gibPreisstufe()</code><br />
* '''verändernde Methode (=set-Methode)''': Dieser Methodentyp ''verändert das Objekt''. Häufig hat dieser Methodentyp einen (oder mehrere) '''Parameter'''. Sie hat zumeist den Rückgabetyp <code>void</code>, denn sie gibt in der Regel nichts zurück.<br />
** Beispiel: <code>public void preisstufeWaehlen('''int pPreisstufe''')</code><br />
<br />
== Methodenaufruf ==<br />
Methoden der gleichen Klasse werden durch ihren Methodennamen aufgerufen.<br />
<br />
'''VORSICHT:'''<br />
Wenn man eine sondierende Methode aufruft, dann muss man sich für das Ergebnis interessieren!<br />
<br />
'''Beispiel:'''<br />
<br />
Im Beispiel ruft die Methode <code>groessteZahl</code> dreimal die Methode <code>gibGroessereZahl</code> auf. Das Ergebnis des Aufrufs wird jeweils in einer lokalen Variable (z.B. <code>groessere12</code> gespeichert, um damit weiter zu rechnen.<br />
<code><br />
public class Rechner{<br />
public int groessteZahl(int z1, int z2, int z3, int z4)<br />
{<br />
int groessere12 = '''gibGroessereZahl(z1, z2);'''<br />
int groessere34 = '''gibGroessereZahl(z3, z4);'''<br />
int ergebnis = '''gibGroessereZahl(groessere12, groessere34);'''<br />
return ergebnis;<br />
}<br />
<br />
'''public int gibGroessereZahl(int a, int b)'''<br />
{<br />
int ergebnis;<br />
if(a > b)<br />
{<br />
return a;<br />
}<br />
else<br />
{<br />
return b;<br />
}<br />
}<br />
}<br />
</code><br />
<br />
===Methoden für Objekte anderer Klassen aufrufen ===<br />
Man kann auf für ein Objekt einer anderen Klasse eine Methode aufrufen; damit wird eine Aufgabe '''delegiert'''.<br />
<br />
'''WICHTIG: Das wesentliche Syntax-Element ist der Punkt!''' <br/>Man gibt erst das Objekt an, dann den Punkt, dann die Methode (ggf. mit Parameter).<br/>Z.B. <code> '''stamm.bewegeZuPosition(110,120)''';</code><br />
<br />
'''Beispiel :'''<br />
<code><br />
public class Baum<br />
{<br />
// Attribute der Klasse Baum<br />
private Kreis krone;<br />
private Quadrat stamm;<br />
<br />
// Konstruktor der Klasse Baum<br />
public Baum()<br />
{<br />
stamm = new Quadrat();<br />
'''stamm.bewegeZuPosition(110,120)''';<br />
'''stamm.sichtbarMachen()''';<br />
krone = new Kreis();<br />
'''krone.bewegeZuPosition(100,100)''';<br />
'''krone.sichtbarMachen()''';<br />
}<br />
}<br />
</code><br />
<br />
'''Erklärung:'''<br />
* <code>stamm</code> ist ein Objekt vom Typ <code>Quadrat</code>; deshalb verfügt <code>stamm</code> über die Methode <code>sichtbarMachen()</code>.<br />
* Im Konstruktor von <code>Baum</code> wird diese Methode mithilfe des Punktes aufgerufen:<br />
** Attributname -> Punkt -> Methodenname.<br />
*<br />
Ein Objekt der Klasse <code>Haus</code> ruft in einem Objekt der Klasse <code>Quadrat</code> die Methode<br />
<br />
=lokale Variable=<br />
* '''Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.'''<br />
* Lokale Variablen kann man (im Gegensatz zu Attributen) <u>nicht</u> in der ganzen Klasse benutzen. <br />
* Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.<br />
** U.a. werden lokale Variablen immer dann eingesetzt, wenn eine Methode ein Ergebnis berechnen und dann zurückgegeben soll.<br />
<br />
'''Beispiel aus der Klasse <code>Automat</code>:'''<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
<br />
// weitere Attribute, Konstruktor und Methoden<br />
<br />
public int geldZurueckGeben()<br />
{<br />
'''int ergebnis''' = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
= Wertzuweisungen =<br />
Attributen und lokalen Variablen können Werte zugewiesen werden.<br />
* Beispiel 1:<br />
** <code>geschwindigkeit = 10;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert 10 zugewiesen.<br />
* Beispiel 2:<br />
** <code>geschwindigkeit = neueGeschwindigkeit;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>neueGeschwindigkeit</code> zugewiesen.<br />
* Beispiel 3:<br />
** <code>geschwindigkeit = geschwindigkeit + 1;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>geschwindigkeit+1</code> zugewiesen,<br />
** d.h. die Geschwindigkeit wird '''um 1 erhöht'''!<br />
* Allgemein:<br />
** '''links vom Gleichzeichen''' steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.<br />
** '''rechts vom Gleichzeichen''' steht der neue Wert.<br />
<br />
<br />
Außerdem gibt es praktische Abkürzungen für Wertzuweisungen, vor allem '''<code>+=</code>''' und '''<code>++</code>'''.<br />
<br />
* Beispiel 4:<br />
** <code>geschwindigkeit '''+=''' 5;</code><br />
** '''<code>+=</code>''' bedeutet: erhöhe um..., d.h. im Beispiel wird Geschwindigkeit wird um 5 erhöht.<br />
* Beispiel 5:<br />
** <code>geschwindigkeit'''++''';</code><br />
** '''<code>++</code>''' bedeutet: erhöhe um eins.<br />
<br />
= Verzweigungen (if-else) =<br />
Beispiel: die folgende Methode überprüft, welche von zwei Zahlen die größere ist.<br />
<br />
Es passiert folgendes: Wenn (<code>if</code>) <code>a</code> größer als <code>b</code> ist, dann wird <code>ergebnis</code> auf <code>a</code> gesetzt, sonst (<code>else</code>) auf <code>b</code>.<br />
<br />
<code><br />
public int bestimmeDieGroessere(int a, int b)<br />
{<br />
int ergebnis;<br />
'''if(a > b)'''<br />
{<br />
ergebnis = a;<br />
}<br />
'''else'''<br />
{<br />
ergebnis = b;<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
'''VORSICHT:'''<br />
Gleichheit überprüft man mit '''doppeltem''' Gleichzeichen:<br />
<code><br />
// Wenn x gleich drei ist, ...<br />
if(x '''==''' 3)<br />
{<br />
...<br />
}<br />
</code><br />
<br />
= Schleifen (while, for, do-while) =<br />
Bei Schleifen kommen die Fähigkeiten der Computer besonders zur Geltung: Schleifen ermöglichen es, dass man Aktionen mehrfach (d.h. auch 1.000 oder 1.000.000 mal) wiederholt.<br />
== for-Schleife ==<br />
Die for-Schleife ist eine '''Zählschleife'''. Sie wird eingesetzt, wenn man zählen kann, wie oft Aktionen wiederholt werden sollen. Dafür gibt es eine '''Zählvariable''', die häufig <code>i</code> heißt, aber jeder andere Name ist auch denkbar.<br />
<br />
'''Beispiel:'''<br />
<br />
Die folgende for-Schleife gibt die Zahlen 0, 3, 6, ...., 999 an die Konsole aus.<br />
<br />
<code><br />
'''for(int i=0; i<=333; i++)'''<br />
{<br />
System.out.println(3*i);<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
<br />
* Die Klammer nach dem <code>for</code> hat drei Teile:<br />
** ''Deklaration und Initialisierung der Zählvariable <code>i</code>:'' i startet bei 0.<br />
** ''Schleifenbedingung:'' Die Schleife wird so lange wiederholt, wie i <= 333 ist.<br />
** ''Veränderung bei jedem Schleifendurchlauf:'' i wird bei jedem Schleifendurchlauf um eins erhöht. (<code>i++</code> bedeutet dasselbe wie <code>i = i+1</code>). D.h. i nimmt nacheinander folgende Werte an: 0, 1, 2, ..., 333.<br />
** Im Schleifenrumpf wird mit <code>System.out.println(i);</code> jeweils das Dreifache von <code>i</code> an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.<br />
<br />
==while-Schleife==<br />
Die while-Schleife ist eine '''bedingte'''Schleife. Sie wird eingesetzt, wenn Aktionen wiederholt werden sollen, solange die '''Schleifenbedingung''', erfüllt ist.<br />
<br />
'''Erklärvideo'''<br><br />
'''[https://www.youtube.com/watch?v=kPovFPak0Hs Erklärvideo zu while-Schleifen (11:49min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br />
<br />
'''Beispiel:'''<br/><br />
Die folgende while-Schleife beginnt bei <code>zahl = 1</code>. <br/><br />
<code>zahl</code> wird dann so lange an die Konsole ausgegeben und verdoppelt, <br/>wie <code>zahl</code> kleiner als 1000 ist. <br/>D.h. die Ausgabe ist: 1, 2, 4, ..., 256, 512.<br />
<code><br />
int zahl = 1;<br />
'''while(zahl < 1000)'''<br />
{<br />
System.out.println(zahl);<br />
// zahl verdoppeln<br />
zahl = zahl * 2;<br />
}<br />
</code><br />
'''Erläuterung:'''<br />
* Die Klammer nach dem <code>while</code> enthält die Bedingung: <br/>Wiederhole, solange zahl kleiner 1000 ist.<br />
* Im Schleifenrumpf wird dann <code>zahl</code> an die Konsole ausgegeben <br/>und dann mit <code>zahl = zahl * 2;</code> verdoppelt.<br />
<br />
= Beziehungen zwischen Klassen =<br />
''Die Implementierung von Beziehungen zwischen Klassen ist auf anderen Seiten erklärt, auf die hier nur verwiesen wird.''<br />
<br />
'''"kennt"-Beziehung:'''<br />
<br />
Wie man kennt-Beziehungen implementiert, kann man hier nachlesen:<br/><br />
[[Klassen-_und_Implementationsdiagramm#Java-Quelltext:|Szenario Roller (Quelltext)]]<br />
<br />
'''Vererbung:'''<br/><br />
[[Vererbung#Implementierung|Szenario Buch - Fachbuch - Hörbuch]]<br />
<br />
=NullPointerException=<br />
Die NullPointerException ist beim Programmieren die häufigste Exception.<br />
<br />
'''Die NullpointerException wird auch im Abitur abgefragt!!!'''<br />
<br />
Eine NullpointerException tritt auf, wenn man auf eine Methode eines Elementes zugreift, das noch gar nicht erzeugt wurde.<br />
<br />
'''Beispiel 1:'''<br/><br />
Beispiel 1 zeigt, wie die NullpointerException beim Programmieren im Unterricht am häufigsten auftritt.<br />
<code><br />
public class SchuelerVerwaltung{<br />
private List<Schueler> schuelerListe;<br />
<br />
public SchuelerVerwaltung(){<br />
Schueler s1 = new Schueler("Gates","Bill"); <br />
<font color='red'>'''schuelerListe'''.append(s1);</font><br />
}<br />
}<br />
</code><br />
'''Erklärung 1:'''<br/><br />
In der roten Zeile kommt es zu einer NullPointerException, weil das Attribut <code>schuelerListe</code> noch gar nicht erzeugt wurde - es ist <code>null</code>.<br/>Für ein Objekt, das den Wert <code>null</code>hat, führt der Aufruf einer Methode (in diesem Fall <code>schuelerListe.'''append(s1)'''</code>) zu einer NullpointerException.<br />
<br />
Man kann die NullPointerException vermeiden, indem man <u>vor</u> der roten Zeile einfügt:<br />
<code><br />
schuelerListe = new List<>();<br />
</code><br />
'''Beispiel 2: Abituraufgabe'''<br/><br />
Das ist eine (verkürzte) Aufgabenstellung aus dem Abitur:<br />
<br />
''Analysieren und erläutern Sie, an welcher Stelle des Quellcodes ein Laufzeitfehler durch einen Zugriff auf ein nicht existentes Objekt (eine sogenannte NullPointerException)<br />
entstehen kann.''<br />
<code><br />
public Team wasErmittleIch(Team pTeam, int pX) {<br />
List<Team> auswahl = filtereTeams(pTeam, pX);<br />
auswahl.toFirst();<br />
int punkte = <font color='red'>'''pTeam'''.berechnePunkte()</font>;<br />
Team g = auswahl.getContent();<br />
int d = Math.abs(<font color='red'>'''g'''.berechnePunkte()</font> - punkte);<br />
auswahl.next();<br />
...<br />
}<br />
</code><br />
'''Erklärung 2:'''<br/><br />
An den roten Stellen kann es zu einer NullpointerException kommen:<br />
* Wenn <code>pTeam</code> den Wert <code>null</code> hat, kann man für <code>pTeam</code> nicht die Methode <code>berechnePunkte()</code> aufrufen.<br />
* Wenn <code>auswahl</code> eine leere Liste ist: dann hat die lokale Variable <code>g</code> den Wert <code>null</code>, und man kann für <code>g</code> dann nicht die Methode <code>berechnePunkte()</code> aufrufen.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java_Basis-Sprachelemente&diff=3658Java Basis-Sprachelemente2024-01-16T18:28:07Z<p>Akaibel: /* while-Schleife */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik-EF]]<br />
[[Kategorie:Informatik-Q1]]<br />
<br />
=Allgemeines=<br />
Hier werden die grundlegenden Sprachelemente von Java '''im Detail''' erklärt.<br />
<br />
Wer wissen möchte, wie eine '''ganze Klasse''' aussieht:<br />
* [[Klasse]]<br />
==Erklärvideos==<br />
<br />
* '''[https://www.youtube.com/watch?v=dEFJUra_3ZA Java-Crashkurs Teil 1 (28min)] '''<br/>In Teil 1 des Crash-Kurses geht es um Grundlagen der Programmierung einer Klasse, d.h.<br/>Klasse, Attribut, Konstruktor, Methode, Parameter, lokale Variable etc.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner.txt Programmiervorlage für den Taschenrechner]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-Dokumentation.pdf|Cheat sheet für Teil 1 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[[Medium:Taschenrechner-Fehlersuche.pdf|Taschenrechner Fehlersuche zum Ausdrucken (PDF)]]'''<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner-mit-Fehlern.txt Java-Quelltext für die Fehlersuche]'''<br/>Den Quelltext kann man in [https://www.jdoodle.com/online-java-compiler/ jdoodle] packen und dann die Fehlermeldungen durchklicken!<br />
&nbsp;<br />
* '''[https://youtu.be/IimFb4cEhUU Java-Crashkurs Teil 2 (40min)] '''<br/>In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner2.txt Programmiervorlage für den Taschenrechner (mit allem für Teil 2)]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-2-Dokumentation.pdf|Cheat sheet für Teil 2 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[https://youtu.be/JVeAUGX60-A Erklärvideo zu Klassen, Objekten, Attritbuten & Methoden (17:08min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br/>[[Medium:VAB-01 Informatik10 KlassenObjekteAttributeMethoden.pdf|Arbeitsblatt zum Video (PDF)]]. <br/>Zu Teilen der Aufgaben gibt es die Lösung im Video, die anderen Aufgaben werden erst im Unterricht besprochen.<br/>&nbsp;<br />
<br />
= Anforderungen Zentralabitur =<br />
Das Zentralabitur fordert die Kenntnis von bestimmten Basis-Sprachelementen, die hier aufgeführt sind.<br />
<br />
Im folgenden werden diese und weitere Basis-Sprachelemente erläutert.<br />
<br />
'''Stand: 2012 (im April 2013 noch aktuell)'''<br />
<br />
* Klassendefinitionen<br />
* Beziehungen zwischen Klassen<br />
** gerichtetete Assoziation<br />
** Vererbung<br />
* Attribute und Methoden (mit Parametern und Rückgabewerten)<br />
* Wertzuweisungen<br />
* Verzweigungen (if, switch)<br />
* Schleifen (while, for, do-while)<br />
<br />
= Klasse, Objekt, Klassendefinition =<br />
''Auf dieser Seite werden Klassen, Objekte etc. Schritt für Schritt erklärt.<br />
<br />
''Den erläuterten kompletten Quellcode einer Java-Klasse findet man hier: [[Klasse in Java]]''<br />
<br />
* Von einer '''Klasse''' können viele '''Objekte''' erzeugt werden.<br />
* Beispiel: Es gibt eine Klasse <code>Baum</code>, von der man viele einzelne Objekte erzeugen kann.<br />
* Java: Definiton einer Klasse:<br />
<code> <br />
'''public class Baum'''<br />
{<br />
// Attribute<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Attribute =<br />
* Attribute beschreiben, welche Eigenschaften bzw. Teil-Objekte die Objekte einer Klasse haben.<br />
* Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den <u>Attribut-Wert</u> haben.<br />
** Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.<br />
* Attribute haben einen <u>Attribut-Typ</u>. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa <code>int</code> für ganze Zahlen oder <code>double</code> für Kommazahlen. Für Namen eignet sich <code>String</code>.<br/>Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Java:<br />
** Attribute werden direkt nach der Klassen-Deklaration notiert.<br />
** Attribute sind in der Regel <code>private</code>, d.h. sie können nicht ohne Weiteres von Außen verändert werden.<br />
<br />
'''Beispiel 1:'''<br />
<br />
Objekte der Klasse <code>Auto</code> können unterschiedlichen Tankstand haben.<br />
<br />
Dafür gibt es das Attribut <code>tankstand</code>. Dieses hat den Datentyp <code>double</code>, weil es eine Kommazahl sein kann.<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
'''private double tankstand;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
'''Beispiel 2:'''<br />
<br />
Objekte der Klasse <code>Baum</code> bestehen aus einem <code>Quadrat</code> (für den Stamm) und einem <code>Kreis</code> (für die Krone). <br/>''Die Klassen <code>Quadrat</code> und <code>Kreis</code> müssen natürlich schon im Projekt enthalten sein!!''<br />
<br />
<code><br />
public class Baum<br />
{<br />
// Attribute<br />
'''private Quadrat stamm;'''<br />
'''private Kreis krone;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Konstruktor =<br />
'''Aufruf des Konstruktors:'''<br />
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:<br />
* Java: <code>Auto neuesAuto = '''new Auto()''';</code><br />
<br />
<br />
'''Deklaration des Konstruktors:'''<br />
* In der Deklaration des Konstruktors wird festgelegt, was passiert, wenn ein Objekt der Klasse erzeugt wird.<br />
* Der Konstruktor heißt genauso wie die Klasse.<br />
* Der Konstruktor hat '''keinen''' Rückgabetyp, also auch kein <code>void</code>.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private int tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto()'''<br />
'''{'''<br />
'''tankstand = 5.0;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch bekommt jedes Auto bei der Erzeugung einen Tankstand von 5.0, d.h. es kann direkt losfahren.<br />
<br />
== Konstruktor mit Parameter ==<br />
Man kann im Konstruktor einen Parameter übergeben, z.B. um direkt bei der Erzeugung die Eigenschaft eines Objektes festzulegen.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto(<u>double pTankstand</u>)'''<br />
'''{'''<br />
'''tankstand = <u>pTankstand</u>;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen.<br />
<br />
'''Aufgerufen''' wird dieser Konstruktor dann z.B. so:<br />
<br />
<code>Auto neuesAuto = '''new Auto(7.0)''';</code><br />
<br />
Damit hat <code>neuesAuto</code> den Tankstand 7.0<br />
<br />
= Methoden =<br />
In Methoden wird festgelegt, was man mit einem Objekt der Klasse machen kann.<br />
<br />
'''Beispiel:'''<br />
Für ein Objekt der Klasse Auto soll es die Methode <code>tanken</code> geben. Außerdem soll man den Tankstand mit der Methode <code>gibTankstand()</code> auslesen können.<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
public Auto()<br />
{<br />
tanstand = 5.0;<br />
}<br />
<br />
// Methoden<br />
'''public void tanken(double pLiter)'''<br />
'''{'''<br />
'''tankstand = tankstand + pLiter;'''<br />
'''}'''<br />
<br />
'''public double gibTankstand()''' <br />
'''{'''<br />
'''return tankstand;'''<br />
'''}'''<br />
}<br />
</code><br />
<br />
== Methodendeklaration / Methodenkopf ==<br />
Methoden werden durch den '''Methodenkopf (auch: die Methodensignatur)''' deklariert.<br />
<br />
D.h. für Objekte der Klasse kann man dann die Methode aufrufen.<br />
<br />
'''Erklärvideo'''<br />
<br />
Hier gibt es ein '''[https://youtu.be/YPVhVxL67xo Erklärvideo zu Methodensignaturen (auf youtube, 11:42min)]'''. <br/>'' (Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.)<br />
<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
private int preisstufe;<br />
<br />
//Konstruktor<br />
public Automat()<br />
{<br />
preisstufe = 0;<br />
eingeworfen = 0;<br />
}<br />
<br />
//Methoden<br />
<br />
'''public void preisstufeWaehlen(int pPreisstufe)'''<br />
{<br />
preisstufe = pPreisstufe;<br />
}<br />
<br />
'''public int gibPreisstufe()'''<br />
{<br />
int ergebnis = preisstufe;<br />
return ergebnis;<br />
}<br />
<br />
'''public void geldEinwerfen(int betragInCent)'''<br />
{<br />
eingeworfen = eingeworfen + betragInCent;<br />
}<br />
<br />
'''private double steuern(int betrag)'''<br />
{<br />
double ergebnis = betrag * 0.19;<br />
return ergebnis;<br />
}<br />
<br />
'''public int geldZurueckGeben()'''<br />
{<br />
int ergebnis = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
Der '''Methodenkopf''' ist immer gleich aufgebaut:<br />
# '''Zugriffsmodifikator''': <code>public</code> oder <code>private</code>.<br />
## Auf <code>public</code>-Methoden darf man auch von außen zugreifen; sie sind '''öffentlich'''.<br />
## Auf <code>private</code>-Methoden darf nur die Klasse selbst zugreifen, d.h. von außen ist diese Methode nicht sichtbar! Das ist z.B. sinnvoll für Hilfsmethoden, die nicht jeder benutzen soll.<br />
# '''Rückgabetyp''': <code>void</code> für ''nichts'' bzw. ein Datentyp (wie z.B. <code>int</code>) oder auch eine Klasse.<br />
## Im Rückgabetyp wird festgelegt, ob und was die Methode zurückgibt. So sollten Methoden, die etwas berechnen, das Ergebnis auch zurückgeben.<br />
## Die Methode <code>public '''void''' geldEinwerfen(int betragInCent)</code> gibt ''nichts'' zurück. <code>'''void'''</code> ist das Schlüsselwort für ''nichts''.<br />
## Die Methode <code>public '''int''' summe(int a, int b) </code> gibt <code>int</code> zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein '''return-Statement''', z.B.: <code>return ergebnis;</code><br />
# '''Methodenname''': Methodennamen sind Verben, denn Methoden bezeichnen Tätigkeiten! Außerdem ist es üblich, Methodennamen '''klein''' zu schreiben.<br />
# '''Parameter''': In der Klammer nach dem Methodenname findet sich der (bzw. die Parameter).<br />
## Bei den Parametern wird erst der '''Parameter-Typ''' (z.B. <code>int</code>) und dann der '''Parameter-Name''' angegeben.<br />
## Mehrere Parameter werden durch Komma getrennt, z.B. <code>public int summe('''int a, int b''')</code><br />
## Methoden ohne Parameter haben leere Klammern, z.B.: <code>public int geldZurueckGeben'''()'''</code><br />
<br />
== Parameter ==<br />
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.<br />
* Das ist hier der Fall bei der Methode <code>geldEinwerfen</code>: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie viel Geld man einwirft.<br />
* Dafür haben Methoden '''Parameter''', in diesem Fall <code>betragInCent</code>.<br />
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von '''Parameter-Typ'''.<br />
** Der Parameter-Typ von <code>betragInCent</code> ist <code>int</code>, also eine ganze Zahl.<br />
** Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den <u>Parameter übergeben</u>. <br />
<code><br />
Automat derAutomat = new Automat();<br />
// jetzt kommt der Methodenaufruf mit Parameterübergabe!<br />
derAutomat.geldEinwerfen('''50''');<br />
</code><br />
* Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur <code>()</code>. Das ist wichtig, um sie von Attribute zu unterscheiden!<br />
<br />
== Rückgabetyp einer Methode ==<br />
Für eine Methode wird immer der Rückgabetyp festgelegt.<br />
* '''<code>void</code>''': Wenn die Methode '''nichts''' zurückgibt (bei einer verändernden Methode).<br />
** Beispiel: <code>public '''void''' geldEinwerfen(int betragInCent)</code><br />
* '''<code>int</code>''': Wenn die Methode eine ganze Zahl (<code>int</code>) zurückgibt.<br />
** Beispiel: <code>public '''int''' geldZurueckGeben()</code><br />
* Statt <code>int</code> kann auch jeder andere Typ oder auch eine Klasse (z.B. <code>Automat</code>) der Rückgabe-Typ einer Methode sein.<br />
** Beispiel: <code>public '''Automat''' gibKopie()</code> : Diese Methode würde eine Kopie des Automaten (also ein Objekt der Klasse <code>Automat</code>) zurückgeben.<br />
<br />
Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
<br />
== sondierende Methode / verändernde Methode ==<br />
* '''sondierende Methode (=get-Methode)''': Dieser Methodentyp ''gibt eine Information über das Objekt zurück''. Diese Methode braucht einen Rückgabetyp (d.h. nicht <code>void</code>) und ein return-Statement.<br />
** Beispiel: <code>public '''int''' gibPreisstufe()</code><br />
* '''verändernde Methode (=set-Methode)''': Dieser Methodentyp ''verändert das Objekt''. Häufig hat dieser Methodentyp einen (oder mehrere) '''Parameter'''. Sie hat zumeist den Rückgabetyp <code>void</code>, denn sie gibt in der Regel nichts zurück.<br />
** Beispiel: <code>public void preisstufeWaehlen('''int pPreisstufe''')</code><br />
<br />
== Methodenaufruf ==<br />
Methoden der gleichen Klasse werden durch ihren Methodennamen aufgerufen.<br />
<br />
'''VORSICHT:'''<br />
Wenn man eine sondierende Methode aufruft, dann muss man sich für das Ergebnis interessieren!<br />
<br />
'''Beispiel:'''<br />
<br />
Im Beispiel ruft die Methode <code>groessteZahl</code> dreimal die Methode <code>gibGroessereZahl</code> auf. Das Ergebnis des Aufrufs wird jeweils in einer lokalen Variable (z.B. <code>groessere12</code> gespeichert, um damit weiter zu rechnen.<br />
<code><br />
public class Rechner{<br />
public int groessteZahl(int z1, int z2, int z3, int z4)<br />
{<br />
int groessere12 = '''gibGroessereZahl(z1, z2);'''<br />
int groessere34 = '''gibGroessereZahl(z3, z4);'''<br />
int ergebnis = '''gibGroessereZahl(groessere12, groessere34);'''<br />
return ergebnis;<br />
}<br />
<br />
'''public int gibGroessereZahl(int a, int b)'''<br />
{<br />
int ergebnis;<br />
if(a > b)<br />
{<br />
return a;<br />
}<br />
else<br />
{<br />
return b;<br />
}<br />
}<br />
}<br />
</code><br />
<br />
===Methoden für Objekte anderer Klassen aufrufen ===<br />
Man kann auf für ein Objekt einer anderen Klasse eine Methode aufrufen; damit wird eine Aufgabe '''delegiert'''.<br />
<br />
'''WICHTIG: Das wesentliche Syntax-Element ist der Punkt!''' <br/>Man gibt erst das Objekt an, dann den Punkt, dann die Methode (ggf. mit Parameter).<br/>Z.B. <code> '''stamm.bewegeZuPosition(110,120)''';</code><br />
<br />
'''Beispiel :'''<br />
<code><br />
public class Baum<br />
{<br />
// Attribute der Klasse Baum<br />
private Kreis krone;<br />
private Quadrat stamm;<br />
<br />
// Konstruktor der Klasse Baum<br />
public Baum()<br />
{<br />
stamm = new Quadrat();<br />
'''stamm.bewegeZuPosition(110,120)''';<br />
'''stamm.sichtbarMachen()''';<br />
krone = new Kreis();<br />
'''krone.bewegeZuPosition(100,100)''';<br />
'''krone.sichtbarMachen()''';<br />
}<br />
}<br />
</code><br />
<br />
'''Erklärung:'''<br />
* <code>stamm</code> ist ein Objekt vom Typ <code>Quadrat</code>; deshalb verfügt <code>stamm</code> über die Methode <code>sichtbarMachen()</code>.<br />
* Im Konstruktor von <code>Baum</code> wird diese Methode mithilfe des Punktes aufgerufen:<br />
** Attributname -> Punkt -> Methodenname.<br />
*<br />
Ein Objekt der Klasse <code>Haus</code> ruft in einem Objekt der Klasse <code>Quadrat</code> die Methode<br />
<br />
=lokale Variable=<br />
* '''Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.'''<br />
* Lokale Variablen kann man (im Gegensatz zu Attributen) <u>nicht</u> in der ganzen Klasse benutzen. <br />
* Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.<br />
** U.a. werden lokale Variablen immer dann eingesetzt, wenn eine Methode ein Ergebnis berechnen und dann zurückgegeben soll.<br />
<br />
'''Beispiel aus der Klasse <code>Automat</code>:'''<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
<br />
// weitere Attribute, Konstruktor und Methoden<br />
<br />
public int geldZurueckGeben()<br />
{<br />
'''int ergebnis''' = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
= Wertzuweisungen =<br />
Attributen und lokalen Variablen können Werte zugewiesen werden.<br />
* Beispiel 1:<br />
** <code>geschwindigkeit = 10;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert 10 zugewiesen.<br />
* Beispiel 2:<br />
** <code>geschwindigkeit = neueGeschwindigkeit;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>neueGeschwindigkeit</code> zugewiesen.<br />
* Beispiel 3:<br />
** <code>geschwindigkeit = geschwindigkeit + 1;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>geschwindigkeit+1</code> zugewiesen,<br />
** d.h. die Geschwindigkeit wird '''um 1 erhöht'''!<br />
* Allgemein:<br />
** '''links vom Gleichzeichen''' steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.<br />
** '''rechts vom Gleichzeichen''' steht der neue Wert.<br />
<br />
<br />
Außerdem gibt es praktische Abkürzungen für Wertzuweisungen, vor allem '''<code>+=</code>''' und '''<code>++</code>'''.<br />
<br />
* Beispiel 4:<br />
** <code>geschwindigkeit '''+=''' 5;</code><br />
** '''<code>+=</code>''' bedeutet: erhöhe um..., d.h. im Beispiel wird Geschwindigkeit wird um 5 erhöht.<br />
* Beispiel 5:<br />
** <code>geschwindigkeit'''++''';</code><br />
** '''<code>++</code>''' bedeutet: erhöhe um eins.<br />
<br />
= Verzweigungen (if-else) =<br />
Beispiel: die folgende Methode überprüft, welche von zwei Zahlen die größere ist.<br />
<br />
Es passiert folgendes: Wenn (<code>if</code>) <code>a</code> größer als <code>b</code> ist, dann wird <code>ergebnis</code> auf <code>a</code> gesetzt, sonst (<code>else</code>) auf <code>b</code>.<br />
<br />
<code><br />
public int bestimmeDieGroessere(int a, int b)<br />
{<br />
int ergebnis;<br />
'''if(a > b)'''<br />
{<br />
ergebnis = a;<br />
}<br />
'''else'''<br />
{<br />
ergebnis = b;<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
'''VORSICHT:'''<br />
Gleichheit überprüft man mit '''doppeltem''' Gleichzeichen:<br />
<code><br />
// Wenn x gleich drei ist, ...<br />
if(x '''==''' 3)<br />
{<br />
...<br />
}<br />
</code><br />
<br />
= Schleifen (while, for, do-while) =<br />
Bei Schleifen kommen die Fähigkeiten der Computer besonders zur Geltung: Schleifen ermöglichen es, dass man Aktionen mehrfach (d.h. auch 1.000 oder 1.000.000 mal) wiederholt.<br />
== for-Schleife ==<br />
Die for-Schleife ist eine '''Zählschleife'''. Sie wird eingesetzt, wenn man zählen kann, wie oft Aktionen wiederholt werden sollen. Dafür gibt es eine '''Zählvariable''', die häufig <code>i</code> heißt, aber jeder andere Name ist auch denkbar.<br />
<br />
'''Beispiel:'''<br />
<br />
Die folgende for-Schleife gibt die Zahlen 0, 3, 6, ...., 999 an die Konsole aus.<br />
<br />
<code><br />
'''for(int i=0; i<=333; i++)'''<br />
{<br />
System.out.println(3*i);<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
<br />
* Die Klammer nach dem <code>for</code> hat drei Teile:<br />
** ''Deklaration und Initialisierung der Zählvariable <code>i</code>:'' i startet bei 0.<br />
** ''Schleifenbedingung:'' Die Schleife wird so lange wiederholt, wie i <= 333 ist.<br />
** ''Veränderung bei jedem Schleifendurchlauf:'' i wird bei jedem Schleifendurchlauf um eins erhöht. (<code>i++</code> bedeutet dasselbe wie <code>i = i+1</code>). D.h. i nimmt nacheinander folgende Werte an: 0, 1, 2, ..., 333.<br />
** Im Schleifenrumpf wird mit <code>System.out.println(i);</code> jeweils das Dreifache von <code>i</code> an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.<br />
<br />
==while-Schleife==<br />
Die while-Schleife ist eine '''bedingte'''Schleife. Sie wird eingesetzt, wenn Aktionen wiederholt werden sollen, solange die '''Schleifenbedingung''', erfüllt ist.<br />
<br />
'''Erklärvideo'''<br><br />
'''[https://www.youtube.com/watch?v=kPovFPak0Hs Erklärvideo zu while-Schleifen (11:49min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br />
<br />
'''Beispiel:'''<br/><br />
Die folgende while-Schleife beginnt bei <code>zahl = 1</code>. <br/><br />
<code>zahl</code> wird dann so lange an die Konsole ausgegeben und verdoppelt, <br/>wie <code>zahl</code> kleiner als 1000 ist. <br/>D.h. die Ausgabe ist: 1, 2, 4, ..., 256, 512.<br />
<code><br />
int zahl = 1;<br />
'''while(zahl < 1000)'''<br />
{<br />
System.out.println(zahl);<br />
// zahl verdoppeln<br />
zahl = zahl * 2;<br />
}<br />
</code><br />
'''Erläuterung:'''<br />
* Die Klammer nach dem <code>while</code> enthält die Bedingung: <br/>Wiederhole, solange zahl kleiner 1000 ist.<br />
* Im Schleifenrumpf wird dann <code>zahl</code> an die Konsole ausgegeben <br/>und dann mit <code>zahl = zahl * 2;</code> verdoppelt.<br />
<br />
= Beziehungen zwischen Klassen =<br />
''Die Implementierung von Beziehungen zwischen Klassen ist auf anderen Seiten erklärt, auf die hier nur verwiesen wird.''<br />
<br />
'''"kennt"-Beziehung:'''<br />
<br />
Wie man kennt-Beziehungen implementiert, kann man hier nachlesen:<br/><br />
[[Klassen-_und_Implementationsdiagramm#Java-Quelltext:|Szenario Roller (Quelltext)]]<br />
<br />
'''Vererbung:'''<br/><br />
[[Vererbung#Implementierung|Szenario Buch - Fachbuch - Hörbuch]]<br />
<br />
=NullPointerException=<br />
Die NullPointerException ist beim Programmieren die häufigste Exception.<br />
<br />
'''Die NullpointerException wird auch im Abitur abgefragt!!!'''<br />
<br />
Eine NullpointerException tritt auf, wenn man auf eine Methode eines Elementes zugreift, das noch gar nicht erzeugt wurde.<br />
<br />
'''Beispiel 1:'''<br/><br />
Beispiel 1 zeigt, wie die NullpointerException beim Programmieren im Unterricht am häufigsten auftritt.<br />
<code><br />
public class SchuelerVerwaltung{<br />
private List<Schueler> schuelerListe;<br />
<br />
public SchuelerVerwaltung(){<br />
Schueler s1 = new Schueler("Gates","Bill"); <br />
<font color='red'>'''schuelerListe'''.append(s1);</font><br />
}<br />
}<br />
</code><br />
'''Erklärung 1:'''<br/><br />
In der roten Zeile kommt es zu einer NullPointerException, weil das Attribut <code>schuelerListe</code> noch gar nicht erzeugt wurde - es ist <code>null</code>.<br/>Für ein Objekt, das den Wert <code>null</code>hat, führt der Aufruf einer Methode (in diesem Fall <code>schuelerListe.'''append(s1)'''</code>) zu einer NullpointerException.<br />
<br />
Man kann die NullPointerException vermeiden, indem man <u>vor</u> der roten Zeile einfügt:<br />
<code><br />
schuelerListe = new List<>();<br />
</code><br />
'''Beispiel 2: Abituraufgabe'''<br/><br />
Das ist eine (verkürzte) Aufgabenstellung aus dem Abitur:<br />
<br />
''Analysieren und erläutern Sie, an welcher Stelle des Quellcodes ein Laufzeitfehler durch einen Zugriff auf ein nicht existentes Objekt (eine sogenannte NullPointerException)<br />
entstehen kann.''<br />
<code><br />
public Team wasErmittleIch(Team pTeam, int pX) {<br />
List<Team> auswahl = filtereTeams(pTeam, pX);<br />
auswahl.toFirst();<br />
int punkte = <font color='red'>'''pTeam'''.berechnePunkte()</font>;<br />
Team g = auswahl.getContent();<br />
int d = Math.abs(<font color='red'>'''g'''.berechnePunkte()</font> - punkte);<br />
auswahl.next();<br />
...<br />
}<br />
</code><br />
'''Erklärung 2:'''<br/><br />
An den roten Stellen kann es zu einer NullpointerException kommen:<br />
* Wenn <code>pTeam</code> den Wert <code>null</code> hat, kann man für <code>pTeam</code> nicht die Methode <code>berechnePunkte()</code> aufrufen.<br />
* Wenn <code>auswahl</code> eine leere Liste ist: dann hat die lokale Variable <code>g</code> den Wert <code>null</code>, und man kann für <code>g</code> dann nicht die Methode <code>berechnePunkte()</code> aufrufen.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java_Basis-Sprachelemente&diff=3657Java Basis-Sprachelemente2024-01-16T18:24:45Z<p>Akaibel: /* NullPointerException */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik-EF]]<br />
[[Kategorie:Informatik-Q1]]<br />
<br />
=Allgemeines=<br />
Hier werden die grundlegenden Sprachelemente von Java '''im Detail''' erklärt.<br />
<br />
Wer wissen möchte, wie eine '''ganze Klasse''' aussieht:<br />
* [[Klasse]]<br />
==Erklärvideos==<br />
<br />
* '''[https://www.youtube.com/watch?v=dEFJUra_3ZA Java-Crashkurs Teil 1 (28min)] '''<br/>In Teil 1 des Crash-Kurses geht es um Grundlagen der Programmierung einer Klasse, d.h.<br/>Klasse, Attribut, Konstruktor, Methode, Parameter, lokale Variable etc.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner.txt Programmiervorlage für den Taschenrechner]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-Dokumentation.pdf|Cheat sheet für Teil 1 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[[Medium:Taschenrechner-Fehlersuche.pdf|Taschenrechner Fehlersuche zum Ausdrucken (PDF)]]'''<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner-mit-Fehlern.txt Java-Quelltext für die Fehlersuche]'''<br/>Den Quelltext kann man in [https://www.jdoodle.com/online-java-compiler/ jdoodle] packen und dann die Fehlermeldungen durchklicken!<br />
&nbsp;<br />
* '''[https://youtu.be/IimFb4cEhUU Java-Crashkurs Teil 2 (40min)] '''<br/>In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner2.txt Programmiervorlage für den Taschenrechner (mit allem für Teil 2)]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-2-Dokumentation.pdf|Cheat sheet für Teil 2 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[https://youtu.be/JVeAUGX60-A Erklärvideo zu Klassen, Objekten, Attritbuten & Methoden (17:08min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br/>[[Medium:VAB-01 Informatik10 KlassenObjekteAttributeMethoden.pdf|Arbeitsblatt zum Video (PDF)]]. <br/>Zu Teilen der Aufgaben gibt es die Lösung im Video, die anderen Aufgaben werden erst im Unterricht besprochen.<br/>&nbsp;<br />
<br />
= Anforderungen Zentralabitur =<br />
Das Zentralabitur fordert die Kenntnis von bestimmten Basis-Sprachelementen, die hier aufgeführt sind.<br />
<br />
Im folgenden werden diese und weitere Basis-Sprachelemente erläutert.<br />
<br />
'''Stand: 2012 (im April 2013 noch aktuell)'''<br />
<br />
* Klassendefinitionen<br />
* Beziehungen zwischen Klassen<br />
** gerichtetete Assoziation<br />
** Vererbung<br />
* Attribute und Methoden (mit Parametern und Rückgabewerten)<br />
* Wertzuweisungen<br />
* Verzweigungen (if, switch)<br />
* Schleifen (while, for, do-while)<br />
<br />
= Klasse, Objekt, Klassendefinition =<br />
''Auf dieser Seite werden Klassen, Objekte etc. Schritt für Schritt erklärt.<br />
<br />
''Den erläuterten kompletten Quellcode einer Java-Klasse findet man hier: [[Klasse in Java]]''<br />
<br />
* Von einer '''Klasse''' können viele '''Objekte''' erzeugt werden.<br />
* Beispiel: Es gibt eine Klasse <code>Baum</code>, von der man viele einzelne Objekte erzeugen kann.<br />
* Java: Definiton einer Klasse:<br />
<code> <br />
'''public class Baum'''<br />
{<br />
// Attribute<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Attribute =<br />
* Attribute beschreiben, welche Eigenschaften bzw. Teil-Objekte die Objekte einer Klasse haben.<br />
* Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den <u>Attribut-Wert</u> haben.<br />
** Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.<br />
* Attribute haben einen <u>Attribut-Typ</u>. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa <code>int</code> für ganze Zahlen oder <code>double</code> für Kommazahlen. Für Namen eignet sich <code>String</code>.<br/>Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Java:<br />
** Attribute werden direkt nach der Klassen-Deklaration notiert.<br />
** Attribute sind in der Regel <code>private</code>, d.h. sie können nicht ohne Weiteres von Außen verändert werden.<br />
<br />
'''Beispiel 1:'''<br />
<br />
Objekte der Klasse <code>Auto</code> können unterschiedlichen Tankstand haben.<br />
<br />
Dafür gibt es das Attribut <code>tankstand</code>. Dieses hat den Datentyp <code>double</code>, weil es eine Kommazahl sein kann.<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
'''private double tankstand;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
'''Beispiel 2:'''<br />
<br />
Objekte der Klasse <code>Baum</code> bestehen aus einem <code>Quadrat</code> (für den Stamm) und einem <code>Kreis</code> (für die Krone). <br/>''Die Klassen <code>Quadrat</code> und <code>Kreis</code> müssen natürlich schon im Projekt enthalten sein!!''<br />
<br />
<code><br />
public class Baum<br />
{<br />
// Attribute<br />
'''private Quadrat stamm;'''<br />
'''private Kreis krone;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Konstruktor =<br />
'''Aufruf des Konstruktors:'''<br />
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:<br />
* Java: <code>Auto neuesAuto = '''new Auto()''';</code><br />
<br />
<br />
'''Deklaration des Konstruktors:'''<br />
* In der Deklaration des Konstruktors wird festgelegt, was passiert, wenn ein Objekt der Klasse erzeugt wird.<br />
* Der Konstruktor heißt genauso wie die Klasse.<br />
* Der Konstruktor hat '''keinen''' Rückgabetyp, also auch kein <code>void</code>.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private int tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto()'''<br />
'''{'''<br />
'''tankstand = 5.0;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch bekommt jedes Auto bei der Erzeugung einen Tankstand von 5.0, d.h. es kann direkt losfahren.<br />
<br />
== Konstruktor mit Parameter ==<br />
Man kann im Konstruktor einen Parameter übergeben, z.B. um direkt bei der Erzeugung die Eigenschaft eines Objektes festzulegen.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto(<u>double pTankstand</u>)'''<br />
'''{'''<br />
'''tankstand = <u>pTankstand</u>;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen.<br />
<br />
'''Aufgerufen''' wird dieser Konstruktor dann z.B. so:<br />
<br />
<code>Auto neuesAuto = '''new Auto(7.0)''';</code><br />
<br />
Damit hat <code>neuesAuto</code> den Tankstand 7.0<br />
<br />
= Methoden =<br />
In Methoden wird festgelegt, was man mit einem Objekt der Klasse machen kann.<br />
<br />
'''Beispiel:'''<br />
Für ein Objekt der Klasse Auto soll es die Methode <code>tanken</code> geben. Außerdem soll man den Tankstand mit der Methode <code>gibTankstand()</code> auslesen können.<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
public Auto()<br />
{<br />
tanstand = 5.0;<br />
}<br />
<br />
// Methoden<br />
'''public void tanken(double pLiter)'''<br />
'''{'''<br />
'''tankstand = tankstand + pLiter;'''<br />
'''}'''<br />
<br />
'''public double gibTankstand()''' <br />
'''{'''<br />
'''return tankstand;'''<br />
'''}'''<br />
}<br />
</code><br />
<br />
== Methodendeklaration / Methodenkopf ==<br />
Methoden werden durch den '''Methodenkopf (auch: die Methodensignatur)''' deklariert.<br />
<br />
D.h. für Objekte der Klasse kann man dann die Methode aufrufen.<br />
<br />
'''Erklärvideo'''<br />
<br />
Hier gibt es ein '''[https://youtu.be/YPVhVxL67xo Erklärvideo zu Methodensignaturen (auf youtube, 11:42min)]'''. <br/>'' (Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.)<br />
<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
private int preisstufe;<br />
<br />
//Konstruktor<br />
public Automat()<br />
{<br />
preisstufe = 0;<br />
eingeworfen = 0;<br />
}<br />
<br />
//Methoden<br />
<br />
'''public void preisstufeWaehlen(int pPreisstufe)'''<br />
{<br />
preisstufe = pPreisstufe;<br />
}<br />
<br />
'''public int gibPreisstufe()'''<br />
{<br />
int ergebnis = preisstufe;<br />
return ergebnis;<br />
}<br />
<br />
'''public void geldEinwerfen(int betragInCent)'''<br />
{<br />
eingeworfen = eingeworfen + betragInCent;<br />
}<br />
<br />
'''private double steuern(int betrag)'''<br />
{<br />
double ergebnis = betrag * 0.19;<br />
return ergebnis;<br />
}<br />
<br />
'''public int geldZurueckGeben()'''<br />
{<br />
int ergebnis = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
Der '''Methodenkopf''' ist immer gleich aufgebaut:<br />
# '''Zugriffsmodifikator''': <code>public</code> oder <code>private</code>.<br />
## Auf <code>public</code>-Methoden darf man auch von außen zugreifen; sie sind '''öffentlich'''.<br />
## Auf <code>private</code>-Methoden darf nur die Klasse selbst zugreifen, d.h. von außen ist diese Methode nicht sichtbar! Das ist z.B. sinnvoll für Hilfsmethoden, die nicht jeder benutzen soll.<br />
# '''Rückgabetyp''': <code>void</code> für ''nichts'' bzw. ein Datentyp (wie z.B. <code>int</code>) oder auch eine Klasse.<br />
## Im Rückgabetyp wird festgelegt, ob und was die Methode zurückgibt. So sollten Methoden, die etwas berechnen, das Ergebnis auch zurückgeben.<br />
## Die Methode <code>public '''void''' geldEinwerfen(int betragInCent)</code> gibt ''nichts'' zurück. <code>'''void'''</code> ist das Schlüsselwort für ''nichts''.<br />
## Die Methode <code>public '''int''' summe(int a, int b) </code> gibt <code>int</code> zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein '''return-Statement''', z.B.: <code>return ergebnis;</code><br />
# '''Methodenname''': Methodennamen sind Verben, denn Methoden bezeichnen Tätigkeiten! Außerdem ist es üblich, Methodennamen '''klein''' zu schreiben.<br />
# '''Parameter''': In der Klammer nach dem Methodenname findet sich der (bzw. die Parameter).<br />
## Bei den Parametern wird erst der '''Parameter-Typ''' (z.B. <code>int</code>) und dann der '''Parameter-Name''' angegeben.<br />
## Mehrere Parameter werden durch Komma getrennt, z.B. <code>public int summe('''int a, int b''')</code><br />
## Methoden ohne Parameter haben leere Klammern, z.B.: <code>public int geldZurueckGeben'''()'''</code><br />
<br />
== Parameter ==<br />
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.<br />
* Das ist hier der Fall bei der Methode <code>geldEinwerfen</code>: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie viel Geld man einwirft.<br />
* Dafür haben Methoden '''Parameter''', in diesem Fall <code>betragInCent</code>.<br />
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von '''Parameter-Typ'''.<br />
** Der Parameter-Typ von <code>betragInCent</code> ist <code>int</code>, also eine ganze Zahl.<br />
** Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den <u>Parameter übergeben</u>. <br />
<code><br />
Automat derAutomat = new Automat();<br />
// jetzt kommt der Methodenaufruf mit Parameterübergabe!<br />
derAutomat.geldEinwerfen('''50''');<br />
</code><br />
* Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur <code>()</code>. Das ist wichtig, um sie von Attribute zu unterscheiden!<br />
<br />
== Rückgabetyp einer Methode ==<br />
Für eine Methode wird immer der Rückgabetyp festgelegt.<br />
* '''<code>void</code>''': Wenn die Methode '''nichts''' zurückgibt (bei einer verändernden Methode).<br />
** Beispiel: <code>public '''void''' geldEinwerfen(int betragInCent)</code><br />
* '''<code>int</code>''': Wenn die Methode eine ganze Zahl (<code>int</code>) zurückgibt.<br />
** Beispiel: <code>public '''int''' geldZurueckGeben()</code><br />
* Statt <code>int</code> kann auch jeder andere Typ oder auch eine Klasse (z.B. <code>Automat</code>) der Rückgabe-Typ einer Methode sein.<br />
** Beispiel: <code>public '''Automat''' gibKopie()</code> : Diese Methode würde eine Kopie des Automaten (also ein Objekt der Klasse <code>Automat</code>) zurückgeben.<br />
<br />
Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
<br />
== sondierende Methode / verändernde Methode ==<br />
* '''sondierende Methode (=get-Methode)''': Dieser Methodentyp ''gibt eine Information über das Objekt zurück''. Diese Methode braucht einen Rückgabetyp (d.h. nicht <code>void</code>) und ein return-Statement.<br />
** Beispiel: <code>public '''int''' gibPreisstufe()</code><br />
* '''verändernde Methode (=set-Methode)''': Dieser Methodentyp ''verändert das Objekt''. Häufig hat dieser Methodentyp einen (oder mehrere) '''Parameter'''. Sie hat zumeist den Rückgabetyp <code>void</code>, denn sie gibt in der Regel nichts zurück.<br />
** Beispiel: <code>public void preisstufeWaehlen('''int pPreisstufe''')</code><br />
<br />
== Methodenaufruf ==<br />
Methoden der gleichen Klasse werden durch ihren Methodennamen aufgerufen.<br />
<br />
'''VORSICHT:'''<br />
Wenn man eine sondierende Methode aufruft, dann muss man sich für das Ergebnis interessieren!<br />
<br />
'''Beispiel:'''<br />
<br />
Im Beispiel ruft die Methode <code>groessteZahl</code> dreimal die Methode <code>gibGroessereZahl</code> auf. Das Ergebnis des Aufrufs wird jeweils in einer lokalen Variable (z.B. <code>groessere12</code> gespeichert, um damit weiter zu rechnen.<br />
<code><br />
public class Rechner{<br />
public int groessteZahl(int z1, int z2, int z3, int z4)<br />
{<br />
int groessere12 = '''gibGroessereZahl(z1, z2);'''<br />
int groessere34 = '''gibGroessereZahl(z3, z4);'''<br />
int ergebnis = '''gibGroessereZahl(groessere12, groessere34);'''<br />
return ergebnis;<br />
}<br />
<br />
'''public int gibGroessereZahl(int a, int b)'''<br />
{<br />
int ergebnis;<br />
if(a > b)<br />
{<br />
return a;<br />
}<br />
else<br />
{<br />
return b;<br />
}<br />
}<br />
}<br />
</code><br />
<br />
===Methoden für Objekte anderer Klassen aufrufen ===<br />
Man kann auf für ein Objekt einer anderen Klasse eine Methode aufrufen; damit wird eine Aufgabe '''delegiert'''.<br />
<br />
'''WICHTIG: Das wesentliche Syntax-Element ist der Punkt!''' <br/>Man gibt erst das Objekt an, dann den Punkt, dann die Methode (ggf. mit Parameter).<br/>Z.B. <code> '''stamm.bewegeZuPosition(110,120)''';</code><br />
<br />
'''Beispiel :'''<br />
<code><br />
public class Baum<br />
{<br />
// Attribute der Klasse Baum<br />
private Kreis krone;<br />
private Quadrat stamm;<br />
<br />
// Konstruktor der Klasse Baum<br />
public Baum()<br />
{<br />
stamm = new Quadrat();<br />
'''stamm.bewegeZuPosition(110,120)''';<br />
'''stamm.sichtbarMachen()''';<br />
krone = new Kreis();<br />
'''krone.bewegeZuPosition(100,100)''';<br />
'''krone.sichtbarMachen()''';<br />
}<br />
}<br />
</code><br />
<br />
'''Erklärung:'''<br />
* <code>stamm</code> ist ein Objekt vom Typ <code>Quadrat</code>; deshalb verfügt <code>stamm</code> über die Methode <code>sichtbarMachen()</code>.<br />
* Im Konstruktor von <code>Baum</code> wird diese Methode mithilfe des Punktes aufgerufen:<br />
** Attributname -> Punkt -> Methodenname.<br />
*<br />
Ein Objekt der Klasse <code>Haus</code> ruft in einem Objekt der Klasse <code>Quadrat</code> die Methode<br />
<br />
=lokale Variable=<br />
* '''Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.'''<br />
* Lokale Variablen kann man (im Gegensatz zu Attributen) <u>nicht</u> in der ganzen Klasse benutzen. <br />
* Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.<br />
** U.a. werden lokale Variablen immer dann eingesetzt, wenn eine Methode ein Ergebnis berechnen und dann zurückgegeben soll.<br />
<br />
'''Beispiel aus der Klasse <code>Automat</code>:'''<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
<br />
// weitere Attribute, Konstruktor und Methoden<br />
<br />
public int geldZurueckGeben()<br />
{<br />
'''int ergebnis''' = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
= Wertzuweisungen =<br />
Attributen und lokalen Variablen können Werte zugewiesen werden.<br />
* Beispiel 1:<br />
** <code>geschwindigkeit = 10;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert 10 zugewiesen.<br />
* Beispiel 2:<br />
** <code>geschwindigkeit = neueGeschwindigkeit;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>neueGeschwindigkeit</code> zugewiesen.<br />
* Beispiel 3:<br />
** <code>geschwindigkeit = geschwindigkeit + 1;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>geschwindigkeit+1</code> zugewiesen,<br />
** d.h. die Geschwindigkeit wird '''um 1 erhöht'''!<br />
* Allgemein:<br />
** '''links vom Gleichzeichen''' steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.<br />
** '''rechts vom Gleichzeichen''' steht der neue Wert.<br />
<br />
<br />
Außerdem gibt es praktische Abkürzungen für Wertzuweisungen, vor allem '''<code>+=</code>''' und '''<code>++</code>'''.<br />
<br />
* Beispiel 4:<br />
** <code>geschwindigkeit '''+=''' 5;</code><br />
** '''<code>+=</code>''' bedeutet: erhöhe um..., d.h. im Beispiel wird Geschwindigkeit wird um 5 erhöht.<br />
* Beispiel 5:<br />
** <code>geschwindigkeit'''++''';</code><br />
** '''<code>++</code>''' bedeutet: erhöhe um eins.<br />
<br />
= Verzweigungen (if-else) =<br />
Beispiel: die folgende Methode überprüft, welche von zwei Zahlen die größere ist.<br />
<br />
Es passiert folgendes: Wenn (<code>if</code>) <code>a</code> größer als <code>b</code> ist, dann wird <code>ergebnis</code> auf <code>a</code> gesetzt, sonst (<code>else</code>) auf <code>b</code>.<br />
<br />
<code><br />
public int bestimmeDieGroessere(int a, int b)<br />
{<br />
int ergebnis;<br />
'''if(a > b)'''<br />
{<br />
ergebnis = a;<br />
}<br />
'''else'''<br />
{<br />
ergebnis = b;<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
'''VORSICHT:'''<br />
Gleichheit überprüft man mit '''doppeltem''' Gleichzeichen:<br />
<code><br />
// Wenn x gleich drei ist, ...<br />
if(x '''==''' 3)<br />
{<br />
...<br />
}<br />
</code><br />
<br />
= Schleifen (while, for, do-while) =<br />
Bei Schleifen kommen die Fähigkeiten der Computer besonders zur Geltung: Schleifen ermöglichen es, dass man Aktionen mehrfach (d.h. auch 1.000 oder 1.000.000 mal) wiederholt.<br />
== for-Schleife ==<br />
Die for-Schleife ist eine '''Zählschleife'''. Sie wird eingesetzt, wenn man zählen kann, wie oft Aktionen wiederholt werden sollen. Dafür gibt es eine '''Zählvariable''', die häufig <code>i</code> heißt, aber jeder andere Name ist auch denkbar.<br />
<br />
'''Beispiel:'''<br />
<br />
Die folgende for-Schleife gibt die Zahlen 0, 3, 6, ...., 999 an die Konsole aus.<br />
<br />
<code><br />
'''for(int i=0; i<=333; i++)'''<br />
{<br />
System.out.println(3*i);<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
<br />
* Die Klammer nach dem <code>for</code> hat drei Teile:<br />
** ''Deklaration und Initialisierung der Zählvariable <code>i</code>:'' i startet bei 0.<br />
** ''Schleifenbedingung:'' Die Schleife wird so lange wiederholt, wie i <= 333 ist.<br />
** ''Veränderung bei jedem Schleifendurchlauf:'' i wird bei jedem Schleifendurchlauf um eins erhöht. (<code>i++</code> bedeutet dasselbe wie <code>i = i+1</code>). D.h. i nimmt nacheinander folgende Werte an: 0, 1, 2, ..., 333.<br />
** Im Schleifenrumpf wird mit <code>System.out.println(i);</code> jeweils das Dreifache von <code>i</code> an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.<br />
<br />
==while-Schleife==<br />
Die while-Schleife ist eine '''bedingte'''Schleife. Sie wird eingesetzt, wenn Aktionen wiederholt werden sollen, solange die '''Schleifenbedingung''', erfüllt ist.<br />
<br />
'''Erklärvideo'''<br><br />
Hier gibt es ein '''[https://www.youtube.com/watch?v=kPovFPak0Hs Erklärvideo zu while-Schleifen (auf youtube, 11:49min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br />
<br />
'''Beispiel:'''<br />
Die folgende while-Schleife beginnt bei <code>zahl = 1</code>. <code>zahl</code> wird dann so lange an die Konsole ausgegeben und verdoppelt, wie <code>zahl</code> kleiner als 1000 ist. D.h. die Ausgabe ist: 1, 2, 4, ..., 256, 512.<br />
<br />
<code><br />
int zahl = 1;<br />
'''while(zahl < 1000)'''<br />
{<br />
System.out.println(zahl);<br />
// zahl verdoppeln<br />
zahl = zahl * 2;<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
* Die Klammer nach dem <code>while</code> enthält die Bedingung: Wiederhole, solange zahl kleiner 1000 ist.<br />
* Im Schleifenrumpf wird dann <code>zahl</code> an die Konsole ausgegeben und dann mit <code>zahl = zahl * 2;</code> verdoppelt.<br />
<br />
= Beziehungen zwischen Klassen =<br />
''Die Implementierung von Beziehungen zwischen Klassen ist auf anderen Seiten erklärt, auf die hier nur verwiesen wird.''<br />
<br />
'''"kennt"-Beziehung:'''<br />
<br />
Wie man kennt-Beziehungen implementiert, kann man hier nachlesen:<br/><br />
[[Klassen-_und_Implementationsdiagramm#Java-Quelltext:|Szenario Roller (Quelltext)]]<br />
<br />
'''Vererbung:'''<br/><br />
[[Vererbung#Implementierung|Szenario Buch - Fachbuch - Hörbuch]]<br />
<br />
=NullPointerException=<br />
Die NullPointerException ist beim Programmieren die häufigste Exception.<br />
<br />
'''Die NullpointerException wird auch im Abitur abgefragt!!!'''<br />
<br />
Eine NullpointerException tritt auf, wenn man auf eine Methode eines Elementes zugreift, das noch gar nicht erzeugt wurde.<br />
<br />
'''Beispiel 1:'''<br/><br />
Beispiel 1 zeigt, wie die NullpointerException beim Programmieren im Unterricht am häufigsten auftritt.<br />
<code><br />
public class SchuelerVerwaltung{<br />
private List<Schueler> schuelerListe;<br />
<br />
public SchuelerVerwaltung(){<br />
Schueler s1 = new Schueler("Gates","Bill"); <br />
<font color='red'>'''schuelerListe'''.append(s1);</font><br />
}<br />
}<br />
</code><br />
'''Erklärung 1:'''<br/><br />
In der roten Zeile kommt es zu einer NullPointerException, weil das Attribut <code>schuelerListe</code> noch gar nicht erzeugt wurde - es ist <code>null</code>.<br/>Für ein Objekt, das den Wert <code>null</code>hat, führt der Aufruf einer Methode (in diesem Fall <code>schuelerListe.'''append(s1)'''</code>) zu einer NullpointerException.<br />
<br />
Man kann die NullPointerException vermeiden, indem man <u>vor</u> der roten Zeile einfügt:<br />
<code><br />
schuelerListe = new List<>();<br />
</code><br />
'''Beispiel 2: Abituraufgabe'''<br/><br />
Das ist eine (verkürzte) Aufgabenstellung aus dem Abitur:<br />
<br />
''Analysieren und erläutern Sie, an welcher Stelle des Quellcodes ein Laufzeitfehler durch einen Zugriff auf ein nicht existentes Objekt (eine sogenannte NullPointerException)<br />
entstehen kann.''<br />
<code><br />
public Team wasErmittleIch(Team pTeam, int pX) {<br />
List<Team> auswahl = filtereTeams(pTeam, pX);<br />
auswahl.toFirst();<br />
int punkte = <font color='red'>'''pTeam'''.berechnePunkte()</font>;<br />
Team g = auswahl.getContent();<br />
int d = Math.abs(<font color='red'>'''g'''.berechnePunkte()</font> - punkte);<br />
auswahl.next();<br />
...<br />
}<br />
</code><br />
'''Erklärung 2:'''<br/><br />
An den roten Stellen kann es zu einer NullpointerException kommen:<br />
* Wenn <code>pTeam</code> den Wert <code>null</code> hat, kann man für <code>pTeam</code> nicht die Methode <code>berechnePunkte()</code> aufrufen.<br />
* Wenn <code>auswahl</code> eine leere Liste ist: dann hat die lokale Variable <code>g</code> den Wert <code>null</code>, und man kann für <code>g</code> dann nicht die Methode <code>berechnePunkte()</code> aufrufen.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik_Fachbegriffe&diff=3656Informatik Fachbegriffe2024-01-16T18:20:51Z<p>Akaibel: /* Java-Programmierung mit linearen Datenstrukturen */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
<br />
Hier werden die wesentlichen Fachbegriffe zusammengestellt, die für das Informatik-Abitur relevant sind.<br />
<br />
''Kursiv sind "interne" Begriffe, die anschaulich sind, aber keine echten Fachbegriffe.''<br />
=Operatoren=<br />
Die Operatoren definieren, was genau man in einer Aufgabe zu machen hat. Anders als in Mathe sind die Operatoren weitestgehend "intuitiv" verständlich - mit Ausnahme des Operators "Analysieren" (siehe unten).<br />
* '''Liste der Operatoren:'''<br/>analysieren, angeben, anwenden, begründen, beschreiben, bestimmen, beurteilen, darstellen, dokumentieren, entscheiden, entwerfen, entwickeln, erläutern, ermitteln, erweitern, implementieren, interpretieren, modellieren, modifizieren, Stellung nehmen, überführen, vergleichen, vervollständigen, zeigen<br />
* '''Vollständige Liste der Operatoren mit Erläuterungen:'''<br/>[https://www.standardsicherung.schulministerium.nrw.de/cms/zentralabitur-wbk/faecher/getfile.php?file=2282 Operatoren Informatik-Abitur (Standardsicherung NRW)]<br />
* '''Analysieren Sie ... '''.<br/>''Der Operator "Analysieren Sie..." heißt in Informatik nur so viel wie "Denken Sie nach über...". <br/>Das heißt: <font color='red'>Dazu muss man NICHTS aufschreiben!!</font><br/>Der Operator "Analysieren Sie..." steht immer zusammen mit einem anderen Operator - und für den muss man was tun.<br />
<br />
=Datenbanken=<br />
==Entity-Relationship-Modellierung==<br />
'''[[Entity-Relationship-Modell|zum Nachlesen hier klicken]]'''<br />
* Kardinalität<br />
* 1:n<br />
* n:m<br />
* Primärschlüssel<br />
* Attribut<br />
* Entitätsmenge<br />
* Entität (=ein Objekt einer Entitätsmenge)<br />
* Relation (=Beziehung)<br />
<br />
==relationales Datenmodell==<br />
'''[[Relationales Datenmodell|zum Nachlesen hier klicken]]'''<br />
* Tabelle<br />
* Relationenschema (damit meint das Zentralabitur eine Tabelle)<br />
* Datenbankschema (damit meint das Zentralabitur das ganze relationale Datenmodell)<br />
* Attribut<br />
* Primärschlüssel: <u>unterstrichen</u><br />
* Fremdschlüssel: ↑<br/>''...bezieht sich auf den Primärschlüssel der Tabelle ...''<br />
* kombinierter Primärschlüssel<br />
<br />
==Normalisierung==<br />
'''[[Normalisierung|zum Nachlesen hier klicken]]'''<br />
* atomar<br />
* nicht eindeutiger Primärschlüssel<br />
* funktional abhängig von einem Teil des Primärschlüssel (Verstoß gegen 2. NF)<br />
* funktional abhängig von einem Nicht-Schlüssel-Attribut (Verstoß gegen 3. NF)<br />
* Anomalien<br />
** Einfüge-Anomalie<br />
** Änderungs-Anomalie<br />
** Lösch-Anomalie<br />
** die können nach Normalisierung nicht mehr auftreten!<br />
<br />
==SQL==<br />
'''[[SQL|zum Nachlesen hier klicken]]'''<br />
* Kartesisches Produkt: "jede(r) mit jedem"<br />
* Abgleich zwischen Tabellen<br />
* Verknüpfen (Join) von zwei Tabellen, wobei ... mit ... abgeglichen wird.<br />
* ''"Drückeberger"'': <code>... LEFT JOIN ... WHERE ... IS NULL</code><br />
* Differenz: <code>NOT IN</code><br />
* Vereinigung: <code>UNION</code><br />
* selbstdefinierte Tabelle<br />
* Alias: <code>AS</code><br />
* zusammenfassen von Zeilen: <code>GROUP BY</code><br />
* sortieren nach: <code>ORDER BY</code><br />
<br />
==mit Java auf Datenbanken zugreifen==<br />
'''[[Java-SQL|zum Nachlesen hier klicken]]'''<br />
* DatabaseConnector<br />
* Query (=Abfrage)<br />
* Variablen (z.B. Parameter) im SQL-Statement<br />
* Zeilenzahl: <code>int zeilenZahl = queryResult.getRowCount();</code><br />
* Array (2-dim): <code>String[][] data = queryResult.getData();</code><br />
** durchlaufen:<br/><code>for(int i=0; i<data.length; i++){<br/>&nbsp;&nbsp;&nbsp;String name = data[i][0];<br/>&nbsp;&nbsp;&nbsp;String vorname = data[i][1];</code><br />
* In Zahl konvertieren: <code>int zahl = Integer.parseInt(data[i][0]);</code><br />
<br />
=Objektorientierte Modellierung und Programmierung=<br />
'''zum Nachlesen:'''<br />
* [[Klassen-_und_Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* [[Klasse|Klasse]]<br />
* [[Vererbung|Vererbung]]<br />
* [[Polymorphie|Polymorphie]]<br />
* [[Abstrakte Klasse|Abstrakte Klasse]]<br />
* [[Interface|Interface]]<br />
* [[Java_Basis-Sprachelemente|Java Basis Sprachelemente]], u.a. Bedingung, Schleife etc.<br />
* [[Array|Arrays]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Vererbung|Vererbung]]<br />
** erbt von <br />
** ist ein (gleichbedeutend mit "erbt von"!)<br />
** Super-Klasse<br />
** Sub-Klasse<br />
* [[Polymorphie|Polymorphie]]<br />
** polymorphe Methode<br />
* [[Abstrakte Klasse|Abstrakte Klasse]] (=Klasse mit mind. einer abstrakten Methode)<br />
* abstrakte Methode<br />
* [[Interface|Interface]]<br />
* [[Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* hat-Beziehung<br />
* Assoziation (=kennt-Beziehung)<br />
* Multiplizität<br />
* [[Klasse|Klasse]]<br />
** Objekt (Von einer Klasse kann man mehrere Objekte erzeugen.)<br />
** Attribut<br />
*** public / private<br />
** Konstruktor<br />
* [[Java_Basis-Sprachelemente#Methoden|Methode]]<br />
** Parameter<br />
** lokale Variable<br />
** Rückgabetyp<br />
** public / private<br />
* ContentType (z.B. für Listen kann man den ContentType angeben.)<br />
* [[Interface|Schnittstelle (interface, vgl. ComparableContent)]]<br />
* [[Struktogramm]]<br />
* Anweisung<br />
* Methodenaufruf<br />
* [[Java_Basis-Sprachelemente#Verzweigungen_(if-else)|Bedingung]]<br />
* [[Java_Basis-Sprachelemente#Schleifen_(while,_for,_do-while)|Schleife]]<br />
** Zählschleife (for)<br />
** bedingte Schleife (while)<br />
** mit Schleife ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
* [[Array|Arrays]]<br />
** Index<br />
** Wert<br />
** [[Array#Zweidimensionale_Arrays|zweidimensionales Array]], z.B.: <code> private int[][] einmalEinsTabelle;</code><br />
<br />
=Java-Programmierung mit linearen Datenstrukturen=<br />
'''zum Nachlesen:'''<br />
* [[Queue#Verwendung_von_Queues|Verwendung von Queues]]<br />
* [[Stack#Verwendung_von_Stacks|Verwendung von Stacks]]<br />
* [[List#Standardvorgehen_im_Umgang_mit_Listen|List: Standardvorgehen]]<br />
* [[Array#Ein_Array_mit_einer_for-Schleife_durchlaufen|Array: durchlaufen]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Laufzeit_von_Algorithmen|Laufzeit]]<br />
** O(log(n)): Suchen in einem [[Binärer Suchbaum|Binären Suchbaum]]<br />
** O(n): Suchen in einer unsortierten Liste<br />
** O(n*log(n)): Sortieren mit [[Quicksort|Quicksort]]<br />
** O(n<sup>2</sup>): Sortieren mit [[Bubblesort]], [[Insertionsort]], [[Selectionsort|Selectionsort]]<br />
* <u>statische</u> Datenstruktur (Array): <br/>''Man muss vorher angeben, wie viele Einträge das Array hat.''<br />
* <u>dynamische</u> Datenstrukturen: Stack, List, Queue (und auch BinaryTree, BinarySearchTree, Graph)<br/>''Dynamische Datenstrukturen können während der Laufzeit "wachsen" und "schrumpfen".''<br />
* [[Java_Basis-Sprachelemente#NullPointerException|NullPointerException]]<br />
* [[Queue|Queue]]: Schlange (vorne - hinten)<br />
** vorderstes Element: <code>pQueue.front()</code><br />
** anhängen: <code>pQueue.enqueue(...)</code> <br />
** vorderstes Element entfernen: <code>pQueue.dequeue()</code><br />
** ist leer: <code>pQueue.isEmpty()</code><br />
** Hilfs-Queue: z.B. um einen Queue zu durchlaufen, ohne ihn zu zustören<br />
* [[Stack|Stack]]: Stapel (oben)<br />
** oberstes Element: <code>pStack.top()</code><br />
** oben drauflegen: <code>pStack.push(...)</code> <br />
** oberstes Element entfernen: <code>pStack.pop()</code><br />
** ist leer: <code>pStack.isEmpty()</code><br />
** Hilfs-Stack: z.B. um einen Stack zu durchlaufen, ohne ihn zu zustören<br />
* [[List|List]]: Liste.<br/>''Listen kann man einfach durchlaufen und irgendwo einfügen.''<br />
** anhängen: <code>pList.append(...)</code><br />
** einfügen vor dem aktuellen Element: <code>pList.insert(...);</code><br />
* [[Array|Array]]: <br/>''statische Datenstruktur - man muss die Anzahl der Elemente vorher festlegen.''<br />
* durchlaufen (Liste, Array)<br />
** ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
** eine Liste durchlaufen: <code>for(pList.toFirst(); pList.hasAccess(); pList.next())</code><br />
* aktuelles Element:<br />
** Array: <code>array[i];</code><br />
** Liste: <code>pList.getContent();</code><br />
* erzeugen<br />
** erzeugen eines Objektes: <code>Person p = '''new''' Person("Mustermann", "Max");</code><br />
** erzeugen einer Liste: <code>List<Person> ergebnisListe = '''new''' List<>();</code><br />
** erzeugen eines Arrays: <br/>z.B. <code>Person[] einwohner = '''new''' int[1000];</code><br/>''Vorsicht! In jedem der 1000 Werte steht <code>null</code>!''<br />
** erzeugen eines zweidimensionalen Arrays: <code>int[][] einmalEinsTabelle = new int[10][10];</code><br />
* Schleife<br />
** Schleife verlassen: <code>break;</code><br />
** Schleife beim nächsten Element fortsetzen: <code>continue;</code><br />
* Methode verlassen <code>return;</code><br />
* zurückgeben: <code>return ergebnis;</code><br />
* ausgeben: <code>System.out.println("Hallo");</code><br />
<br />
=Sortierverfahren=<br />
* [[Bubblesort]] <u>nur für Arrays!</u>, Laufzeit O(n<sup>2</sup>)<br />
* [[Insertionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* [[Selectionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* nur LK: [[Quicksort]] für Listen, Laufzeit O(n*log(n)) im Average Case<br />
* Sortieren mit einem [[Binärer Suchbaum|Binären Suchbaum ]]<br/>- Der Reihe nach in den Binären Suchbaum einfügen<br/>- Inorder-Traversierung<br/>Laufzeit O(n*log(n)) im Average Case<br />
<br />
=Binärbäume und binäre Suchbäume=<br />
* Rahmenmethode<br />
* rekursive Methode<br />
* Abbruchbedingung<br />
* ''Wurzelbehandlung''<br />
* ''Sachlogik''<br />
* rekursive Aufrufe<br />
* Traversierung<br />
* Preorder<br />
* Inorder (=im Suchbaum: Sortierte Ausgabe!)<br />
* Levelorder (nur LK)<br />
* Baumliste für Levelorder (nur LK)<br />
* ComparableContent<br />
* implementiert die Schnittstelle (ComparableContent)<br />
* ''Dummy'': zum Suchen in Suchbäumen.<br />
<br />
=Automaten und Grammatiken=<br />
'''zum Nachlesen:'''<br/><br />
[https://sibiwiki.de/wiki/index.php?title=Kategorie:Endliche_Automaten Kategorie endliche Automaten]<br />
<br/>''Da gibt es Links zu allen Unterüberschriften.''<br />
==endliche Automaten==<br />
* [[Deterministischer Endlicher Automat|Deterministischer endlicher Automat (DEA)]]<br />
** A, Z, d, Q<sub>0</sub>, E: ''allen Zuhörern doofen Quatsch erzählen''<br />
* Der DEA '''erkennt''' eine reguläre Sprache<br />
* Der DEA '''überprüft''' ein Wort, ob es zur Sprache gehört.<br />
* [[Nicht-deterministischer endlicher Automaten|Nicht-deterministischer endlicher Automat (NEA)]]<br />
** ''"es gibt einen Weg"''<br />
* Zustand<br />
**Anfangszustand<br />
**Endzustände<br />
* Übergang<br />
* Alphabet<br />
* Zustands-Übergangs-Graph<br />
* Zustands-Übergangs-Tabelle<br />
* Zustandsfolge<br />
** für einen NEA ggf. mit geschweifter Klammer mehrere Zustände zusammenfassen.<br />
* Senke (=ein Zustand, aus dem es keinen Ausweg mehr gibt)<br />
* [[Potenzmengenkonstruktion|Potenzmengenkonstruktion]]<br />
** Potenzmenge (=eine Menge von Zuständen)<br />
<br />
==[[Reguläre Grammatik|reguläre Grammatik]]==<br />
* G = {N, T, S, P} ''Nerds testen Sonys Playstation''<br />
* linkslineare Grammatik: Nicht-Terminal links<br />
* rechtslineare Grammatik: Nicht-Terminal rechts<br />
** <i>linkslineare und rechtslineare Regeln nicht mischen!!!<br/>z.B.: <code>S → aS | Sb</code><br/>ist nicht regulär!!!</i><br />
* Terminal-Symbol<br />
* Nicht-Terminal-Symbol<br />
**Startsymbol<br />
* Produktionsregeln<br />
* Produktion eines Wortes<br />
* die RG erzeugt eine (reguläre) Sprache<br />
<br />
==[[Kellerautomat|Kellerautomaten (nur LK)]]==<br />
* Keller-Alphabet<br />
* Keller-Zeichen<br />
* Epsilon (ε): Um den Endzustand zu erreichen, darf man das Zeichen ε (="nichts") schreiben.<br />
<br />
==[[Kontextfreie_Grammatik|kontextfreie Grammatik (nur LK)]]==<br />
* lässt sich durch Kellerautomaten prüfen<br />
<br />
==Parser==<br />
* [[Parser|Parser für DEA]]<br />
* [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomaten (nur LK)]]<br />
** Keller (=<code>Stack</code>)<br />
<br />
=[[Graph|Graph (nur LK!)]]=<br />
* Knoten<br />
* Kante<br />
* markieren (Knoten oder Kante)<br />
* Markierung aufheben<br />
* Gewicht<br />
* Traversierung (d.h. Breitendurchlauf oder Tiefendurchlauf)<br />
* [[Graph#Tiefendurchlauf|Tiefendurchlauf]]<br />
** rekursiv<br />
* [[Graph#Breitendurchlauf|Breitendurchlauf]]<br />
** Knotenliste<br />
* [[Dijkstra-Algorithmus|Dijkstra-Algorithmus]]<br />
* rote Liste (für Dijkstra-Algo)<br />
* gelbe Liste (für Dijkstra-Algo)<br />
<br />
=[[Datenschutz|Datenschutz]]=<br />
Schutz von Angaben, aus denen man einen bestimmten Menschen erkennen kann oder die einem bestimmten Menschen zugeordnet werden können. <br />
<br />
'''Prinzipien des Datenschutzes:'''<br />
* <u>Verbot mit Erlaubnisvorbehalt</u><br />
* Datenminimierung<br />
* Zweckbindung<br />
* Transparenz<br />
* <u>Erforderlichkeit</u><br />
<br />
=[[Backtracking|Backtracking (nur LK!)]]=<br />
* Stufe<br />
* Teillösungsschritt<br />
* Abbruchbedingung<br />
** Lösung erreicht<br />
** Lösung nicht mehr erreichbar<br />
** maximale Stufenzahl überschritten<br />
* rückgängig machen</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java_Basis-Sprachelemente&diff=3655Java Basis-Sprachelemente2024-01-16T18:17:52Z<p>Akaibel: /* NullPointerException */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik-EF]]<br />
[[Kategorie:Informatik-Q1]]<br />
<br />
=Allgemeines=<br />
Hier werden die grundlegenden Sprachelemente von Java '''im Detail''' erklärt.<br />
<br />
Wer wissen möchte, wie eine '''ganze Klasse''' aussieht:<br />
* [[Klasse]]<br />
==Erklärvideos==<br />
<br />
* '''[https://www.youtube.com/watch?v=dEFJUra_3ZA Java-Crashkurs Teil 1 (28min)] '''<br/>In Teil 1 des Crash-Kurses geht es um Grundlagen der Programmierung einer Klasse, d.h.<br/>Klasse, Attribut, Konstruktor, Methode, Parameter, lokale Variable etc.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner.txt Programmiervorlage für den Taschenrechner]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-Dokumentation.pdf|Cheat sheet für Teil 1 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[[Medium:Taschenrechner-Fehlersuche.pdf|Taschenrechner Fehlersuche zum Ausdrucken (PDF)]]'''<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner-mit-Fehlern.txt Java-Quelltext für die Fehlersuche]'''<br/>Den Quelltext kann man in [https://www.jdoodle.com/online-java-compiler/ jdoodle] packen und dann die Fehlermeldungen durchklicken!<br />
&nbsp;<br />
* '''[https://youtu.be/IimFb4cEhUU Java-Crashkurs Teil 2 (40min)] '''<br/>In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner2.txt Programmiervorlage für den Taschenrechner (mit allem für Teil 2)]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-2-Dokumentation.pdf|Cheat sheet für Teil 2 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[https://youtu.be/JVeAUGX60-A Erklärvideo zu Klassen, Objekten, Attritbuten & Methoden (17:08min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br/>[[Medium:VAB-01 Informatik10 KlassenObjekteAttributeMethoden.pdf|Arbeitsblatt zum Video (PDF)]]. <br/>Zu Teilen der Aufgaben gibt es die Lösung im Video, die anderen Aufgaben werden erst im Unterricht besprochen.<br/>&nbsp;<br />
<br />
= Anforderungen Zentralabitur =<br />
Das Zentralabitur fordert die Kenntnis von bestimmten Basis-Sprachelementen, die hier aufgeführt sind.<br />
<br />
Im folgenden werden diese und weitere Basis-Sprachelemente erläutert.<br />
<br />
'''Stand: 2012 (im April 2013 noch aktuell)'''<br />
<br />
* Klassendefinitionen<br />
* Beziehungen zwischen Klassen<br />
** gerichtetete Assoziation<br />
** Vererbung<br />
* Attribute und Methoden (mit Parametern und Rückgabewerten)<br />
* Wertzuweisungen<br />
* Verzweigungen (if, switch)<br />
* Schleifen (while, for, do-while)<br />
<br />
= Klasse, Objekt, Klassendefinition =<br />
''Auf dieser Seite werden Klassen, Objekte etc. Schritt für Schritt erklärt.<br />
<br />
''Den erläuterten kompletten Quellcode einer Java-Klasse findet man hier: [[Klasse in Java]]''<br />
<br />
* Von einer '''Klasse''' können viele '''Objekte''' erzeugt werden.<br />
* Beispiel: Es gibt eine Klasse <code>Baum</code>, von der man viele einzelne Objekte erzeugen kann.<br />
* Java: Definiton einer Klasse:<br />
<code> <br />
'''public class Baum'''<br />
{<br />
// Attribute<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Attribute =<br />
* Attribute beschreiben, welche Eigenschaften bzw. Teil-Objekte die Objekte einer Klasse haben.<br />
* Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den <u>Attribut-Wert</u> haben.<br />
** Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.<br />
* Attribute haben einen <u>Attribut-Typ</u>. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa <code>int</code> für ganze Zahlen oder <code>double</code> für Kommazahlen. Für Namen eignet sich <code>String</code>.<br/>Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Java:<br />
** Attribute werden direkt nach der Klassen-Deklaration notiert.<br />
** Attribute sind in der Regel <code>private</code>, d.h. sie können nicht ohne Weiteres von Außen verändert werden.<br />
<br />
'''Beispiel 1:'''<br />
<br />
Objekte der Klasse <code>Auto</code> können unterschiedlichen Tankstand haben.<br />
<br />
Dafür gibt es das Attribut <code>tankstand</code>. Dieses hat den Datentyp <code>double</code>, weil es eine Kommazahl sein kann.<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
'''private double tankstand;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
'''Beispiel 2:'''<br />
<br />
Objekte der Klasse <code>Baum</code> bestehen aus einem <code>Quadrat</code> (für den Stamm) und einem <code>Kreis</code> (für die Krone). <br/>''Die Klassen <code>Quadrat</code> und <code>Kreis</code> müssen natürlich schon im Projekt enthalten sein!!''<br />
<br />
<code><br />
public class Baum<br />
{<br />
// Attribute<br />
'''private Quadrat stamm;'''<br />
'''private Kreis krone;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Konstruktor =<br />
'''Aufruf des Konstruktors:'''<br />
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:<br />
* Java: <code>Auto neuesAuto = '''new Auto()''';</code><br />
<br />
<br />
'''Deklaration des Konstruktors:'''<br />
* In der Deklaration des Konstruktors wird festgelegt, was passiert, wenn ein Objekt der Klasse erzeugt wird.<br />
* Der Konstruktor heißt genauso wie die Klasse.<br />
* Der Konstruktor hat '''keinen''' Rückgabetyp, also auch kein <code>void</code>.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private int tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto()'''<br />
'''{'''<br />
'''tankstand = 5.0;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch bekommt jedes Auto bei der Erzeugung einen Tankstand von 5.0, d.h. es kann direkt losfahren.<br />
<br />
== Konstruktor mit Parameter ==<br />
Man kann im Konstruktor einen Parameter übergeben, z.B. um direkt bei der Erzeugung die Eigenschaft eines Objektes festzulegen.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto(<u>double pTankstand</u>)'''<br />
'''{'''<br />
'''tankstand = <u>pTankstand</u>;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen.<br />
<br />
'''Aufgerufen''' wird dieser Konstruktor dann z.B. so:<br />
<br />
<code>Auto neuesAuto = '''new Auto(7.0)''';</code><br />
<br />
Damit hat <code>neuesAuto</code> den Tankstand 7.0<br />
<br />
= Methoden =<br />
In Methoden wird festgelegt, was man mit einem Objekt der Klasse machen kann.<br />
<br />
'''Beispiel:'''<br />
Für ein Objekt der Klasse Auto soll es die Methode <code>tanken</code> geben. Außerdem soll man den Tankstand mit der Methode <code>gibTankstand()</code> auslesen können.<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
public Auto()<br />
{<br />
tanstand = 5.0;<br />
}<br />
<br />
// Methoden<br />
'''public void tanken(double pLiter)'''<br />
'''{'''<br />
'''tankstand = tankstand + pLiter;'''<br />
'''}'''<br />
<br />
'''public double gibTankstand()''' <br />
'''{'''<br />
'''return tankstand;'''<br />
'''}'''<br />
}<br />
</code><br />
<br />
== Methodendeklaration / Methodenkopf ==<br />
Methoden werden durch den '''Methodenkopf (auch: die Methodensignatur)''' deklariert.<br />
<br />
D.h. für Objekte der Klasse kann man dann die Methode aufrufen.<br />
<br />
'''Erklärvideo'''<br />
<br />
Hier gibt es ein '''[https://youtu.be/YPVhVxL67xo Erklärvideo zu Methodensignaturen (auf youtube, 11:42min)]'''. <br/>'' (Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.)<br />
<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
private int preisstufe;<br />
<br />
//Konstruktor<br />
public Automat()<br />
{<br />
preisstufe = 0;<br />
eingeworfen = 0;<br />
}<br />
<br />
//Methoden<br />
<br />
'''public void preisstufeWaehlen(int pPreisstufe)'''<br />
{<br />
preisstufe = pPreisstufe;<br />
}<br />
<br />
'''public int gibPreisstufe()'''<br />
{<br />
int ergebnis = preisstufe;<br />
return ergebnis;<br />
}<br />
<br />
'''public void geldEinwerfen(int betragInCent)'''<br />
{<br />
eingeworfen = eingeworfen + betragInCent;<br />
}<br />
<br />
'''private double steuern(int betrag)'''<br />
{<br />
double ergebnis = betrag * 0.19;<br />
return ergebnis;<br />
}<br />
<br />
'''public int geldZurueckGeben()'''<br />
{<br />
int ergebnis = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
Der '''Methodenkopf''' ist immer gleich aufgebaut:<br />
# '''Zugriffsmodifikator''': <code>public</code> oder <code>private</code>.<br />
## Auf <code>public</code>-Methoden darf man auch von außen zugreifen; sie sind '''öffentlich'''.<br />
## Auf <code>private</code>-Methoden darf nur die Klasse selbst zugreifen, d.h. von außen ist diese Methode nicht sichtbar! Das ist z.B. sinnvoll für Hilfsmethoden, die nicht jeder benutzen soll.<br />
# '''Rückgabetyp''': <code>void</code> für ''nichts'' bzw. ein Datentyp (wie z.B. <code>int</code>) oder auch eine Klasse.<br />
## Im Rückgabetyp wird festgelegt, ob und was die Methode zurückgibt. So sollten Methoden, die etwas berechnen, das Ergebnis auch zurückgeben.<br />
## Die Methode <code>public '''void''' geldEinwerfen(int betragInCent)</code> gibt ''nichts'' zurück. <code>'''void'''</code> ist das Schlüsselwort für ''nichts''.<br />
## Die Methode <code>public '''int''' summe(int a, int b) </code> gibt <code>int</code> zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein '''return-Statement''', z.B.: <code>return ergebnis;</code><br />
# '''Methodenname''': Methodennamen sind Verben, denn Methoden bezeichnen Tätigkeiten! Außerdem ist es üblich, Methodennamen '''klein''' zu schreiben.<br />
# '''Parameter''': In der Klammer nach dem Methodenname findet sich der (bzw. die Parameter).<br />
## Bei den Parametern wird erst der '''Parameter-Typ''' (z.B. <code>int</code>) und dann der '''Parameter-Name''' angegeben.<br />
## Mehrere Parameter werden durch Komma getrennt, z.B. <code>public int summe('''int a, int b''')</code><br />
## Methoden ohne Parameter haben leere Klammern, z.B.: <code>public int geldZurueckGeben'''()'''</code><br />
<br />
== Parameter ==<br />
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.<br />
* Das ist hier der Fall bei der Methode <code>geldEinwerfen</code>: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie viel Geld man einwirft.<br />
* Dafür haben Methoden '''Parameter''', in diesem Fall <code>betragInCent</code>.<br />
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von '''Parameter-Typ'''.<br />
** Der Parameter-Typ von <code>betragInCent</code> ist <code>int</code>, also eine ganze Zahl.<br />
** Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den <u>Parameter übergeben</u>. <br />
<code><br />
Automat derAutomat = new Automat();<br />
// jetzt kommt der Methodenaufruf mit Parameterübergabe!<br />
derAutomat.geldEinwerfen('''50''');<br />
</code><br />
* Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur <code>()</code>. Das ist wichtig, um sie von Attribute zu unterscheiden!<br />
<br />
== Rückgabetyp einer Methode ==<br />
Für eine Methode wird immer der Rückgabetyp festgelegt.<br />
* '''<code>void</code>''': Wenn die Methode '''nichts''' zurückgibt (bei einer verändernden Methode).<br />
** Beispiel: <code>public '''void''' geldEinwerfen(int betragInCent)</code><br />
* '''<code>int</code>''': Wenn die Methode eine ganze Zahl (<code>int</code>) zurückgibt.<br />
** Beispiel: <code>public '''int''' geldZurueckGeben()</code><br />
* Statt <code>int</code> kann auch jeder andere Typ oder auch eine Klasse (z.B. <code>Automat</code>) der Rückgabe-Typ einer Methode sein.<br />
** Beispiel: <code>public '''Automat''' gibKopie()</code> : Diese Methode würde eine Kopie des Automaten (also ein Objekt der Klasse <code>Automat</code>) zurückgeben.<br />
<br />
Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
<br />
== sondierende Methode / verändernde Methode ==<br />
* '''sondierende Methode (=get-Methode)''': Dieser Methodentyp ''gibt eine Information über das Objekt zurück''. Diese Methode braucht einen Rückgabetyp (d.h. nicht <code>void</code>) und ein return-Statement.<br />
** Beispiel: <code>public '''int''' gibPreisstufe()</code><br />
* '''verändernde Methode (=set-Methode)''': Dieser Methodentyp ''verändert das Objekt''. Häufig hat dieser Methodentyp einen (oder mehrere) '''Parameter'''. Sie hat zumeist den Rückgabetyp <code>void</code>, denn sie gibt in der Regel nichts zurück.<br />
** Beispiel: <code>public void preisstufeWaehlen('''int pPreisstufe''')</code><br />
<br />
== Methodenaufruf ==<br />
Methoden der gleichen Klasse werden durch ihren Methodennamen aufgerufen.<br />
<br />
'''VORSICHT:'''<br />
Wenn man eine sondierende Methode aufruft, dann muss man sich für das Ergebnis interessieren!<br />
<br />
'''Beispiel:'''<br />
<br />
Im Beispiel ruft die Methode <code>groessteZahl</code> dreimal die Methode <code>gibGroessereZahl</code> auf. Das Ergebnis des Aufrufs wird jeweils in einer lokalen Variable (z.B. <code>groessere12</code> gespeichert, um damit weiter zu rechnen.<br />
<code><br />
public class Rechner{<br />
public int groessteZahl(int z1, int z2, int z3, int z4)<br />
{<br />
int groessere12 = '''gibGroessereZahl(z1, z2);'''<br />
int groessere34 = '''gibGroessereZahl(z3, z4);'''<br />
int ergebnis = '''gibGroessereZahl(groessere12, groessere34);'''<br />
return ergebnis;<br />
}<br />
<br />
'''public int gibGroessereZahl(int a, int b)'''<br />
{<br />
int ergebnis;<br />
if(a > b)<br />
{<br />
return a;<br />
}<br />
else<br />
{<br />
return b;<br />
}<br />
}<br />
}<br />
</code><br />
<br />
===Methoden für Objekte anderer Klassen aufrufen ===<br />
Man kann auf für ein Objekt einer anderen Klasse eine Methode aufrufen; damit wird eine Aufgabe '''delegiert'''.<br />
<br />
'''WICHTIG: Das wesentliche Syntax-Element ist der Punkt!''' <br/>Man gibt erst das Objekt an, dann den Punkt, dann die Methode (ggf. mit Parameter).<br/>Z.B. <code> '''stamm.bewegeZuPosition(110,120)''';</code><br />
<br />
'''Beispiel :'''<br />
<code><br />
public class Baum<br />
{<br />
// Attribute der Klasse Baum<br />
private Kreis krone;<br />
private Quadrat stamm;<br />
<br />
// Konstruktor der Klasse Baum<br />
public Baum()<br />
{<br />
stamm = new Quadrat();<br />
'''stamm.bewegeZuPosition(110,120)''';<br />
'''stamm.sichtbarMachen()''';<br />
krone = new Kreis();<br />
'''krone.bewegeZuPosition(100,100)''';<br />
'''krone.sichtbarMachen()''';<br />
}<br />
}<br />
</code><br />
<br />
'''Erklärung:'''<br />
* <code>stamm</code> ist ein Objekt vom Typ <code>Quadrat</code>; deshalb verfügt <code>stamm</code> über die Methode <code>sichtbarMachen()</code>.<br />
* Im Konstruktor von <code>Baum</code> wird diese Methode mithilfe des Punktes aufgerufen:<br />
** Attributname -> Punkt -> Methodenname.<br />
*<br />
Ein Objekt der Klasse <code>Haus</code> ruft in einem Objekt der Klasse <code>Quadrat</code> die Methode<br />
<br />
=lokale Variable=<br />
* '''Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.'''<br />
* Lokale Variablen kann man (im Gegensatz zu Attributen) <u>nicht</u> in der ganzen Klasse benutzen. <br />
* Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.<br />
** U.a. werden lokale Variablen immer dann eingesetzt, wenn eine Methode ein Ergebnis berechnen und dann zurückgegeben soll.<br />
<br />
'''Beispiel aus der Klasse <code>Automat</code>:'''<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
<br />
// weitere Attribute, Konstruktor und Methoden<br />
<br />
public int geldZurueckGeben()<br />
{<br />
'''int ergebnis''' = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
= Wertzuweisungen =<br />
Attributen und lokalen Variablen können Werte zugewiesen werden.<br />
* Beispiel 1:<br />
** <code>geschwindigkeit = 10;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert 10 zugewiesen.<br />
* Beispiel 2:<br />
** <code>geschwindigkeit = neueGeschwindigkeit;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>neueGeschwindigkeit</code> zugewiesen.<br />
* Beispiel 3:<br />
** <code>geschwindigkeit = geschwindigkeit + 1;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>geschwindigkeit+1</code> zugewiesen,<br />
** d.h. die Geschwindigkeit wird '''um 1 erhöht'''!<br />
* Allgemein:<br />
** '''links vom Gleichzeichen''' steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.<br />
** '''rechts vom Gleichzeichen''' steht der neue Wert.<br />
<br />
<br />
Außerdem gibt es praktische Abkürzungen für Wertzuweisungen, vor allem '''<code>+=</code>''' und '''<code>++</code>'''.<br />
<br />
* Beispiel 4:<br />
** <code>geschwindigkeit '''+=''' 5;</code><br />
** '''<code>+=</code>''' bedeutet: erhöhe um..., d.h. im Beispiel wird Geschwindigkeit wird um 5 erhöht.<br />
* Beispiel 5:<br />
** <code>geschwindigkeit'''++''';</code><br />
** '''<code>++</code>''' bedeutet: erhöhe um eins.<br />
<br />
= Verzweigungen (if-else) =<br />
Beispiel: die folgende Methode überprüft, welche von zwei Zahlen die größere ist.<br />
<br />
Es passiert folgendes: Wenn (<code>if</code>) <code>a</code> größer als <code>b</code> ist, dann wird <code>ergebnis</code> auf <code>a</code> gesetzt, sonst (<code>else</code>) auf <code>b</code>.<br />
<br />
<code><br />
public int bestimmeDieGroessere(int a, int b)<br />
{<br />
int ergebnis;<br />
'''if(a > b)'''<br />
{<br />
ergebnis = a;<br />
}<br />
'''else'''<br />
{<br />
ergebnis = b;<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
'''VORSICHT:'''<br />
Gleichheit überprüft man mit '''doppeltem''' Gleichzeichen:<br />
<code><br />
// Wenn x gleich drei ist, ...<br />
if(x '''==''' 3)<br />
{<br />
...<br />
}<br />
</code><br />
<br />
= Schleifen (while, for, do-while) =<br />
Bei Schleifen kommen die Fähigkeiten der Computer besonders zur Geltung: Schleifen ermöglichen es, dass man Aktionen mehrfach (d.h. auch 1.000 oder 1.000.000 mal) wiederholt.<br />
== for-Schleife ==<br />
Die for-Schleife ist eine '''Zählschleife'''. Sie wird eingesetzt, wenn man zählen kann, wie oft Aktionen wiederholt werden sollen. Dafür gibt es eine '''Zählvariable''', die häufig <code>i</code> heißt, aber jeder andere Name ist auch denkbar.<br />
<br />
'''Beispiel:'''<br />
<br />
Die folgende for-Schleife gibt die Zahlen 0, 3, 6, ...., 999 an die Konsole aus.<br />
<br />
<code><br />
'''for(int i=0; i<=333; i++)'''<br />
{<br />
System.out.println(3*i);<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
<br />
* Die Klammer nach dem <code>for</code> hat drei Teile:<br />
** ''Deklaration und Initialisierung der Zählvariable <code>i</code>:'' i startet bei 0.<br />
** ''Schleifenbedingung:'' Die Schleife wird so lange wiederholt, wie i <= 333 ist.<br />
** ''Veränderung bei jedem Schleifendurchlauf:'' i wird bei jedem Schleifendurchlauf um eins erhöht. (<code>i++</code> bedeutet dasselbe wie <code>i = i+1</code>). D.h. i nimmt nacheinander folgende Werte an: 0, 1, 2, ..., 333.<br />
** Im Schleifenrumpf wird mit <code>System.out.println(i);</code> jeweils das Dreifache von <code>i</code> an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.<br />
<br />
==while-Schleife==<br />
Die while-Schleife ist eine '''bedingte'''Schleife. Sie wird eingesetzt, wenn Aktionen wiederholt werden sollen, solange die '''Schleifenbedingung''', erfüllt ist.<br />
<br />
'''Erklärvideo'''<br><br />
Hier gibt es ein '''[https://www.youtube.com/watch?v=kPovFPak0Hs Erklärvideo zu while-Schleifen (auf youtube, 11:49min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br />
<br />
'''Beispiel:'''<br />
Die folgende while-Schleife beginnt bei <code>zahl = 1</code>. <code>zahl</code> wird dann so lange an die Konsole ausgegeben und verdoppelt, wie <code>zahl</code> kleiner als 1000 ist. D.h. die Ausgabe ist: 1, 2, 4, ..., 256, 512.<br />
<br />
<code><br />
int zahl = 1;<br />
'''while(zahl < 1000)'''<br />
{<br />
System.out.println(zahl);<br />
// zahl verdoppeln<br />
zahl = zahl * 2;<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
* Die Klammer nach dem <code>while</code> enthält die Bedingung: Wiederhole, solange zahl kleiner 1000 ist.<br />
* Im Schleifenrumpf wird dann <code>zahl</code> an die Konsole ausgegeben und dann mit <code>zahl = zahl * 2;</code> verdoppelt.<br />
<br />
= Beziehungen zwischen Klassen =<br />
''Die Implementierung von Beziehungen zwischen Klassen ist auf anderen Seiten erklärt, auf die hier nur verwiesen wird.''<br />
<br />
'''"kennt"-Beziehung:'''<br />
<br />
Wie man kennt-Beziehungen implementiert, kann man hier nachlesen:<br/><br />
[[Klassen-_und_Implementationsdiagramm#Java-Quelltext:|Szenario Roller (Quelltext)]]<br />
<br />
'''Vererbung:'''<br/><br />
[[Vererbung#Implementierung|Szenario Buch - Fachbuch - Hörbuch]]<br />
<br />
=NullPointerException=<br />
Die NullPointerException ist beim Programmieren die häufigste Exception.<br />
<br />
'''Die NullpointerException wird auch im Abitur abgefragt!!!'''<br />
<br />
Eine NullpointerException tritt auf, wenn man auf eine Methode eines Elementes zugreift, das noch gar nicht erzeugt wurde.<br />
<br />
'''Beispiel 1:'''<br/><br />
Beispiel 1 zeigt, wie die NullpointerException beim Programmieren im Unterricht am häufigsten auftritt.<br />
<code><br />
public class SchuelerVerwaltung{<br />
private List<Schueler> schuelerListe;<br />
<br />
public SchuelerVerwaltung(){<br />
Schueler s1 = new Schueler("Gates","Bill"); <br />
<font color='red'>'''schuelerListe'''.append(s1);</font><br />
}<br />
}<br />
</code><br />
'''Erklärung 1:'''<br/><br />
In der roten Zeile kommt es zu einer NullPointerException, weil das Attribut <code>schuelerListe</code> noch gar nicht erzeugt wurde - es ist <code>null</code>.<br />
<br />
Man kann die NullPointerException vermeiden, indem man <u>vor</u> der roten Zeile einfügt:<br />
<code><br />
schuelerListe = new List<>();<br />
</code><br />
'''Beispiel 2: Abituraufgabe'''<br/><br />
Das ist eine (verkürzte) Aufgabenstellung aus dem Abitur:<br />
<br />
''Analysieren und erläutern Sie, an welcher Stelle des Quellcodes ein Laufzeitfehler durch einen Zugriff auf ein nicht existentes Objekt (eine sogenannte NullPointerException)<br />
entstehen kann.''<br />
<code><br />
public Team wasErmittleIch(Team pTeam, int pX) {<br />
List<Team> auswahl = filtereTeams(pTeam, pX);<br />
auswahl.toFirst();<br />
int punkte = <font color='red'>'''pTeam'''.berechnePunkte()</font>;<br />
Team g = auswahl.getContent();<br />
int d = Math.abs(<font color='red'>'''g'''.berechnePunkte()</font> - punkte);<br />
auswahl.next();<br />
...<br />
}<br />
</code><br />
'''Erklärung 2:'''<br/><br />
An den roten Stellen kann es zu einer NullpointerException kommen:<br />
* Wenn <code>pTeam</code> den Wert <code>null</code> hat, kann man für <code>pTeam</code> nicht die Methode <code>berechnePunkte()</code> aufrufen.<br />
* Wenn <code>auswahl</code> eine leere Liste ist: dann hat die lokale Variable <code>g</code> den Wert <code>null</code>, und man kann für <code>g</code> dann nicht die Methode <code>berechnePunkte()</code> aufrufen.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java_Basis-Sprachelemente&diff=3654Java Basis-Sprachelemente2024-01-16T18:15:44Z<p>Akaibel: /* NullPointerException */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik-EF]]<br />
[[Kategorie:Informatik-Q1]]<br />
<br />
=Allgemeines=<br />
Hier werden die grundlegenden Sprachelemente von Java '''im Detail''' erklärt.<br />
<br />
Wer wissen möchte, wie eine '''ganze Klasse''' aussieht:<br />
* [[Klasse]]<br />
==Erklärvideos==<br />
<br />
* '''[https://www.youtube.com/watch?v=dEFJUra_3ZA Java-Crashkurs Teil 1 (28min)] '''<br/>In Teil 1 des Crash-Kurses geht es um Grundlagen der Programmierung einer Klasse, d.h.<br/>Klasse, Attribut, Konstruktor, Methode, Parameter, lokale Variable etc.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner.txt Programmiervorlage für den Taschenrechner]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-Dokumentation.pdf|Cheat sheet für Teil 1 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[[Medium:Taschenrechner-Fehlersuche.pdf|Taschenrechner Fehlersuche zum Ausdrucken (PDF)]]'''<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner-mit-Fehlern.txt Java-Quelltext für die Fehlersuche]'''<br/>Den Quelltext kann man in [https://www.jdoodle.com/online-java-compiler/ jdoodle] packen und dann die Fehlermeldungen durchklicken!<br />
&nbsp;<br />
* '''[https://youtu.be/IimFb4cEhUU Java-Crashkurs Teil 2 (40min)] '''<br/>In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner2.txt Programmiervorlage für den Taschenrechner (mit allem für Teil 2)]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-2-Dokumentation.pdf|Cheat sheet für Teil 2 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[https://youtu.be/JVeAUGX60-A Erklärvideo zu Klassen, Objekten, Attritbuten & Methoden (17:08min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br/>[[Medium:VAB-01 Informatik10 KlassenObjekteAttributeMethoden.pdf|Arbeitsblatt zum Video (PDF)]]. <br/>Zu Teilen der Aufgaben gibt es die Lösung im Video, die anderen Aufgaben werden erst im Unterricht besprochen.<br/>&nbsp;<br />
<br />
= Anforderungen Zentralabitur =<br />
Das Zentralabitur fordert die Kenntnis von bestimmten Basis-Sprachelementen, die hier aufgeführt sind.<br />
<br />
Im folgenden werden diese und weitere Basis-Sprachelemente erläutert.<br />
<br />
'''Stand: 2012 (im April 2013 noch aktuell)'''<br />
<br />
* Klassendefinitionen<br />
* Beziehungen zwischen Klassen<br />
** gerichtetete Assoziation<br />
** Vererbung<br />
* Attribute und Methoden (mit Parametern und Rückgabewerten)<br />
* Wertzuweisungen<br />
* Verzweigungen (if, switch)<br />
* Schleifen (while, for, do-while)<br />
<br />
= Klasse, Objekt, Klassendefinition =<br />
''Auf dieser Seite werden Klassen, Objekte etc. Schritt für Schritt erklärt.<br />
<br />
''Den erläuterten kompletten Quellcode einer Java-Klasse findet man hier: [[Klasse in Java]]''<br />
<br />
* Von einer '''Klasse''' können viele '''Objekte''' erzeugt werden.<br />
* Beispiel: Es gibt eine Klasse <code>Baum</code>, von der man viele einzelne Objekte erzeugen kann.<br />
* Java: Definiton einer Klasse:<br />
<code> <br />
'''public class Baum'''<br />
{<br />
// Attribute<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Attribute =<br />
* Attribute beschreiben, welche Eigenschaften bzw. Teil-Objekte die Objekte einer Klasse haben.<br />
* Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den <u>Attribut-Wert</u> haben.<br />
** Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.<br />
* Attribute haben einen <u>Attribut-Typ</u>. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa <code>int</code> für ganze Zahlen oder <code>double</code> für Kommazahlen. Für Namen eignet sich <code>String</code>.<br/>Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Java:<br />
** Attribute werden direkt nach der Klassen-Deklaration notiert.<br />
** Attribute sind in der Regel <code>private</code>, d.h. sie können nicht ohne Weiteres von Außen verändert werden.<br />
<br />
'''Beispiel 1:'''<br />
<br />
Objekte der Klasse <code>Auto</code> können unterschiedlichen Tankstand haben.<br />
<br />
Dafür gibt es das Attribut <code>tankstand</code>. Dieses hat den Datentyp <code>double</code>, weil es eine Kommazahl sein kann.<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
'''private double tankstand;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
'''Beispiel 2:'''<br />
<br />
Objekte der Klasse <code>Baum</code> bestehen aus einem <code>Quadrat</code> (für den Stamm) und einem <code>Kreis</code> (für die Krone). <br/>''Die Klassen <code>Quadrat</code> und <code>Kreis</code> müssen natürlich schon im Projekt enthalten sein!!''<br />
<br />
<code><br />
public class Baum<br />
{<br />
// Attribute<br />
'''private Quadrat stamm;'''<br />
'''private Kreis krone;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Konstruktor =<br />
'''Aufruf des Konstruktors:'''<br />
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:<br />
* Java: <code>Auto neuesAuto = '''new Auto()''';</code><br />
<br />
<br />
'''Deklaration des Konstruktors:'''<br />
* In der Deklaration des Konstruktors wird festgelegt, was passiert, wenn ein Objekt der Klasse erzeugt wird.<br />
* Der Konstruktor heißt genauso wie die Klasse.<br />
* Der Konstruktor hat '''keinen''' Rückgabetyp, also auch kein <code>void</code>.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private int tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto()'''<br />
'''{'''<br />
'''tankstand = 5.0;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch bekommt jedes Auto bei der Erzeugung einen Tankstand von 5.0, d.h. es kann direkt losfahren.<br />
<br />
== Konstruktor mit Parameter ==<br />
Man kann im Konstruktor einen Parameter übergeben, z.B. um direkt bei der Erzeugung die Eigenschaft eines Objektes festzulegen.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto(<u>double pTankstand</u>)'''<br />
'''{'''<br />
'''tankstand = <u>pTankstand</u>;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen.<br />
<br />
'''Aufgerufen''' wird dieser Konstruktor dann z.B. so:<br />
<br />
<code>Auto neuesAuto = '''new Auto(7.0)''';</code><br />
<br />
Damit hat <code>neuesAuto</code> den Tankstand 7.0<br />
<br />
= Methoden =<br />
In Methoden wird festgelegt, was man mit einem Objekt der Klasse machen kann.<br />
<br />
'''Beispiel:'''<br />
Für ein Objekt der Klasse Auto soll es die Methode <code>tanken</code> geben. Außerdem soll man den Tankstand mit der Methode <code>gibTankstand()</code> auslesen können.<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
public Auto()<br />
{<br />
tanstand = 5.0;<br />
}<br />
<br />
// Methoden<br />
'''public void tanken(double pLiter)'''<br />
'''{'''<br />
'''tankstand = tankstand + pLiter;'''<br />
'''}'''<br />
<br />
'''public double gibTankstand()''' <br />
'''{'''<br />
'''return tankstand;'''<br />
'''}'''<br />
}<br />
</code><br />
<br />
== Methodendeklaration / Methodenkopf ==<br />
Methoden werden durch den '''Methodenkopf (auch: die Methodensignatur)''' deklariert.<br />
<br />
D.h. für Objekte der Klasse kann man dann die Methode aufrufen.<br />
<br />
'''Erklärvideo'''<br />
<br />
Hier gibt es ein '''[https://youtu.be/YPVhVxL67xo Erklärvideo zu Methodensignaturen (auf youtube, 11:42min)]'''. <br/>'' (Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.)<br />
<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
private int preisstufe;<br />
<br />
//Konstruktor<br />
public Automat()<br />
{<br />
preisstufe = 0;<br />
eingeworfen = 0;<br />
}<br />
<br />
//Methoden<br />
<br />
'''public void preisstufeWaehlen(int pPreisstufe)'''<br />
{<br />
preisstufe = pPreisstufe;<br />
}<br />
<br />
'''public int gibPreisstufe()'''<br />
{<br />
int ergebnis = preisstufe;<br />
return ergebnis;<br />
}<br />
<br />
'''public void geldEinwerfen(int betragInCent)'''<br />
{<br />
eingeworfen = eingeworfen + betragInCent;<br />
}<br />
<br />
'''private double steuern(int betrag)'''<br />
{<br />
double ergebnis = betrag * 0.19;<br />
return ergebnis;<br />
}<br />
<br />
'''public int geldZurueckGeben()'''<br />
{<br />
int ergebnis = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
Der '''Methodenkopf''' ist immer gleich aufgebaut:<br />
# '''Zugriffsmodifikator''': <code>public</code> oder <code>private</code>.<br />
## Auf <code>public</code>-Methoden darf man auch von außen zugreifen; sie sind '''öffentlich'''.<br />
## Auf <code>private</code>-Methoden darf nur die Klasse selbst zugreifen, d.h. von außen ist diese Methode nicht sichtbar! Das ist z.B. sinnvoll für Hilfsmethoden, die nicht jeder benutzen soll.<br />
# '''Rückgabetyp''': <code>void</code> für ''nichts'' bzw. ein Datentyp (wie z.B. <code>int</code>) oder auch eine Klasse.<br />
## Im Rückgabetyp wird festgelegt, ob und was die Methode zurückgibt. So sollten Methoden, die etwas berechnen, das Ergebnis auch zurückgeben.<br />
## Die Methode <code>public '''void''' geldEinwerfen(int betragInCent)</code> gibt ''nichts'' zurück. <code>'''void'''</code> ist das Schlüsselwort für ''nichts''.<br />
## Die Methode <code>public '''int''' summe(int a, int b) </code> gibt <code>int</code> zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein '''return-Statement''', z.B.: <code>return ergebnis;</code><br />
# '''Methodenname''': Methodennamen sind Verben, denn Methoden bezeichnen Tätigkeiten! Außerdem ist es üblich, Methodennamen '''klein''' zu schreiben.<br />
# '''Parameter''': In der Klammer nach dem Methodenname findet sich der (bzw. die Parameter).<br />
## Bei den Parametern wird erst der '''Parameter-Typ''' (z.B. <code>int</code>) und dann der '''Parameter-Name''' angegeben.<br />
## Mehrere Parameter werden durch Komma getrennt, z.B. <code>public int summe('''int a, int b''')</code><br />
## Methoden ohne Parameter haben leere Klammern, z.B.: <code>public int geldZurueckGeben'''()'''</code><br />
<br />
== Parameter ==<br />
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.<br />
* Das ist hier der Fall bei der Methode <code>geldEinwerfen</code>: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie viel Geld man einwirft.<br />
* Dafür haben Methoden '''Parameter''', in diesem Fall <code>betragInCent</code>.<br />
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von '''Parameter-Typ'''.<br />
** Der Parameter-Typ von <code>betragInCent</code> ist <code>int</code>, also eine ganze Zahl.<br />
** Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den <u>Parameter übergeben</u>. <br />
<code><br />
Automat derAutomat = new Automat();<br />
// jetzt kommt der Methodenaufruf mit Parameterübergabe!<br />
derAutomat.geldEinwerfen('''50''');<br />
</code><br />
* Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur <code>()</code>. Das ist wichtig, um sie von Attribute zu unterscheiden!<br />
<br />
== Rückgabetyp einer Methode ==<br />
Für eine Methode wird immer der Rückgabetyp festgelegt.<br />
* '''<code>void</code>''': Wenn die Methode '''nichts''' zurückgibt (bei einer verändernden Methode).<br />
** Beispiel: <code>public '''void''' geldEinwerfen(int betragInCent)</code><br />
* '''<code>int</code>''': Wenn die Methode eine ganze Zahl (<code>int</code>) zurückgibt.<br />
** Beispiel: <code>public '''int''' geldZurueckGeben()</code><br />
* Statt <code>int</code> kann auch jeder andere Typ oder auch eine Klasse (z.B. <code>Automat</code>) der Rückgabe-Typ einer Methode sein.<br />
** Beispiel: <code>public '''Automat''' gibKopie()</code> : Diese Methode würde eine Kopie des Automaten (also ein Objekt der Klasse <code>Automat</code>) zurückgeben.<br />
<br />
Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
<br />
== sondierende Methode / verändernde Methode ==<br />
* '''sondierende Methode (=get-Methode)''': Dieser Methodentyp ''gibt eine Information über das Objekt zurück''. Diese Methode braucht einen Rückgabetyp (d.h. nicht <code>void</code>) und ein return-Statement.<br />
** Beispiel: <code>public '''int''' gibPreisstufe()</code><br />
* '''verändernde Methode (=set-Methode)''': Dieser Methodentyp ''verändert das Objekt''. Häufig hat dieser Methodentyp einen (oder mehrere) '''Parameter'''. Sie hat zumeist den Rückgabetyp <code>void</code>, denn sie gibt in der Regel nichts zurück.<br />
** Beispiel: <code>public void preisstufeWaehlen('''int pPreisstufe''')</code><br />
<br />
== Methodenaufruf ==<br />
Methoden der gleichen Klasse werden durch ihren Methodennamen aufgerufen.<br />
<br />
'''VORSICHT:'''<br />
Wenn man eine sondierende Methode aufruft, dann muss man sich für das Ergebnis interessieren!<br />
<br />
'''Beispiel:'''<br />
<br />
Im Beispiel ruft die Methode <code>groessteZahl</code> dreimal die Methode <code>gibGroessereZahl</code> auf. Das Ergebnis des Aufrufs wird jeweils in einer lokalen Variable (z.B. <code>groessere12</code> gespeichert, um damit weiter zu rechnen.<br />
<code><br />
public class Rechner{<br />
public int groessteZahl(int z1, int z2, int z3, int z4)<br />
{<br />
int groessere12 = '''gibGroessereZahl(z1, z2);'''<br />
int groessere34 = '''gibGroessereZahl(z3, z4);'''<br />
int ergebnis = '''gibGroessereZahl(groessere12, groessere34);'''<br />
return ergebnis;<br />
}<br />
<br />
'''public int gibGroessereZahl(int a, int b)'''<br />
{<br />
int ergebnis;<br />
if(a > b)<br />
{<br />
return a;<br />
}<br />
else<br />
{<br />
return b;<br />
}<br />
}<br />
}<br />
</code><br />
<br />
===Methoden für Objekte anderer Klassen aufrufen ===<br />
Man kann auf für ein Objekt einer anderen Klasse eine Methode aufrufen; damit wird eine Aufgabe '''delegiert'''.<br />
<br />
'''WICHTIG: Das wesentliche Syntax-Element ist der Punkt!''' <br/>Man gibt erst das Objekt an, dann den Punkt, dann die Methode (ggf. mit Parameter).<br/>Z.B. <code> '''stamm.bewegeZuPosition(110,120)''';</code><br />
<br />
'''Beispiel :'''<br />
<code><br />
public class Baum<br />
{<br />
// Attribute der Klasse Baum<br />
private Kreis krone;<br />
private Quadrat stamm;<br />
<br />
// Konstruktor der Klasse Baum<br />
public Baum()<br />
{<br />
stamm = new Quadrat();<br />
'''stamm.bewegeZuPosition(110,120)''';<br />
'''stamm.sichtbarMachen()''';<br />
krone = new Kreis();<br />
'''krone.bewegeZuPosition(100,100)''';<br />
'''krone.sichtbarMachen()''';<br />
}<br />
}<br />
</code><br />
<br />
'''Erklärung:'''<br />
* <code>stamm</code> ist ein Objekt vom Typ <code>Quadrat</code>; deshalb verfügt <code>stamm</code> über die Methode <code>sichtbarMachen()</code>.<br />
* Im Konstruktor von <code>Baum</code> wird diese Methode mithilfe des Punktes aufgerufen:<br />
** Attributname -> Punkt -> Methodenname.<br />
*<br />
Ein Objekt der Klasse <code>Haus</code> ruft in einem Objekt der Klasse <code>Quadrat</code> die Methode<br />
<br />
=lokale Variable=<br />
* '''Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.'''<br />
* Lokale Variablen kann man (im Gegensatz zu Attributen) <u>nicht</u> in der ganzen Klasse benutzen. <br />
* Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.<br />
** U.a. werden lokale Variablen immer dann eingesetzt, wenn eine Methode ein Ergebnis berechnen und dann zurückgegeben soll.<br />
<br />
'''Beispiel aus der Klasse <code>Automat</code>:'''<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
<br />
// weitere Attribute, Konstruktor und Methoden<br />
<br />
public int geldZurueckGeben()<br />
{<br />
'''int ergebnis''' = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
= Wertzuweisungen =<br />
Attributen und lokalen Variablen können Werte zugewiesen werden.<br />
* Beispiel 1:<br />
** <code>geschwindigkeit = 10;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert 10 zugewiesen.<br />
* Beispiel 2:<br />
** <code>geschwindigkeit = neueGeschwindigkeit;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>neueGeschwindigkeit</code> zugewiesen.<br />
* Beispiel 3:<br />
** <code>geschwindigkeit = geschwindigkeit + 1;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>geschwindigkeit+1</code> zugewiesen,<br />
** d.h. die Geschwindigkeit wird '''um 1 erhöht'''!<br />
* Allgemein:<br />
** '''links vom Gleichzeichen''' steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.<br />
** '''rechts vom Gleichzeichen''' steht der neue Wert.<br />
<br />
<br />
Außerdem gibt es praktische Abkürzungen für Wertzuweisungen, vor allem '''<code>+=</code>''' und '''<code>++</code>'''.<br />
<br />
* Beispiel 4:<br />
** <code>geschwindigkeit '''+=''' 5;</code><br />
** '''<code>+=</code>''' bedeutet: erhöhe um..., d.h. im Beispiel wird Geschwindigkeit wird um 5 erhöht.<br />
* Beispiel 5:<br />
** <code>geschwindigkeit'''++''';</code><br />
** '''<code>++</code>''' bedeutet: erhöhe um eins.<br />
<br />
= Verzweigungen (if-else) =<br />
Beispiel: die folgende Methode überprüft, welche von zwei Zahlen die größere ist.<br />
<br />
Es passiert folgendes: Wenn (<code>if</code>) <code>a</code> größer als <code>b</code> ist, dann wird <code>ergebnis</code> auf <code>a</code> gesetzt, sonst (<code>else</code>) auf <code>b</code>.<br />
<br />
<code><br />
public int bestimmeDieGroessere(int a, int b)<br />
{<br />
int ergebnis;<br />
'''if(a > b)'''<br />
{<br />
ergebnis = a;<br />
}<br />
'''else'''<br />
{<br />
ergebnis = b;<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
'''VORSICHT:'''<br />
Gleichheit überprüft man mit '''doppeltem''' Gleichzeichen:<br />
<code><br />
// Wenn x gleich drei ist, ...<br />
if(x '''==''' 3)<br />
{<br />
...<br />
}<br />
</code><br />
<br />
= Schleifen (while, for, do-while) =<br />
Bei Schleifen kommen die Fähigkeiten der Computer besonders zur Geltung: Schleifen ermöglichen es, dass man Aktionen mehrfach (d.h. auch 1.000 oder 1.000.000 mal) wiederholt.<br />
== for-Schleife ==<br />
Die for-Schleife ist eine '''Zählschleife'''. Sie wird eingesetzt, wenn man zählen kann, wie oft Aktionen wiederholt werden sollen. Dafür gibt es eine '''Zählvariable''', die häufig <code>i</code> heißt, aber jeder andere Name ist auch denkbar.<br />
<br />
'''Beispiel:'''<br />
<br />
Die folgende for-Schleife gibt die Zahlen 0, 3, 6, ...., 999 an die Konsole aus.<br />
<br />
<code><br />
'''for(int i=0; i<=333; i++)'''<br />
{<br />
System.out.println(3*i);<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
<br />
* Die Klammer nach dem <code>for</code> hat drei Teile:<br />
** ''Deklaration und Initialisierung der Zählvariable <code>i</code>:'' i startet bei 0.<br />
** ''Schleifenbedingung:'' Die Schleife wird so lange wiederholt, wie i <= 333 ist.<br />
** ''Veränderung bei jedem Schleifendurchlauf:'' i wird bei jedem Schleifendurchlauf um eins erhöht. (<code>i++</code> bedeutet dasselbe wie <code>i = i+1</code>). D.h. i nimmt nacheinander folgende Werte an: 0, 1, 2, ..., 333.<br />
** Im Schleifenrumpf wird mit <code>System.out.println(i);</code> jeweils das Dreifache von <code>i</code> an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.<br />
<br />
==while-Schleife==<br />
Die while-Schleife ist eine '''bedingte'''Schleife. Sie wird eingesetzt, wenn Aktionen wiederholt werden sollen, solange die '''Schleifenbedingung''', erfüllt ist.<br />
<br />
'''Erklärvideo'''<br><br />
Hier gibt es ein '''[https://www.youtube.com/watch?v=kPovFPak0Hs Erklärvideo zu while-Schleifen (auf youtube, 11:49min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br />
<br />
'''Beispiel:'''<br />
Die folgende while-Schleife beginnt bei <code>zahl = 1</code>. <code>zahl</code> wird dann so lange an die Konsole ausgegeben und verdoppelt, wie <code>zahl</code> kleiner als 1000 ist. D.h. die Ausgabe ist: 1, 2, 4, ..., 256, 512.<br />
<br />
<code><br />
int zahl = 1;<br />
'''while(zahl < 1000)'''<br />
{<br />
System.out.println(zahl);<br />
// zahl verdoppeln<br />
zahl = zahl * 2;<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
* Die Klammer nach dem <code>while</code> enthält die Bedingung: Wiederhole, solange zahl kleiner 1000 ist.<br />
* Im Schleifenrumpf wird dann <code>zahl</code> an die Konsole ausgegeben und dann mit <code>zahl = zahl * 2;</code> verdoppelt.<br />
<br />
= Beziehungen zwischen Klassen =<br />
''Die Implementierung von Beziehungen zwischen Klassen ist auf anderen Seiten erklärt, auf die hier nur verwiesen wird.''<br />
<br />
'''"kennt"-Beziehung:'''<br />
<br />
Wie man kennt-Beziehungen implementiert, kann man hier nachlesen:<br/><br />
[[Klassen-_und_Implementationsdiagramm#Java-Quelltext:|Szenario Roller (Quelltext)]]<br />
<br />
'''Vererbung:'''<br/><br />
[[Vererbung#Implementierung|Szenario Buch - Fachbuch - Hörbuch]]<br />
<br />
=NullPointerException=<br />
Die NullPointerException ist beim Programmieren die häufigste Exception.<br />
<br />
'''Die NullpointerException wird auch im Abitur abgefragt!!!'''<br />
<br />
Eine NullpointerException tritt auf, wenn man auf eine Methode eines Elementes zugreift, das noch gar nicht erzeugt wurde.<br />
<br />
'''Beispiel 1:'''<br/><br />
Beispiel 1 zeigt, wie die NullpointerException beim Programmieren im Unterricht am häufigsten auftritt.<br />
<code><br />
public class SchuelerVerwaltung{<br />
private List<Schueler> schuelerListe;<br />
<br />
public SchuelerVerwaltung(){<br />
Schueler s1 = new Schueler("Gates","Bill"); <br />
<font color='red'>'''schuelerListe'''.append(s1);</font><br />
}<br />
}<br />
</code><br />
'''Erklärung 1:'''<br/><br />
In der roten Zeile kommt es zu einer NullPointerException, weil das Attribut <code>schuelerListe</code> noch gar nicht erzeugt wurde - es ist <code>null</code>.<br />
<br />
Man kann die NullPointerException vermeiden, indem man <u>vor</u> der roten Zeile einfügt:<br />
<code><br />
schuelerListe = new List<>();<br />
</code><br />
<br />
'''Beispiel 2: Abituraufgabe'''<br/><br />
Das ist eine (verkürzte) Aufgabenstellung aus dem Abitur:<br />
<br />
''Analysieren und erläutern Sie, an welcher Stelle des Quellcodes ein Laufzeitfehler durch<br />
einen Zugriff auf ein nicht existentes Objekt (eine sogenannte NullPointerException)<br />
entstehen kann.''<br />
<br />
<code><br />
public Team wasErmittleIch(Team pTeam, int pX) {<br />
List<Team> auswahl = filtereTeams(pTeam, pX);<br />
auswahl.toFirst();<br />
int punkte = <font color='red'>'''pTeam'''</font>.berechnePunkte();<br />
Team g = auswahl.getContent();<br />
int d = Math.abs(<font color='red'>'''g'''</font>.berechnePunkte() - punkte);<br />
auswahl.next();<br />
...<br />
}<br />
</code><br />
<br />
'''Erklärung 2:'''<br/><br />
An den roten Stellen kann es zu einer NullpointerException kommen:<br />
* Wenn <code>pTeam</code> den Wert <code>null</code> hat, kann man für <code>pTeam</code> nicht die Methode <code>berechnePunkte()</code> aufrufen.<br />
* <code>auswahl</code> eine leere Liste ist: dann hat die lokale Variable <code>g</code> den Wert <code>null</code>, und man kann für <code>g</code> dann nicht die Methode <code>berechnePunkte()</code> aufrufen.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java_Basis-Sprachelemente&diff=3653Java Basis-Sprachelemente2024-01-16T18:00:39Z<p>Akaibel: /* Beziehungen zwischen Klassen */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik-EF]]<br />
[[Kategorie:Informatik-Q1]]<br />
<br />
=Allgemeines=<br />
Hier werden die grundlegenden Sprachelemente von Java '''im Detail''' erklärt.<br />
<br />
Wer wissen möchte, wie eine '''ganze Klasse''' aussieht:<br />
* [[Klasse]]<br />
==Erklärvideos==<br />
<br />
* '''[https://www.youtube.com/watch?v=dEFJUra_3ZA Java-Crashkurs Teil 1 (28min)] '''<br/>In Teil 1 des Crash-Kurses geht es um Grundlagen der Programmierung einer Klasse, d.h.<br/>Klasse, Attribut, Konstruktor, Methode, Parameter, lokale Variable etc.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner.txt Programmiervorlage für den Taschenrechner]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-Dokumentation.pdf|Cheat sheet für Teil 1 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[[Medium:Taschenrechner-Fehlersuche.pdf|Taschenrechner Fehlersuche zum Ausdrucken (PDF)]]'''<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner-mit-Fehlern.txt Java-Quelltext für die Fehlersuche]'''<br/>Den Quelltext kann man in [https://www.jdoodle.com/online-java-compiler/ jdoodle] packen und dann die Fehlermeldungen durchklicken!<br />
&nbsp;<br />
* '''[https://youtu.be/IimFb4cEhUU Java-Crashkurs Teil 2 (40min)] '''<br/>In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner2.txt Programmiervorlage für den Taschenrechner (mit allem für Teil 2)]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-2-Dokumentation.pdf|Cheat sheet für Teil 2 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[https://youtu.be/JVeAUGX60-A Erklärvideo zu Klassen, Objekten, Attritbuten & Methoden (17:08min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br/>[[Medium:VAB-01 Informatik10 KlassenObjekteAttributeMethoden.pdf|Arbeitsblatt zum Video (PDF)]]. <br/>Zu Teilen der Aufgaben gibt es die Lösung im Video, die anderen Aufgaben werden erst im Unterricht besprochen.<br/>&nbsp;<br />
<br />
= Anforderungen Zentralabitur =<br />
Das Zentralabitur fordert die Kenntnis von bestimmten Basis-Sprachelementen, die hier aufgeführt sind.<br />
<br />
Im folgenden werden diese und weitere Basis-Sprachelemente erläutert.<br />
<br />
'''Stand: 2012 (im April 2013 noch aktuell)'''<br />
<br />
* Klassendefinitionen<br />
* Beziehungen zwischen Klassen<br />
** gerichtetete Assoziation<br />
** Vererbung<br />
* Attribute und Methoden (mit Parametern und Rückgabewerten)<br />
* Wertzuweisungen<br />
* Verzweigungen (if, switch)<br />
* Schleifen (while, for, do-while)<br />
<br />
= Klasse, Objekt, Klassendefinition =<br />
''Auf dieser Seite werden Klassen, Objekte etc. Schritt für Schritt erklärt.<br />
<br />
''Den erläuterten kompletten Quellcode einer Java-Klasse findet man hier: [[Klasse in Java]]''<br />
<br />
* Von einer '''Klasse''' können viele '''Objekte''' erzeugt werden.<br />
* Beispiel: Es gibt eine Klasse <code>Baum</code>, von der man viele einzelne Objekte erzeugen kann.<br />
* Java: Definiton einer Klasse:<br />
<code> <br />
'''public class Baum'''<br />
{<br />
// Attribute<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Attribute =<br />
* Attribute beschreiben, welche Eigenschaften bzw. Teil-Objekte die Objekte einer Klasse haben.<br />
* Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den <u>Attribut-Wert</u> haben.<br />
** Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.<br />
* Attribute haben einen <u>Attribut-Typ</u>. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa <code>int</code> für ganze Zahlen oder <code>double</code> für Kommazahlen. Für Namen eignet sich <code>String</code>.<br/>Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Java:<br />
** Attribute werden direkt nach der Klassen-Deklaration notiert.<br />
** Attribute sind in der Regel <code>private</code>, d.h. sie können nicht ohne Weiteres von Außen verändert werden.<br />
<br />
'''Beispiel 1:'''<br />
<br />
Objekte der Klasse <code>Auto</code> können unterschiedlichen Tankstand haben.<br />
<br />
Dafür gibt es das Attribut <code>tankstand</code>. Dieses hat den Datentyp <code>double</code>, weil es eine Kommazahl sein kann.<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
'''private double tankstand;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
'''Beispiel 2:'''<br />
<br />
Objekte der Klasse <code>Baum</code> bestehen aus einem <code>Quadrat</code> (für den Stamm) und einem <code>Kreis</code> (für die Krone). <br/>''Die Klassen <code>Quadrat</code> und <code>Kreis</code> müssen natürlich schon im Projekt enthalten sein!!''<br />
<br />
<code><br />
public class Baum<br />
{<br />
// Attribute<br />
'''private Quadrat stamm;'''<br />
'''private Kreis krone;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Konstruktor =<br />
'''Aufruf des Konstruktors:'''<br />
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:<br />
* Java: <code>Auto neuesAuto = '''new Auto()''';</code><br />
<br />
<br />
'''Deklaration des Konstruktors:'''<br />
* In der Deklaration des Konstruktors wird festgelegt, was passiert, wenn ein Objekt der Klasse erzeugt wird.<br />
* Der Konstruktor heißt genauso wie die Klasse.<br />
* Der Konstruktor hat '''keinen''' Rückgabetyp, also auch kein <code>void</code>.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private int tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto()'''<br />
'''{'''<br />
'''tankstand = 5.0;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch bekommt jedes Auto bei der Erzeugung einen Tankstand von 5.0, d.h. es kann direkt losfahren.<br />
<br />
== Konstruktor mit Parameter ==<br />
Man kann im Konstruktor einen Parameter übergeben, z.B. um direkt bei der Erzeugung die Eigenschaft eines Objektes festzulegen.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto(<u>double pTankstand</u>)'''<br />
'''{'''<br />
'''tankstand = <u>pTankstand</u>;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen.<br />
<br />
'''Aufgerufen''' wird dieser Konstruktor dann z.B. so:<br />
<br />
<code>Auto neuesAuto = '''new Auto(7.0)''';</code><br />
<br />
Damit hat <code>neuesAuto</code> den Tankstand 7.0<br />
<br />
= Methoden =<br />
In Methoden wird festgelegt, was man mit einem Objekt der Klasse machen kann.<br />
<br />
'''Beispiel:'''<br />
Für ein Objekt der Klasse Auto soll es die Methode <code>tanken</code> geben. Außerdem soll man den Tankstand mit der Methode <code>gibTankstand()</code> auslesen können.<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
public Auto()<br />
{<br />
tanstand = 5.0;<br />
}<br />
<br />
// Methoden<br />
'''public void tanken(double pLiter)'''<br />
'''{'''<br />
'''tankstand = tankstand + pLiter;'''<br />
'''}'''<br />
<br />
'''public double gibTankstand()''' <br />
'''{'''<br />
'''return tankstand;'''<br />
'''}'''<br />
}<br />
</code><br />
<br />
== Methodendeklaration / Methodenkopf ==<br />
Methoden werden durch den '''Methodenkopf (auch: die Methodensignatur)''' deklariert.<br />
<br />
D.h. für Objekte der Klasse kann man dann die Methode aufrufen.<br />
<br />
'''Erklärvideo'''<br />
<br />
Hier gibt es ein '''[https://youtu.be/YPVhVxL67xo Erklärvideo zu Methodensignaturen (auf youtube, 11:42min)]'''. <br/>'' (Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.)<br />
<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
private int preisstufe;<br />
<br />
//Konstruktor<br />
public Automat()<br />
{<br />
preisstufe = 0;<br />
eingeworfen = 0;<br />
}<br />
<br />
//Methoden<br />
<br />
'''public void preisstufeWaehlen(int pPreisstufe)'''<br />
{<br />
preisstufe = pPreisstufe;<br />
}<br />
<br />
'''public int gibPreisstufe()'''<br />
{<br />
int ergebnis = preisstufe;<br />
return ergebnis;<br />
}<br />
<br />
'''public void geldEinwerfen(int betragInCent)'''<br />
{<br />
eingeworfen = eingeworfen + betragInCent;<br />
}<br />
<br />
'''private double steuern(int betrag)'''<br />
{<br />
double ergebnis = betrag * 0.19;<br />
return ergebnis;<br />
}<br />
<br />
'''public int geldZurueckGeben()'''<br />
{<br />
int ergebnis = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
Der '''Methodenkopf''' ist immer gleich aufgebaut:<br />
# '''Zugriffsmodifikator''': <code>public</code> oder <code>private</code>.<br />
## Auf <code>public</code>-Methoden darf man auch von außen zugreifen; sie sind '''öffentlich'''.<br />
## Auf <code>private</code>-Methoden darf nur die Klasse selbst zugreifen, d.h. von außen ist diese Methode nicht sichtbar! Das ist z.B. sinnvoll für Hilfsmethoden, die nicht jeder benutzen soll.<br />
# '''Rückgabetyp''': <code>void</code> für ''nichts'' bzw. ein Datentyp (wie z.B. <code>int</code>) oder auch eine Klasse.<br />
## Im Rückgabetyp wird festgelegt, ob und was die Methode zurückgibt. So sollten Methoden, die etwas berechnen, das Ergebnis auch zurückgeben.<br />
## Die Methode <code>public '''void''' geldEinwerfen(int betragInCent)</code> gibt ''nichts'' zurück. <code>'''void'''</code> ist das Schlüsselwort für ''nichts''.<br />
## Die Methode <code>public '''int''' summe(int a, int b) </code> gibt <code>int</code> zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein '''return-Statement''', z.B.: <code>return ergebnis;</code><br />
# '''Methodenname''': Methodennamen sind Verben, denn Methoden bezeichnen Tätigkeiten! Außerdem ist es üblich, Methodennamen '''klein''' zu schreiben.<br />
# '''Parameter''': In der Klammer nach dem Methodenname findet sich der (bzw. die Parameter).<br />
## Bei den Parametern wird erst der '''Parameter-Typ''' (z.B. <code>int</code>) und dann der '''Parameter-Name''' angegeben.<br />
## Mehrere Parameter werden durch Komma getrennt, z.B. <code>public int summe('''int a, int b''')</code><br />
## Methoden ohne Parameter haben leere Klammern, z.B.: <code>public int geldZurueckGeben'''()'''</code><br />
<br />
== Parameter ==<br />
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.<br />
* Das ist hier der Fall bei der Methode <code>geldEinwerfen</code>: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie viel Geld man einwirft.<br />
* Dafür haben Methoden '''Parameter''', in diesem Fall <code>betragInCent</code>.<br />
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von '''Parameter-Typ'''.<br />
** Der Parameter-Typ von <code>betragInCent</code> ist <code>int</code>, also eine ganze Zahl.<br />
** Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den <u>Parameter übergeben</u>. <br />
<code><br />
Automat derAutomat = new Automat();<br />
// jetzt kommt der Methodenaufruf mit Parameterübergabe!<br />
derAutomat.geldEinwerfen('''50''');<br />
</code><br />
* Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur <code>()</code>. Das ist wichtig, um sie von Attribute zu unterscheiden!<br />
<br />
== Rückgabetyp einer Methode ==<br />
Für eine Methode wird immer der Rückgabetyp festgelegt.<br />
* '''<code>void</code>''': Wenn die Methode '''nichts''' zurückgibt (bei einer verändernden Methode).<br />
** Beispiel: <code>public '''void''' geldEinwerfen(int betragInCent)</code><br />
* '''<code>int</code>''': Wenn die Methode eine ganze Zahl (<code>int</code>) zurückgibt.<br />
** Beispiel: <code>public '''int''' geldZurueckGeben()</code><br />
* Statt <code>int</code> kann auch jeder andere Typ oder auch eine Klasse (z.B. <code>Automat</code>) der Rückgabe-Typ einer Methode sein.<br />
** Beispiel: <code>public '''Automat''' gibKopie()</code> : Diese Methode würde eine Kopie des Automaten (also ein Objekt der Klasse <code>Automat</code>) zurückgeben.<br />
<br />
Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
<br />
== sondierende Methode / verändernde Methode ==<br />
* '''sondierende Methode (=get-Methode)''': Dieser Methodentyp ''gibt eine Information über das Objekt zurück''. Diese Methode braucht einen Rückgabetyp (d.h. nicht <code>void</code>) und ein return-Statement.<br />
** Beispiel: <code>public '''int''' gibPreisstufe()</code><br />
* '''verändernde Methode (=set-Methode)''': Dieser Methodentyp ''verändert das Objekt''. Häufig hat dieser Methodentyp einen (oder mehrere) '''Parameter'''. Sie hat zumeist den Rückgabetyp <code>void</code>, denn sie gibt in der Regel nichts zurück.<br />
** Beispiel: <code>public void preisstufeWaehlen('''int pPreisstufe''')</code><br />
<br />
== Methodenaufruf ==<br />
Methoden der gleichen Klasse werden durch ihren Methodennamen aufgerufen.<br />
<br />
'''VORSICHT:'''<br />
Wenn man eine sondierende Methode aufruft, dann muss man sich für das Ergebnis interessieren!<br />
<br />
'''Beispiel:'''<br />
<br />
Im Beispiel ruft die Methode <code>groessteZahl</code> dreimal die Methode <code>gibGroessereZahl</code> auf. Das Ergebnis des Aufrufs wird jeweils in einer lokalen Variable (z.B. <code>groessere12</code> gespeichert, um damit weiter zu rechnen.<br />
<code><br />
public class Rechner{<br />
public int groessteZahl(int z1, int z2, int z3, int z4)<br />
{<br />
int groessere12 = '''gibGroessereZahl(z1, z2);'''<br />
int groessere34 = '''gibGroessereZahl(z3, z4);'''<br />
int ergebnis = '''gibGroessereZahl(groessere12, groessere34);'''<br />
return ergebnis;<br />
}<br />
<br />
'''public int gibGroessereZahl(int a, int b)'''<br />
{<br />
int ergebnis;<br />
if(a > b)<br />
{<br />
return a;<br />
}<br />
else<br />
{<br />
return b;<br />
}<br />
}<br />
}<br />
</code><br />
<br />
===Methoden für Objekte anderer Klassen aufrufen ===<br />
Man kann auf für ein Objekt einer anderen Klasse eine Methode aufrufen; damit wird eine Aufgabe '''delegiert'''.<br />
<br />
'''WICHTIG: Das wesentliche Syntax-Element ist der Punkt!''' <br/>Man gibt erst das Objekt an, dann den Punkt, dann die Methode (ggf. mit Parameter).<br/>Z.B. <code> '''stamm.bewegeZuPosition(110,120)''';</code><br />
<br />
'''Beispiel :'''<br />
<code><br />
public class Baum<br />
{<br />
// Attribute der Klasse Baum<br />
private Kreis krone;<br />
private Quadrat stamm;<br />
<br />
// Konstruktor der Klasse Baum<br />
public Baum()<br />
{<br />
stamm = new Quadrat();<br />
'''stamm.bewegeZuPosition(110,120)''';<br />
'''stamm.sichtbarMachen()''';<br />
krone = new Kreis();<br />
'''krone.bewegeZuPosition(100,100)''';<br />
'''krone.sichtbarMachen()''';<br />
}<br />
}<br />
</code><br />
<br />
'''Erklärung:'''<br />
* <code>stamm</code> ist ein Objekt vom Typ <code>Quadrat</code>; deshalb verfügt <code>stamm</code> über die Methode <code>sichtbarMachen()</code>.<br />
* Im Konstruktor von <code>Baum</code> wird diese Methode mithilfe des Punktes aufgerufen:<br />
** Attributname -> Punkt -> Methodenname.<br />
*<br />
Ein Objekt der Klasse <code>Haus</code> ruft in einem Objekt der Klasse <code>Quadrat</code> die Methode<br />
<br />
=lokale Variable=<br />
* '''Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.'''<br />
* Lokale Variablen kann man (im Gegensatz zu Attributen) <u>nicht</u> in der ganzen Klasse benutzen. <br />
* Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.<br />
** U.a. werden lokale Variablen immer dann eingesetzt, wenn eine Methode ein Ergebnis berechnen und dann zurückgegeben soll.<br />
<br />
'''Beispiel aus der Klasse <code>Automat</code>:'''<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
<br />
// weitere Attribute, Konstruktor und Methoden<br />
<br />
public int geldZurueckGeben()<br />
{<br />
'''int ergebnis''' = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
= Wertzuweisungen =<br />
Attributen und lokalen Variablen können Werte zugewiesen werden.<br />
* Beispiel 1:<br />
** <code>geschwindigkeit = 10;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert 10 zugewiesen.<br />
* Beispiel 2:<br />
** <code>geschwindigkeit = neueGeschwindigkeit;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>neueGeschwindigkeit</code> zugewiesen.<br />
* Beispiel 3:<br />
** <code>geschwindigkeit = geschwindigkeit + 1;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>geschwindigkeit+1</code> zugewiesen,<br />
** d.h. die Geschwindigkeit wird '''um 1 erhöht'''!<br />
* Allgemein:<br />
** '''links vom Gleichzeichen''' steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.<br />
** '''rechts vom Gleichzeichen''' steht der neue Wert.<br />
<br />
<br />
Außerdem gibt es praktische Abkürzungen für Wertzuweisungen, vor allem '''<code>+=</code>''' und '''<code>++</code>'''.<br />
<br />
* Beispiel 4:<br />
** <code>geschwindigkeit '''+=''' 5;</code><br />
** '''<code>+=</code>''' bedeutet: erhöhe um..., d.h. im Beispiel wird Geschwindigkeit wird um 5 erhöht.<br />
* Beispiel 5:<br />
** <code>geschwindigkeit'''++''';</code><br />
** '''<code>++</code>''' bedeutet: erhöhe um eins.<br />
<br />
= Verzweigungen (if-else) =<br />
Beispiel: die folgende Methode überprüft, welche von zwei Zahlen die größere ist.<br />
<br />
Es passiert folgendes: Wenn (<code>if</code>) <code>a</code> größer als <code>b</code> ist, dann wird <code>ergebnis</code> auf <code>a</code> gesetzt, sonst (<code>else</code>) auf <code>b</code>.<br />
<br />
<code><br />
public int bestimmeDieGroessere(int a, int b)<br />
{<br />
int ergebnis;<br />
'''if(a > b)'''<br />
{<br />
ergebnis = a;<br />
}<br />
'''else'''<br />
{<br />
ergebnis = b;<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
'''VORSICHT:'''<br />
Gleichheit überprüft man mit '''doppeltem''' Gleichzeichen:<br />
<code><br />
// Wenn x gleich drei ist, ...<br />
if(x '''==''' 3)<br />
{<br />
...<br />
}<br />
</code><br />
<br />
= Schleifen (while, for, do-while) =<br />
Bei Schleifen kommen die Fähigkeiten der Computer besonders zur Geltung: Schleifen ermöglichen es, dass man Aktionen mehrfach (d.h. auch 1.000 oder 1.000.000 mal) wiederholt.<br />
== for-Schleife ==<br />
Die for-Schleife ist eine '''Zählschleife'''. Sie wird eingesetzt, wenn man zählen kann, wie oft Aktionen wiederholt werden sollen. Dafür gibt es eine '''Zählvariable''', die häufig <code>i</code> heißt, aber jeder andere Name ist auch denkbar.<br />
<br />
'''Beispiel:'''<br />
<br />
Die folgende for-Schleife gibt die Zahlen 0, 3, 6, ...., 999 an die Konsole aus.<br />
<br />
<code><br />
'''for(int i=0; i<=333; i++)'''<br />
{<br />
System.out.println(3*i);<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
<br />
* Die Klammer nach dem <code>for</code> hat drei Teile:<br />
** ''Deklaration und Initialisierung der Zählvariable <code>i</code>:'' i startet bei 0.<br />
** ''Schleifenbedingung:'' Die Schleife wird so lange wiederholt, wie i <= 333 ist.<br />
** ''Veränderung bei jedem Schleifendurchlauf:'' i wird bei jedem Schleifendurchlauf um eins erhöht. (<code>i++</code> bedeutet dasselbe wie <code>i = i+1</code>). D.h. i nimmt nacheinander folgende Werte an: 0, 1, 2, ..., 333.<br />
** Im Schleifenrumpf wird mit <code>System.out.println(i);</code> jeweils das Dreifache von <code>i</code> an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.<br />
<br />
==while-Schleife==<br />
Die while-Schleife ist eine '''bedingte'''Schleife. Sie wird eingesetzt, wenn Aktionen wiederholt werden sollen, solange die '''Schleifenbedingung''', erfüllt ist.<br />
<br />
'''Erklärvideo'''<br><br />
Hier gibt es ein '''[https://www.youtube.com/watch?v=kPovFPak0Hs Erklärvideo zu while-Schleifen (auf youtube, 11:49min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br />
<br />
'''Beispiel:'''<br />
Die folgende while-Schleife beginnt bei <code>zahl = 1</code>. <code>zahl</code> wird dann so lange an die Konsole ausgegeben und verdoppelt, wie <code>zahl</code> kleiner als 1000 ist. D.h. die Ausgabe ist: 1, 2, 4, ..., 256, 512.<br />
<br />
<code><br />
int zahl = 1;<br />
'''while(zahl < 1000)'''<br />
{<br />
System.out.println(zahl);<br />
// zahl verdoppeln<br />
zahl = zahl * 2;<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
* Die Klammer nach dem <code>while</code> enthält die Bedingung: Wiederhole, solange zahl kleiner 1000 ist.<br />
* Im Schleifenrumpf wird dann <code>zahl</code> an die Konsole ausgegeben und dann mit <code>zahl = zahl * 2;</code> verdoppelt.<br />
<br />
= Beziehungen zwischen Klassen =<br />
''Die Implementierung von Beziehungen zwischen Klassen ist auf anderen Seiten erklärt, auf die hier nur verwiesen wird.''<br />
<br />
'''"kennt"-Beziehung:'''<br />
<br />
Wie man kennt-Beziehungen implementiert, kann man hier nachlesen:<br/><br />
[[Klassen-_und_Implementationsdiagramm#Java-Quelltext:|Szenario Roller (Quelltext)]]<br />
<br />
'''Vererbung:'''<br/><br />
[[Vererbung#Implementierung|Szenario Buch - Fachbuch - Hörbuch]]<br />
<br />
=NullPointerException=<br />
Die NullPointerException ist beim Programmieren die häufigste Exception.<br />
<br />
'''Die NullpointerException wird auch im Abitur abgefragt!!!'''<br />
<br />
Eine NullpointerException tritt auf, wenn man auf eine Methode eines Elementes zugreift, das noch gar nicht erzeugt wurde.<br />
<br />
'''Beispiel 1:'''<br/><br />
Beispiel 1 zeigt, wie die NullpointerException beim Programmieren im Unterricht am häufigsten auftritt.<br />
<code><br />
public class SchuelerVerwaltung{<br />
private List<Schueler> schuelerListe;<br />
<br />
public SchuelerVerwaltung(){<br />
Schueler s1 = new Schueler("Gates","Bill"); <br />
<font color='red'>schuelerListe.append(s1);</font><br />
}<br />
}<br />
</code><br />
'''Erklärung 1:'''<br/><br />
In der roten Zeile kommt es zu einer NullPointerException, weil das Attribut <code>schuelerListe</code> noch gar nicht erzeugt wurde - es ist <code>null</code>.<br />
<br />
Man kann die NullPointerException vermeiden, indem man <u>vor</u> der roten Zeile einfügt:<br />
<code><br />
schuelerListe = new List<>();<br />
</code></div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Java_Basis-Sprachelemente&diff=3652Java Basis-Sprachelemente2024-01-16T17:50:36Z<p>Akaibel: /* Beziehungen zwischen Klassen */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Abitur]]<br />
[[Kategorie:Informatik-EF]]<br />
[[Kategorie:Informatik-Q1]]<br />
<br />
=Allgemeines=<br />
Hier werden die grundlegenden Sprachelemente von Java '''im Detail''' erklärt.<br />
<br />
Wer wissen möchte, wie eine '''ganze Klasse''' aussieht:<br />
* [[Klasse]]<br />
==Erklärvideos==<br />
<br />
* '''[https://www.youtube.com/watch?v=dEFJUra_3ZA Java-Crashkurs Teil 1 (28min)] '''<br/>In Teil 1 des Crash-Kurses geht es um Grundlagen der Programmierung einer Klasse, d.h.<br/>Klasse, Attribut, Konstruktor, Methode, Parameter, lokale Variable etc.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner.txt Programmiervorlage für den Taschenrechner]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-Dokumentation.pdf|Cheat sheet für Teil 1 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[[Medium:Taschenrechner-Fehlersuche.pdf|Taschenrechner Fehlersuche zum Ausdrucken (PDF)]]'''<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner-mit-Fehlern.txt Java-Quelltext für die Fehlersuche]'''<br/>Den Quelltext kann man in [https://www.jdoodle.com/online-java-compiler/ jdoodle] packen und dann die Fehlermeldungen durchklicken!<br />
&nbsp;<br />
* '''[https://youtu.be/IimFb4cEhUU Java-Crashkurs Teil 2 (40min)] '''<br/>In Teil 2 des Crash-Kurses geht es um get- und set-Methoden, Bedingungen und Schleifen.<br />
** '''[http://sibiwiki.de/informatik/crashkurs/Taschenrechner2.txt Programmiervorlage für den Taschenrechner (mit allem für Teil 2)]'''<br />
** '''[https://www.jdoodle.com/online-java-compiler/ jdoodle online compiler]'''<br/><br />
** '''[[Medium:Java-Crashkurs-2-Dokumentation.pdf|Cheat sheet für Teil 2 (PDF)]]''' zum Ausdrucken.<br />
&nbsp;<br />
* '''[https://youtu.be/JVeAUGX60-A Erklärvideo zu Klassen, Objekten, Attritbuten & Methoden (17:08min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br/>[[Medium:VAB-01 Informatik10 KlassenObjekteAttributeMethoden.pdf|Arbeitsblatt zum Video (PDF)]]. <br/>Zu Teilen der Aufgaben gibt es die Lösung im Video, die anderen Aufgaben werden erst im Unterricht besprochen.<br/>&nbsp;<br />
<br />
= Anforderungen Zentralabitur =<br />
Das Zentralabitur fordert die Kenntnis von bestimmten Basis-Sprachelementen, die hier aufgeführt sind.<br />
<br />
Im folgenden werden diese und weitere Basis-Sprachelemente erläutert.<br />
<br />
'''Stand: 2012 (im April 2013 noch aktuell)'''<br />
<br />
* Klassendefinitionen<br />
* Beziehungen zwischen Klassen<br />
** gerichtetete Assoziation<br />
** Vererbung<br />
* Attribute und Methoden (mit Parametern und Rückgabewerten)<br />
* Wertzuweisungen<br />
* Verzweigungen (if, switch)<br />
* Schleifen (while, for, do-while)<br />
<br />
= Klasse, Objekt, Klassendefinition =<br />
''Auf dieser Seite werden Klassen, Objekte etc. Schritt für Schritt erklärt.<br />
<br />
''Den erläuterten kompletten Quellcode einer Java-Klasse findet man hier: [[Klasse in Java]]''<br />
<br />
* Von einer '''Klasse''' können viele '''Objekte''' erzeugt werden.<br />
* Beispiel: Es gibt eine Klasse <code>Baum</code>, von der man viele einzelne Objekte erzeugen kann.<br />
* Java: Definiton einer Klasse:<br />
<code> <br />
'''public class Baum'''<br />
{<br />
// Attribute<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Attribute =<br />
* Attribute beschreiben, welche Eigenschaften bzw. Teil-Objekte die Objekte einer Klasse haben.<br />
* Jedes Attribut kann für jedes einzelne Objekt einer Klasseeinen anderen Wert, den <u>Attribut-Wert</u> haben.<br />
** Beispiel: Die eine Krabbe hat die Geschwindigkeit 5, die andere Krabbe hat die Geschwindigkeit 10.<br />
* Attribute haben einen <u>Attribut-Typ</u>. Für Geschwindigkeiten ist beispielsweise ein Zahltyp sinnvoll, etwa <code>int</code> für ganze Zahlen oder <code>double</code> für Kommazahlen. Für Namen eignet sich <code>String</code>.<br/>Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Java:<br />
** Attribute werden direkt nach der Klassen-Deklaration notiert.<br />
** Attribute sind in der Regel <code>private</code>, d.h. sie können nicht ohne Weiteres von Außen verändert werden.<br />
<br />
'''Beispiel 1:'''<br />
<br />
Objekte der Klasse <code>Auto</code> können unterschiedlichen Tankstand haben.<br />
<br />
Dafür gibt es das Attribut <code>tankstand</code>. Dieses hat den Datentyp <code>double</code>, weil es eine Kommazahl sein kann.<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
'''private double tankstand;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
'''Beispiel 2:'''<br />
<br />
Objekte der Klasse <code>Baum</code> bestehen aus einem <code>Quadrat</code> (für den Stamm) und einem <code>Kreis</code> (für die Krone). <br/>''Die Klassen <code>Quadrat</code> und <code>Kreis</code> müssen natürlich schon im Projekt enthalten sein!!''<br />
<br />
<code><br />
public class Baum<br />
{<br />
// Attribute<br />
'''private Quadrat stamm;'''<br />
'''private Kreis krone;'''<br />
<br />
// Konstruktor<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
= Konstruktor =<br />
'''Aufruf des Konstruktors:'''<br />
* Um ein neues Objekt einer Klasse zu erzeugen, ruft man den Konstruktor der Klasse auf, z.B.:<br />
* Java: <code>Auto neuesAuto = '''new Auto()''';</code><br />
<br />
<br />
'''Deklaration des Konstruktors:'''<br />
* In der Deklaration des Konstruktors wird festgelegt, was passiert, wenn ein Objekt der Klasse erzeugt wird.<br />
* Der Konstruktor heißt genauso wie die Klasse.<br />
* Der Konstruktor hat '''keinen''' Rückgabetyp, also auch kein <code>void</code>.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private int tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto()'''<br />
'''{'''<br />
'''tankstand = 5.0;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch bekommt jedes Auto bei der Erzeugung einen Tankstand von 5.0, d.h. es kann direkt losfahren.<br />
<br />
== Konstruktor mit Parameter ==<br />
Man kann im Konstruktor einen Parameter übergeben, z.B. um direkt bei der Erzeugung die Eigenschaft eines Objektes festzulegen.<br />
<br />
Beispiel:<br />
<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
'''public Auto(<u>double pTankstand</u>)'''<br />
'''{'''<br />
'''tankstand = <u>pTankstand</u>;'''<br />
'''}'''<br />
<br />
// Methoden<br />
}<br />
</code><br />
<br />
<br />
Dadurch muss man bei der Erzeugung des Autos den Tankstand festlegen.<br />
<br />
'''Aufgerufen''' wird dieser Konstruktor dann z.B. so:<br />
<br />
<code>Auto neuesAuto = '''new Auto(7.0)''';</code><br />
<br />
Damit hat <code>neuesAuto</code> den Tankstand 7.0<br />
<br />
= Methoden =<br />
In Methoden wird festgelegt, was man mit einem Objekt der Klasse machen kann.<br />
<br />
'''Beispiel:'''<br />
Für ein Objekt der Klasse Auto soll es die Methode <code>tanken</code> geben. Außerdem soll man den Tankstand mit der Methode <code>gibTankstand()</code> auslesen können.<br />
<code><br />
public class Auto<br />
{<br />
// Attribute<br />
private double tankstand; <br />
<br />
// Konstruktor<br />
public Auto()<br />
{<br />
tanstand = 5.0;<br />
}<br />
<br />
// Methoden<br />
'''public void tanken(double pLiter)'''<br />
'''{'''<br />
'''tankstand = tankstand + pLiter;'''<br />
'''}'''<br />
<br />
'''public double gibTankstand()''' <br />
'''{'''<br />
'''return tankstand;'''<br />
'''}'''<br />
}<br />
</code><br />
<br />
== Methodendeklaration / Methodenkopf ==<br />
Methoden werden durch den '''Methodenkopf (auch: die Methodensignatur)''' deklariert.<br />
<br />
D.h. für Objekte der Klasse kann man dann die Methode aufrufen.<br />
<br />
'''Erklärvideo'''<br />
<br />
Hier gibt es ein '''[https://youtu.be/YPVhVxL67xo Erklärvideo zu Methodensignaturen (auf youtube, 11:42min)]'''. <br/>'' (Man lernt, welche Informationen man an einer Methodensignatur ablesen kann.)<br />
<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
private int preisstufe;<br />
<br />
//Konstruktor<br />
public Automat()<br />
{<br />
preisstufe = 0;<br />
eingeworfen = 0;<br />
}<br />
<br />
//Methoden<br />
<br />
'''public void preisstufeWaehlen(int pPreisstufe)'''<br />
{<br />
preisstufe = pPreisstufe;<br />
}<br />
<br />
'''public int gibPreisstufe()'''<br />
{<br />
int ergebnis = preisstufe;<br />
return ergebnis;<br />
}<br />
<br />
'''public void geldEinwerfen(int betragInCent)'''<br />
{<br />
eingeworfen = eingeworfen + betragInCent;<br />
}<br />
<br />
'''private double steuern(int betrag)'''<br />
{<br />
double ergebnis = betrag * 0.19;<br />
return ergebnis;<br />
}<br />
<br />
'''public int geldZurueckGeben()'''<br />
{<br />
int ergebnis = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
Der '''Methodenkopf''' ist immer gleich aufgebaut:<br />
# '''Zugriffsmodifikator''': <code>public</code> oder <code>private</code>.<br />
## Auf <code>public</code>-Methoden darf man auch von außen zugreifen; sie sind '''öffentlich'''.<br />
## Auf <code>private</code>-Methoden darf nur die Klasse selbst zugreifen, d.h. von außen ist diese Methode nicht sichtbar! Das ist z.B. sinnvoll für Hilfsmethoden, die nicht jeder benutzen soll.<br />
# '''Rückgabetyp''': <code>void</code> für ''nichts'' bzw. ein Datentyp (wie z.B. <code>int</code>) oder auch eine Klasse.<br />
## Im Rückgabetyp wird festgelegt, ob und was die Methode zurückgibt. So sollten Methoden, die etwas berechnen, das Ergebnis auch zurückgeben.<br />
## Die Methode <code>public '''void''' geldEinwerfen(int betragInCent)</code> gibt ''nichts'' zurück. <code>'''void'''</code> ist das Schlüsselwort für ''nichts''.<br />
## Die Methode <code>public '''int''' summe(int a, int b) </code> gibt <code>int</code> zurück, d.h. eine ganze Zahl. Methoden, die etwas zurückgeben, brauchen am Ende der Methode ein '''return-Statement''', z.B.: <code>return ergebnis;</code><br />
# '''Methodenname''': Methodennamen sind Verben, denn Methoden bezeichnen Tätigkeiten! Außerdem ist es üblich, Methodennamen '''klein''' zu schreiben.<br />
# '''Parameter''': In der Klammer nach dem Methodenname findet sich der (bzw. die Parameter).<br />
## Bei den Parametern wird erst der '''Parameter-Typ''' (z.B. <code>int</code>) und dann der '''Parameter-Name''' angegeben.<br />
## Mehrere Parameter werden durch Komma getrennt, z.B. <code>public int summe('''int a, int b''')</code><br />
## Methoden ohne Parameter haben leere Klammern, z.B.: <code>public int geldZurueckGeben'''()'''</code><br />
<br />
== Parameter ==<br />
* Manche Methoden brauchen eine zusätzliche Information, um richtig arbeiten zu können.<br />
* Das ist hier der Fall bei der Methode <code>geldEinwerfen</code>: Damit sie sinnvoll arbeiten kann, muss man angeben können, wie viel Geld man einwirft.<br />
* Dafür haben Methoden '''Parameter''', in diesem Fall <code>betragInCent</code>.<br />
* Bei Parametern muss immer der Typ festgelegt werden; man spricht von '''Parameter-Typ'''.<br />
** Der Parameter-Typ von <code>betragInCent</code> ist <code>int</code>, also eine ganze Zahl.<br />
** Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
* Wenn eine Methode mit Parameter aufgerufen wird, dann muss man den <u>Parameter übergeben</u>. <br />
<code><br />
Automat derAutomat = new Automat();<br />
// jetzt kommt der Methodenaufruf mit Parameterübergabe!<br />
derAutomat.geldEinwerfen('''50''');<br />
</code><br />
* Bei Methoden ohne Parameter steht nach dem Methoden-Namen nur <code>()</code>. Das ist wichtig, um sie von Attribute zu unterscheiden!<br />
<br />
== Rückgabetyp einer Methode ==<br />
Für eine Methode wird immer der Rückgabetyp festgelegt.<br />
* '''<code>void</code>''': Wenn die Methode '''nichts''' zurückgibt (bei einer verändernden Methode).<br />
** Beispiel: <code>public '''void''' geldEinwerfen(int betragInCent)</code><br />
* '''<code>int</code>''': Wenn die Methode eine ganze Zahl (<code>int</code>) zurückgibt.<br />
** Beispiel: <code>public '''int''' geldZurueckGeben()</code><br />
* Statt <code>int</code> kann auch jeder andere Typ oder auch eine Klasse (z.B. <code>Automat</code>) der Rückgabe-Typ einer Methode sein.<br />
** Beispiel: <code>public '''Automat''' gibKopie()</code> : Diese Methode würde eine Kopie des Automaten (also ein Objekt der Klasse <code>Automat</code>) zurückgeben.<br />
<br />
Detaillierte Infos zu den Java-Datentypen finden sich hier: '''[[Java_Basis-Datentypen]]'''<br />
<br />
== sondierende Methode / verändernde Methode ==<br />
* '''sondierende Methode (=get-Methode)''': Dieser Methodentyp ''gibt eine Information über das Objekt zurück''. Diese Methode braucht einen Rückgabetyp (d.h. nicht <code>void</code>) und ein return-Statement.<br />
** Beispiel: <code>public '''int''' gibPreisstufe()</code><br />
* '''verändernde Methode (=set-Methode)''': Dieser Methodentyp ''verändert das Objekt''. Häufig hat dieser Methodentyp einen (oder mehrere) '''Parameter'''. Sie hat zumeist den Rückgabetyp <code>void</code>, denn sie gibt in der Regel nichts zurück.<br />
** Beispiel: <code>public void preisstufeWaehlen('''int pPreisstufe''')</code><br />
<br />
== Methodenaufruf ==<br />
Methoden der gleichen Klasse werden durch ihren Methodennamen aufgerufen.<br />
<br />
'''VORSICHT:'''<br />
Wenn man eine sondierende Methode aufruft, dann muss man sich für das Ergebnis interessieren!<br />
<br />
'''Beispiel:'''<br />
<br />
Im Beispiel ruft die Methode <code>groessteZahl</code> dreimal die Methode <code>gibGroessereZahl</code> auf. Das Ergebnis des Aufrufs wird jeweils in einer lokalen Variable (z.B. <code>groessere12</code> gespeichert, um damit weiter zu rechnen.<br />
<code><br />
public class Rechner{<br />
public int groessteZahl(int z1, int z2, int z3, int z4)<br />
{<br />
int groessere12 = '''gibGroessereZahl(z1, z2);'''<br />
int groessere34 = '''gibGroessereZahl(z3, z4);'''<br />
int ergebnis = '''gibGroessereZahl(groessere12, groessere34);'''<br />
return ergebnis;<br />
}<br />
<br />
'''public int gibGroessereZahl(int a, int b)'''<br />
{<br />
int ergebnis;<br />
if(a > b)<br />
{<br />
return a;<br />
}<br />
else<br />
{<br />
return b;<br />
}<br />
}<br />
}<br />
</code><br />
<br />
===Methoden für Objekte anderer Klassen aufrufen ===<br />
Man kann auf für ein Objekt einer anderen Klasse eine Methode aufrufen; damit wird eine Aufgabe '''delegiert'''.<br />
<br />
'''WICHTIG: Das wesentliche Syntax-Element ist der Punkt!''' <br/>Man gibt erst das Objekt an, dann den Punkt, dann die Methode (ggf. mit Parameter).<br/>Z.B. <code> '''stamm.bewegeZuPosition(110,120)''';</code><br />
<br />
'''Beispiel :'''<br />
<code><br />
public class Baum<br />
{<br />
// Attribute der Klasse Baum<br />
private Kreis krone;<br />
private Quadrat stamm;<br />
<br />
// Konstruktor der Klasse Baum<br />
public Baum()<br />
{<br />
stamm = new Quadrat();<br />
'''stamm.bewegeZuPosition(110,120)''';<br />
'''stamm.sichtbarMachen()''';<br />
krone = new Kreis();<br />
'''krone.bewegeZuPosition(100,100)''';<br />
'''krone.sichtbarMachen()''';<br />
}<br />
}<br />
</code><br />
<br />
'''Erklärung:'''<br />
* <code>stamm</code> ist ein Objekt vom Typ <code>Quadrat</code>; deshalb verfügt <code>stamm</code> über die Methode <code>sichtbarMachen()</code>.<br />
* Im Konstruktor von <code>Baum</code> wird diese Methode mithilfe des Punktes aufgerufen:<br />
** Attributname -> Punkt -> Methodenname.<br />
*<br />
Ein Objekt der Klasse <code>Haus</code> ruft in einem Objekt der Klasse <code>Quadrat</code> die Methode<br />
<br />
=lokale Variable=<br />
* '''Lokale Variablen sind nur in dem Block gültig, in dem sie deklariert wurden.'''<br />
* Lokale Variablen kann man (im Gegensatz zu Attributen) <u>nicht</u> in der ganzen Klasse benutzen. <br />
* Man benutzt lokale Variablen, um Informationen zu speichern, die man nur kurzfristig braucht.<br />
** U.a. werden lokale Variablen immer dann eingesetzt, wenn eine Methode ein Ergebnis berechnen und dann zurückgegeben soll.<br />
<br />
'''Beispiel aus der Klasse <code>Automat</code>:'''<br />
'''Beispiel:'''<br />
<code><br />
public class Automat {<br />
//Attribute<br />
private int eingeworfen;<br />
<br />
// weitere Attribute, Konstruktor und Methoden<br />
<br />
public int geldZurueckGeben()<br />
{<br />
'''int ergebnis''' = eingeworfen;<br />
eingeworfen = 0;<br />
return ergebnis;<br />
}<br />
}<br />
</code><br />
<br />
= Wertzuweisungen =<br />
Attributen und lokalen Variablen können Werte zugewiesen werden.<br />
* Beispiel 1:<br />
** <code>geschwindigkeit = 10;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert 10 zugewiesen.<br />
* Beispiel 2:<br />
** <code>geschwindigkeit = neueGeschwindigkeit;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>neueGeschwindigkeit</code> zugewiesen.<br />
* Beispiel 3:<br />
** <code>geschwindigkeit = geschwindigkeit + 1;</code><br />
** Damit wird dem Attribut <code>geschwindigkeit</code> der Wert <code>geschwindigkeit+1</code> zugewiesen,<br />
** d.h. die Geschwindigkeit wird '''um 1 erhöht'''!<br />
* Allgemein:<br />
** '''links vom Gleichzeichen''' steht das Attribut (bzw. die lokale Variable), der ein neuer Wert zugewiesen wird.<br />
** '''rechts vom Gleichzeichen''' steht der neue Wert.<br />
<br />
<br />
Außerdem gibt es praktische Abkürzungen für Wertzuweisungen, vor allem '''<code>+=</code>''' und '''<code>++</code>'''.<br />
<br />
* Beispiel 4:<br />
** <code>geschwindigkeit '''+=''' 5;</code><br />
** '''<code>+=</code>''' bedeutet: erhöhe um..., d.h. im Beispiel wird Geschwindigkeit wird um 5 erhöht.<br />
* Beispiel 5:<br />
** <code>geschwindigkeit'''++''';</code><br />
** '''<code>++</code>''' bedeutet: erhöhe um eins.<br />
<br />
= Verzweigungen (if-else) =<br />
Beispiel: die folgende Methode überprüft, welche von zwei Zahlen die größere ist.<br />
<br />
Es passiert folgendes: Wenn (<code>if</code>) <code>a</code> größer als <code>b</code> ist, dann wird <code>ergebnis</code> auf <code>a</code> gesetzt, sonst (<code>else</code>) auf <code>b</code>.<br />
<br />
<code><br />
public int bestimmeDieGroessere(int a, int b)<br />
{<br />
int ergebnis;<br />
'''if(a > b)'''<br />
{<br />
ergebnis = a;<br />
}<br />
'''else'''<br />
{<br />
ergebnis = b;<br />
}<br />
return ergebnis;<br />
}<br />
</code><br />
<br />
'''VORSICHT:'''<br />
Gleichheit überprüft man mit '''doppeltem''' Gleichzeichen:<br />
<code><br />
// Wenn x gleich drei ist, ...<br />
if(x '''==''' 3)<br />
{<br />
...<br />
}<br />
</code><br />
<br />
= Schleifen (while, for, do-while) =<br />
Bei Schleifen kommen die Fähigkeiten der Computer besonders zur Geltung: Schleifen ermöglichen es, dass man Aktionen mehrfach (d.h. auch 1.000 oder 1.000.000 mal) wiederholt.<br />
== for-Schleife ==<br />
Die for-Schleife ist eine '''Zählschleife'''. Sie wird eingesetzt, wenn man zählen kann, wie oft Aktionen wiederholt werden sollen. Dafür gibt es eine '''Zählvariable''', die häufig <code>i</code> heißt, aber jeder andere Name ist auch denkbar.<br />
<br />
'''Beispiel:'''<br />
<br />
Die folgende for-Schleife gibt die Zahlen 0, 3, 6, ...., 999 an die Konsole aus.<br />
<br />
<code><br />
'''for(int i=0; i<=333; i++)'''<br />
{<br />
System.out.println(3*i);<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
<br />
* Die Klammer nach dem <code>for</code> hat drei Teile:<br />
** ''Deklaration und Initialisierung der Zählvariable <code>i</code>:'' i startet bei 0.<br />
** ''Schleifenbedingung:'' Die Schleife wird so lange wiederholt, wie i <= 333 ist.<br />
** ''Veränderung bei jedem Schleifendurchlauf:'' i wird bei jedem Schleifendurchlauf um eins erhöht. (<code>i++</code> bedeutet dasselbe wie <code>i = i+1</code>). D.h. i nimmt nacheinander folgende Werte an: 0, 1, 2, ..., 333.<br />
** Im Schleifenrumpf wird mit <code>System.out.println(i);</code> jeweils das Dreifache von <code>i</code> an die Konsole ausgegeben, d.h.: 0, 3, 6, ..., 999.<br />
<br />
==while-Schleife==<br />
Die while-Schleife ist eine '''bedingte'''Schleife. Sie wird eingesetzt, wenn Aktionen wiederholt werden sollen, solange die '''Schleifenbedingung''', erfüllt ist.<br />
<br />
'''Erklärvideo'''<br><br />
Hier gibt es ein '''[https://www.youtube.com/watch?v=kPovFPak0Hs Erklärvideo zu while-Schleifen (auf youtube, 11:49min)]''' <br/>'' (anhand eines Greenfoot-Szenarios)<br />
<br />
'''Beispiel:'''<br />
Die folgende while-Schleife beginnt bei <code>zahl = 1</code>. <code>zahl</code> wird dann so lange an die Konsole ausgegeben und verdoppelt, wie <code>zahl</code> kleiner als 1000 ist. D.h. die Ausgabe ist: 1, 2, 4, ..., 256, 512.<br />
<br />
<code><br />
int zahl = 1;<br />
'''while(zahl < 1000)'''<br />
{<br />
System.out.println(zahl);<br />
// zahl verdoppeln<br />
zahl = zahl * 2;<br />
}<br />
</code><br />
<br />
'''Erläuterung:'''<br />
* Die Klammer nach dem <code>while</code> enthält die Bedingung: Wiederhole, solange zahl kleiner 1000 ist.<br />
* Im Schleifenrumpf wird dann <code>zahl</code> an die Konsole ausgegeben und dann mit <code>zahl = zahl * 2;</code> verdoppelt.<br />
<br />
= Beziehungen zwischen Klassen =<br />
''Die Implementierung von Beziehungen zwischen Klassen ist auf anderen Seiten erklärt, auf die hier nur verwiesen wird.''<br />
<br />
'''"kennt"-Beziehung:'''<br />
<br />
Wie man kennt-Beziehungen implementiert, kann man hier nachlesen:<br/><br />
[[Klassen-_und_Implementationsdiagramm#Java-Quelltext:|Szenario Roller (Quelltext)]]<br />
<br />
'''Vererbung:'''<br/><br />
[[Vererbung#Implementierung|Szenario Buch - Fachbuch - Hörbuch]]</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Relationales_Datenmodell&diff=3651Relationales Datenmodell2024-01-16T15:01:30Z<p>Akaibel: /* Endergebnis und Zusammenfassung */</p>
<hr />
<div>[[Kategorie:Datenbanken]]<br />
[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Q1]]<br />
[[Kategorie:Informatik-Abitur]]<br />
<br />
Mithilfe von Relationalen Datenmodellen kann man relationale Datenbanken planen:<br />
<br />
Realität -> Anforderungsermittlung -> [[Entity-Relationship-Modell]] -> '''Relationales Datenmodell''' -> Datenbanksystem<br />
<br />
Um ein relationales Datenmodell zu erstellen, muss erst ein [[Entity-Relationship-Modell]] vorliegen.<br />
Das Entity-Relationship-Modell kann mithilfe von technischen Schritten in ein relationales Datenmodell übersetzt werden.<br />
<br />
<br />
=Erklärvideos=<br />
# [https://youtu.be/0_3Dyf-7_Bg Relationales Datenmodell - Was ist das?]<br />
# [https://youtu.be/JEyv8hh_Q5I aus einem Entity-Relationship-Modell ein relationales Datenmodell erstellen]<br />
# [https://youtu.be/MSe4uxcxTHg Mit MySQL-Workbench und XAMPP aus dem ER-Modell eine "echte" Datenbank erzeugen]<br />
<br />
=Fachbegriffe=<br />
<br />
Primärschlüssel, Primärschlüssel kombiniert aus zwei Fremdschlüsseln, Fremdschlüssel, Attribut, Tabelle, 1:n-Beziehung, n:m-Beziehung<br />
<br />
<font color='red'><br />
Das Zentralabitur verwendet folgende Fachbegriffe, die hier kurz übersetzt werden:<br />
</font><br />
* <font color='red'>'''Datenbankschema'''</font> = das ganze relationale Datenmodell<br />
* <font color='red'>'''Relationenschema'''</font> = eine Zeile im relationalen Datenmodell, z.B. kurs(<u>id</u>, name, kuerzel, halbjahr, &uarr;lehrer_id)<br/>''Hier wird das "Tabelle" genannt, weil es in der Datenbank eine Tabelle wird.''<br />
<br />
=Erläuterung der Begriffe=<br />
<br />
* '''Primärschlüssel''': Der Primärschlüssel (Primary Key; abgekürzt: '''PK''') ist ein Attribut (oder eine Kombination aus 2 Attributen), das '''einen Datensatz (d.h. eine Zeile in einer Datenbank-Tabelle) eindeutig identifiziert'''. <br />
** Primärschlüssel werden unterstrichen, z.B. '''<u>id</u>'''<br />
* '''Fremdschlüssel''': Der Fremdschlüssel (Foreign Key; abgekürzt: '''FK''') stellt die Verbindung zwischen Tabellen her: '''Ein Fremdschlüssel verweist auf den Primärschlüssel einer anderen Tabelle.'''<br />
** Fremdschlüssel werden durch einen Pfeil nach oben (&uarr;) markiert, z.B.: '''&uarr;kunde_id'''<br />
<br />
=Vom ER-Modell zum relationalen Datenmodell=<br />
[[File:ER-modell-lehrer-kurs-schueler.png|thumb|ER-Modell Kurssystem |572px]]<br />
<br />
Der Weg vom ER-Modell zum relationalen Datenmodell wird beispielhaft am ER-Modell ''Kurssystem'' (s. rechts) dargestellt.<br />
<br />
== Primärschlüssel festlegen==<br />
Für die Entitätsmengen ''schueler'', ''kurs'' und ''lehrer'' müssen Primärschlüssel festgelegt werden:<br />
* Keine der drei Tabellen hat ein Attribut, das einen Datensatz eindeutig identifiziert.<br />
* Deswegen erhält jede Entitätsmenge ein neues Attribut <u>id</u> als Primärschlüssel.<br />
<br />
'''Zwischenergebnis:'''<br />
<br />
* schueler('''<u>id</u>''', name, vorname, geburtsdatum, adresse, geschlecht)<br />
* kurs('''<u>id</u>''', name, kuerzel, halbjahr)<br />
* lehrer('''<u>id</u>''', name, vorname, kuerzel)<br />
<br />
Man sieht, dass die Beziehungen zwischen den Entitätsmengen noch nicht in das relationale Datenmodell übersetzt wurden; dementsprechend fehlt auch das Attribut ''note''.<br />
<br />
== 1:n-Beziehungen übertragen==<br />
1:n-Beziehungen werden in das relationale Datenmodell übersetzt, indem '''auf der n-Seite''' der Beziehung ein Fremdschlüssel eingetragen wird, der auf den Primärschlüssel der anderen beteiligten Tabelle verweist.<br />
* ''lehrer'' - ''kurs'' ist eine 1:n-Beziehung.<br />
* ''kurs'' ist auf der n-Seite der Beziehung.<br />
* in ''kurs'' wird als Fremdschlüssel '''&uarr;lehrer_id''' eingetragen.<br />
<br />
'''Zwischenergebnis:'''<br />
<br />
* schueler(<u>id</u>, name, vorname, geburtsdatum, adresse, geschlecht)<br />
* kurs(<u>id</u>, name, kuerzel, halbjahr, '''&uarr;lehrer_id''')<br />
* lehrer(<u>id</u>, name, vorname, kuerzel)<br />
<br />
Jetzt kann man bei jedem einzelen Kurs sehen, welcher Lehrer ihn unterrichtet.<br />
<br />
== n:m-Beziehungen übertragen==<br />
n:m-Beziehungen werden in das relationale Datenmodell übersetzt, indem man eine '''Zwischentabelle''' einfügt: die Zwischentabelle enthält zwei Fremdschlüssel auf die beiden Tabellen der Beziehung. Meistens kann die ''Kombination'' der beiden Fremdschlüssel als Primärschlüssel der Zwischentabelle genutzt werden.<br />
* Eine Tabelle ''belegt'' wird eingeführt.<br />
* sie enthält als Attribute die beiden Fremdschlüssel '''&uarr;schueler_id''' und '''&uarr;kurs_id''' - und zusätzlich das Attribut '''note'''.<br />
* die beiden Fremdschlüssel können '''zusammen''' als Primärschlüssel genutzt werden, denn jeder Schüler kann jeden Kurs nur einmal belegen.<br />
<br />
'''Man erhält also:'''<br />
<br />
* schueler(<u>id</u>, name, vorname, geburtsdatum, adresse, geschlecht)<br />
* '''belegt(<u>&uarr;schueler_id</u>, <u>&uarr;kurs_id</u>, note)'''<br />
* kurs(<u>id</u>, name, kuerzel, halbjahr, &uarr;lehrer_id)<br />
* lehrer(<u>id</u>, name, vorname, kuerzel)<br />
<br />
==Endergebnis und Zusammenfassung==<br />
'''Endergebnis für das relationale Datenmodell:'''<br />
<br />
* schueler(<u>id</u>, name, vorname, geburtsdatum, adresse, geschlecht)<br />
* belegt(<u>&uarr;schueler_id</u>, <u>&uarr;kurs_id</u>, note)<br />
* kurs(<u>id</u>, name, kuerzel, halbjahr, &uarr;lehrer_id)<br />
* lehrer(<u>id</u>, name, vorname, kuerzel)<br />
<br />
'''Zusammenfassung:'''<br />
* Jede Entitätsmenge bekommt einen '''Primärschlüssel'''<br />
* '''1:n-Beziehungen''' werden durch einen '''Fremdschlüssel auf der n-Seite der Beziehung''' modelliert.<br />
* '''n:m-Beziehungen''' werden durch eine eigene Tabelle modelliert:<br />
** die Tabelle enthält '''zwei Fremdschlüssel''', für jede beteiligte Entitätsmenge einen.<br />
** die Tabelle kann weitere Attribute enthalten.<br />
<br />
=Praxis=<br />
In der Praxis nimmt man zur Erstellung des relationalen Datenmodells ein Tool, z.B. MySQL-Workbench.<br />
<br />
Vorteil: Man kann das fertige relationale Datenmodell sofort in die Datenbank exportieren.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Visual_Studio_Code&diff=3650Visual Studio Code2024-01-15T18:02:57Z<p>Akaibel: Die Seite wurde neu angelegt: „Kategorie:Informatik <font color='red'>Diese Seite ist im Aufbau.</font> =Shortcuts= * SHIFT + ALT + F: richtig einrücken (''indent'')“</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
<br />
<font color='red'>Diese Seite ist im Aufbau.</font><br />
<br />
=Shortcuts=<br />
* SHIFT + ALT + F: richtig einrücken (''indent'')</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Projekt_java_Q1Q2&diff=3649Projekt java Q1Q22024-01-15T17:50:44Z<p>Akaibel: /* Visual Studio Code */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Q1]]<br />
[[Kategorie:Informatik-Q2]]<br />
<br />
Das Projekt java_Q1Q2 umfasst ALLE Szenarien, mit denen am SIBI in der Q1 und Q2 Java entwickelt wird.<br />
<br />
'''<u>D.h. wer sich das einmal runterlädt, der hat softwaremäßig für die Q1 und Q2 ausgesorgt!!!</u>'''<br />
<br />
=Stand des Projektes:=<br />
<br />
* Das Projekt bildet die Schnittstellen des Abi 2018 (und folgende) ab. <br />
<br />
* Letztes Update: 28.07.2023<br />
<br />
''Der aktuellste Stand des Projektes findet sich immer auf GitHub. (siehe weiter unten).''<br />
<br />
=Voraussetzungen=<br />
<br />
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).<br />
<br />
==Visual Studio Code==<br />
'''Installation''':<br />
* [https://www.youtube.com/watch?v=RkU3ape9e24 Erklärvideo zur Installation von VS Code und Java (2:30min)]<br />
* [https://devblogs.microsoft.com/java/announcing-visual-studio-code-java-installer/ Link zum Artikel (aus dem Video)]<br />
* [https://aka.ms/vscode-java-installer-win direkter Link zum Installer]<br />
* Wenn die Installation von VS-Code fehlschlägt:<br />
** [https://code.visualstudio.com/Download Download von VS-Code]<br />
** Dann muss man links das Symbol für "Extensions" anklicken,<br/>"Extension Pack für Java" auswählen<br/>und das installieren.<br />
<br />
== Eclipse==<br />
<br />
Um das Projekt öffnen zu können, muss man '''[[Eclipse]]''' installiert haben. Wie man das tut, erfährt man hier: '''[[Eclipse|Eclipse]]'''.<br />
<br />
==BlueJ==<br />
<br />
Man kann das Projekt auch mit '''BlueJ''' öffnen. <br/><br />
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.<br/><br />
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.<br />
<br />
'''<u>WICHTIG: </u>''' Wenn man das Projekt mit BlueJ öffnet, dann muss man alle Klassen über die main-Methode starten:<br />
<br />
* rechte Maustaste auf die Klasse -> main auswählen.<br />
<br />
=Download und Öffnen in Eclipse=<br />
'''''<font color='red'>Dieser Weg ist viel komplizierter als das direkte Runterladen von GitHub (siehe unten).</font>'''''<br />
<br />
* '''Runterladen und entpacken:'''<br />
* '''[[Datei:Java Q1Q2.zip]]''' runterladen<br />
<br />
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")<br />
<br />
'''In Eclipse:'''<br />
<br />
*File -> New -> Java Project<br />
*Haken weg bei "Use Default Location"<br />
*"Browse" klicken und den Ordner "javaQ1Q2" suchen.<br />
**Evtl. liegt dieser Ordner in einem übergeordneten Ordner "javaQ1Q2".<br/>Dann den "inneren" der beiden Ordner wählen.<br />
*"Finish" klicken<br />
<br />
'''Jetzt die notwendigen Bibliotheken einbauen:'''<br />
<br />
*'''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen<br />
*in einen geeigneten Ordner extrahieren (z.B. Informatik)<br />
* in Eclipse:<br />
** Das Projekt java_Q1Q2 auswählen<br />
** Project -> Properties -> Java Build Path -> Libraries<br />
** "Add External JARs" klicken<br />
** alle JAR-Files aus dem Ordner "Jung" auswählen.<br />
** nochmal "Add External JARs" klicken<br />
** im Order DB-java-connector die Datei "mysql-connector-java-5.0.8-bin.jar" auswählen.<br />
<br />
==Von GitHub beziehen==<br />
Man kann das Projekt javaQ1Q2 auch von GitHub beziehen. Dort findet sich die aktuelleste Version des Projektes:<br />
<br />
'''[https://github.com/akaibel/javaQ1Q2 https://github.com/akaibel/javaQ1Q2]'''<br />
<br />
So bekommt man es in Eclipse:<br />
# Copy the GitHub URL of the repository to the clipboard.<br />
# Open Eclipse and choose File -> Import –> Git -> Projects from Git<br />
# Choose the Clone URI option in the Git import wizard and click Next.<br />
# Confirm the URI, Host and Repository path parameters and click Next.<br />
# In "local destination" choose the directory, where the project should go to.<br />
<br />
=Download und Öffnen in BlueJ=<br />
* '''[[Datei:Java Q1Q2.zip]]'''<br />
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")<br />
* In BlueJ:<br />
** Project -> Open Non BlueJ bzw. <br/>Projekt -> Fremdprojekt öffnen<br />
** Den Ordner "java-Q1Q2-202021" suchen.<br />
*** Evtl. liegt dieser Ordner im Ordner "java-Q1Q2-202021-2020-07-28".<br />
* '''Jetzt noch die notwendigen Libraries laden:'''<br />
** '''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen und entzippen.<br />
<br />
** Tools -> Preferences -> Libraries -> Add bzw.<br/>Werkzeuge -> Einstellungen -> Bibliotheken -> Hinzufügen<br />
<br />
** Den Ordner ECLIPSE_LIBRARIES suchen.<br />
** In diesem Ordner jede jar-Datei einzeln durch Anklicken hinzufügen (=etwas mühsam...)<br />
* Abschließend mit STRG+UMSCHALT+R die Virtuelle Maschine neu starten.<br />
* Testen: Im Package _test die Klasse Graphtest: <br/>rechte Maustaste -> main ausführen.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Projekt_java_Q1Q2&diff=3648Projekt java Q1Q22024-01-15T17:46:39Z<p>Akaibel: /* Visual Studio Code */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Q1]]<br />
[[Kategorie:Informatik-Q2]]<br />
<br />
Das Projekt java_Q1Q2 umfasst ALLE Szenarien, mit denen am SIBI in der Q1 und Q2 Java entwickelt wird.<br />
<br />
'''<u>D.h. wer sich das einmal runterlädt, der hat softwaremäßig für die Q1 und Q2 ausgesorgt!!!</u>'''<br />
<br />
=Stand des Projektes:=<br />
<br />
* Das Projekt bildet die Schnittstellen des Abi 2018 (und folgende) ab. <br />
<br />
* Letztes Update: 28.07.2023<br />
<br />
''Der aktuellste Stand des Projektes findet sich immer auf GitHub. (siehe weiter unten).''<br />
<br />
=Voraussetzungen=<br />
<br />
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).<br />
<br />
==Visual Studio Code==<br />
'''Installation''':<br />
* [https://www.youtube.com/watch?v=RkU3ape9e24 Erklärvideo zur Installation von VS Code und Java (2:30min)]<br />
* [https://devblogs.microsoft.com/java/announcing-visual-studio-code-java-installer/ Link zum Artikel (aus dem Video)]<br />
* [https://aka.ms/vscode-java-installer-win direkter Link zum Installer]<br />
* Wenn die Installation von VS-Code fehlschlägt:<br/>[https://code.visualstudio.com/Download Download von VS-Code]<br />
<br />
== Eclipse==<br />
<br />
Um das Projekt öffnen zu können, muss man '''[[Eclipse]]''' installiert haben. Wie man das tut, erfährt man hier: '''[[Eclipse|Eclipse]]'''.<br />
<br />
==BlueJ==<br />
<br />
Man kann das Projekt auch mit '''BlueJ''' öffnen. <br/><br />
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.<br/><br />
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.<br />
<br />
'''<u>WICHTIG: </u>''' Wenn man das Projekt mit BlueJ öffnet, dann muss man alle Klassen über die main-Methode starten:<br />
<br />
* rechte Maustaste auf die Klasse -> main auswählen.<br />
<br />
=Download und Öffnen in Eclipse=<br />
'''''<font color='red'>Dieser Weg ist viel komplizierter als das direkte Runterladen von GitHub (siehe unten).</font>'''''<br />
<br />
* '''Runterladen und entpacken:'''<br />
* '''[[Datei:Java Q1Q2.zip]]''' runterladen<br />
<br />
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")<br />
<br />
'''In Eclipse:'''<br />
<br />
*File -> New -> Java Project<br />
*Haken weg bei "Use Default Location"<br />
*"Browse" klicken und den Ordner "javaQ1Q2" suchen.<br />
**Evtl. liegt dieser Ordner in einem übergeordneten Ordner "javaQ1Q2".<br/>Dann den "inneren" der beiden Ordner wählen.<br />
*"Finish" klicken<br />
<br />
'''Jetzt die notwendigen Bibliotheken einbauen:'''<br />
<br />
*'''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen<br />
*in einen geeigneten Ordner extrahieren (z.B. Informatik)<br />
* in Eclipse:<br />
** Das Projekt java_Q1Q2 auswählen<br />
** Project -> Properties -> Java Build Path -> Libraries<br />
** "Add External JARs" klicken<br />
** alle JAR-Files aus dem Ordner "Jung" auswählen.<br />
** nochmal "Add External JARs" klicken<br />
** im Order DB-java-connector die Datei "mysql-connector-java-5.0.8-bin.jar" auswählen.<br />
<br />
==Von GitHub beziehen==<br />
Man kann das Projekt javaQ1Q2 auch von GitHub beziehen. Dort findet sich die aktuelleste Version des Projektes:<br />
<br />
'''[https://github.com/akaibel/javaQ1Q2 https://github.com/akaibel/javaQ1Q2]'''<br />
<br />
So bekommt man es in Eclipse:<br />
# Copy the GitHub URL of the repository to the clipboard.<br />
# Open Eclipse and choose File -> Import –> Git -> Projects from Git<br />
# Choose the Clone URI option in the Git import wizard and click Next.<br />
# Confirm the URI, Host and Repository path parameters and click Next.<br />
# In "local destination" choose the directory, where the project should go to.<br />
<br />
=Download und Öffnen in BlueJ=<br />
* '''[[Datei:Java Q1Q2.zip]]'''<br />
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")<br />
* In BlueJ:<br />
** Project -> Open Non BlueJ bzw. <br/>Projekt -> Fremdprojekt öffnen<br />
** Den Ordner "java-Q1Q2-202021" suchen.<br />
*** Evtl. liegt dieser Ordner im Ordner "java-Q1Q2-202021-2020-07-28".<br />
* '''Jetzt noch die notwendigen Libraries laden:'''<br />
** '''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen und entzippen.<br />
<br />
** Tools -> Preferences -> Libraries -> Add bzw.<br/>Werkzeuge -> Einstellungen -> Bibliotheken -> Hinzufügen<br />
<br />
** Den Ordner ECLIPSE_LIBRARIES suchen.<br />
** In diesem Ordner jede jar-Datei einzeln durch Anklicken hinzufügen (=etwas mühsam...)<br />
* Abschließend mit STRG+UMSCHALT+R die Virtuelle Maschine neu starten.<br />
* Testen: Im Package _test die Klasse Graphtest: <br/>rechte Maustaste -> main ausführen.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Projekt_java_Q1Q2&diff=3647Projekt java Q1Q22024-01-15T17:42:30Z<p>Akaibel: /* Visual Studio Code */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Q1]]<br />
[[Kategorie:Informatik-Q2]]<br />
<br />
Das Projekt java_Q1Q2 umfasst ALLE Szenarien, mit denen am SIBI in der Q1 und Q2 Java entwickelt wird.<br />
<br />
'''<u>D.h. wer sich das einmal runterlädt, der hat softwaremäßig für die Q1 und Q2 ausgesorgt!!!</u>'''<br />
<br />
=Stand des Projektes:=<br />
<br />
* Das Projekt bildet die Schnittstellen des Abi 2018 (und folgende) ab. <br />
<br />
* Letztes Update: 28.07.2023<br />
<br />
''Der aktuellste Stand des Projektes findet sich immer auf GitHub. (siehe weiter unten).''<br />
<br />
=Voraussetzungen=<br />
<br />
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).<br />
<br />
==Visual Studio Code==<br />
'''Installation''':<br />
* [https://www.youtube.com/watch?v=RkU3ape9e24 Erklärvideo zur Installation von VS Code und Java (2:30min)]<br />
* [https://devblogs.microsoft.com/java/announcing-visual-studio-code-java-installer/ Link zum Artikel (aus dem Video)]<br />
* [https://aka.ms/vscode-java-installer-win direkter Link zum Installer]<br />
<br />
== Eclipse==<br />
<br />
Um das Projekt öffnen zu können, muss man '''[[Eclipse]]''' installiert haben. Wie man das tut, erfährt man hier: '''[[Eclipse|Eclipse]]'''.<br />
<br />
==BlueJ==<br />
<br />
Man kann das Projekt auch mit '''BlueJ''' öffnen. <br/><br />
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.<br/><br />
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.<br />
<br />
'''<u>WICHTIG: </u>''' Wenn man das Projekt mit BlueJ öffnet, dann muss man alle Klassen über die main-Methode starten:<br />
<br />
* rechte Maustaste auf die Klasse -> main auswählen.<br />
<br />
=Download und Öffnen in Eclipse=<br />
'''''<font color='red'>Dieser Weg ist viel komplizierter als das direkte Runterladen von GitHub (siehe unten).</font>'''''<br />
<br />
* '''Runterladen und entpacken:'''<br />
* '''[[Datei:Java Q1Q2.zip]]''' runterladen<br />
<br />
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")<br />
<br />
'''In Eclipse:'''<br />
<br />
*File -> New -> Java Project<br />
*Haken weg bei "Use Default Location"<br />
*"Browse" klicken und den Ordner "javaQ1Q2" suchen.<br />
**Evtl. liegt dieser Ordner in einem übergeordneten Ordner "javaQ1Q2".<br/>Dann den "inneren" der beiden Ordner wählen.<br />
*"Finish" klicken<br />
<br />
'''Jetzt die notwendigen Bibliotheken einbauen:'''<br />
<br />
*'''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen<br />
*in einen geeigneten Ordner extrahieren (z.B. Informatik)<br />
* in Eclipse:<br />
** Das Projekt java_Q1Q2 auswählen<br />
** Project -> Properties -> Java Build Path -> Libraries<br />
** "Add External JARs" klicken<br />
** alle JAR-Files aus dem Ordner "Jung" auswählen.<br />
** nochmal "Add External JARs" klicken<br />
** im Order DB-java-connector die Datei "mysql-connector-java-5.0.8-bin.jar" auswählen.<br />
<br />
==Von GitHub beziehen==<br />
Man kann das Projekt javaQ1Q2 auch von GitHub beziehen. Dort findet sich die aktuelleste Version des Projektes:<br />
<br />
'''[https://github.com/akaibel/javaQ1Q2 https://github.com/akaibel/javaQ1Q2]'''<br />
<br />
So bekommt man es in Eclipse:<br />
# Copy the GitHub URL of the repository to the clipboard.<br />
# Open Eclipse and choose File -> Import –> Git -> Projects from Git<br />
# Choose the Clone URI option in the Git import wizard and click Next.<br />
# Confirm the URI, Host and Repository path parameters and click Next.<br />
# In "local destination" choose the directory, where the project should go to.<br />
<br />
=Download und Öffnen in BlueJ=<br />
* '''[[Datei:Java Q1Q2.zip]]'''<br />
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")<br />
* In BlueJ:<br />
** Project -> Open Non BlueJ bzw. <br/>Projekt -> Fremdprojekt öffnen<br />
** Den Ordner "java-Q1Q2-202021" suchen.<br />
*** Evtl. liegt dieser Ordner im Ordner "java-Q1Q2-202021-2020-07-28".<br />
* '''Jetzt noch die notwendigen Libraries laden:'''<br />
** '''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen und entzippen.<br />
<br />
** Tools -> Preferences -> Libraries -> Add bzw.<br/>Werkzeuge -> Einstellungen -> Bibliotheken -> Hinzufügen<br />
<br />
** Den Ordner ECLIPSE_LIBRARIES suchen.<br />
** In diesem Ordner jede jar-Datei einzeln durch Anklicken hinzufügen (=etwas mühsam...)<br />
* Abschließend mit STRG+UMSCHALT+R die Virtuelle Maschine neu starten.<br />
* Testen: Im Package _test die Klasse Graphtest: <br/>rechte Maustaste -> main ausführen.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Projekt_java_Q1Q2&diff=3646Projekt java Q1Q22024-01-15T17:40:46Z<p>Akaibel: /* Voraussetzungen */</p>
<hr />
<div>[[Kategorie:Informatik]]<br />
[[Kategorie:Informatik-Q1]]<br />
[[Kategorie:Informatik-Q2]]<br />
<br />
Das Projekt java_Q1Q2 umfasst ALLE Szenarien, mit denen am SIBI in der Q1 und Q2 Java entwickelt wird.<br />
<br />
'''<u>D.h. wer sich das einmal runterlädt, der hat softwaremäßig für die Q1 und Q2 ausgesorgt!!!</u>'''<br />
<br />
=Stand des Projektes:=<br />
<br />
* Das Projekt bildet die Schnittstellen des Abi 2018 (und folgende) ab. <br />
<br />
* Letztes Update: 28.07.2023<br />
<br />
''Der aktuellste Stand des Projektes findet sich immer auf GitHub. (siehe weiter unten).''<br />
<br />
=Voraussetzungen=<br />
<br />
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).<br />
<br />
==Visual Studio Code==<br />
'''Installation''':<br />
* [https://www.youtube.com/watch?v=RkU3ape9e24 Erklärvideo zur Installation von VS Code und Java (2:30min)]<br />
* [https://devblogs.microsoft.com/java/announcing-visual-studio-code-java-installer/ Link zum Installer (aus dem Video]<br />
<br />
== Eclipse==<br />
<br />
Um das Projekt öffnen zu können, muss man '''[[Eclipse]]''' installiert haben. Wie man das tut, erfährt man hier: '''[[Eclipse|Eclipse]]'''.<br />
<br />
==BlueJ==<br />
<br />
Man kann das Projekt auch mit '''BlueJ''' öffnen. <br/><br />
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.<br/><br />
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.<br />
<br />
'''<u>WICHTIG: </u>''' Wenn man das Projekt mit BlueJ öffnet, dann muss man alle Klassen über die main-Methode starten:<br />
<br />
* rechte Maustaste auf die Klasse -> main auswählen.<br />
<br />
=Download und Öffnen in Eclipse=<br />
'''''<font color='red'>Dieser Weg ist viel komplizierter als das direkte Runterladen von GitHub (siehe unten).</font>'''''<br />
<br />
* '''Runterladen und entpacken:'''<br />
* '''[[Datei:Java Q1Q2.zip]]''' runterladen<br />
<br />
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")<br />
<br />
'''In Eclipse:'''<br />
<br />
*File -> New -> Java Project<br />
*Haken weg bei "Use Default Location"<br />
*"Browse" klicken und den Ordner "javaQ1Q2" suchen.<br />
**Evtl. liegt dieser Ordner in einem übergeordneten Ordner "javaQ1Q2".<br/>Dann den "inneren" der beiden Ordner wählen.<br />
*"Finish" klicken<br />
<br />
'''Jetzt die notwendigen Bibliotheken einbauen:'''<br />
<br />
*'''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen<br />
*in einen geeigneten Ordner extrahieren (z.B. Informatik)<br />
* in Eclipse:<br />
** Das Projekt java_Q1Q2 auswählen<br />
** Project -> Properties -> Java Build Path -> Libraries<br />
** "Add External JARs" klicken<br />
** alle JAR-Files aus dem Ordner "Jung" auswählen.<br />
** nochmal "Add External JARs" klicken<br />
** im Order DB-java-connector die Datei "mysql-connector-java-5.0.8-bin.jar" auswählen.<br />
<br />
==Von GitHub beziehen==<br />
Man kann das Projekt javaQ1Q2 auch von GitHub beziehen. Dort findet sich die aktuelleste Version des Projektes:<br />
<br />
'''[https://github.com/akaibel/javaQ1Q2 https://github.com/akaibel/javaQ1Q2]'''<br />
<br />
So bekommt man es in Eclipse:<br />
# Copy the GitHub URL of the repository to the clipboard.<br />
# Open Eclipse and choose File -> Import –> Git -> Projects from Git<br />
# Choose the Clone URI option in the Git import wizard and click Next.<br />
# Confirm the URI, Host and Repository path parameters and click Next.<br />
# In "local destination" choose the directory, where the project should go to.<br />
<br />
=Download und Öffnen in BlueJ=<br />
* '''[[Datei:Java Q1Q2.zip]]'''<br />
* in einen geeigneten Ordner extrahieren (z.B. "Informatik")<br />
* In BlueJ:<br />
** Project -> Open Non BlueJ bzw. <br/>Projekt -> Fremdprojekt öffnen<br />
** Den Ordner "java-Q1Q2-202021" suchen.<br />
*** Evtl. liegt dieser Ordner im Ordner "java-Q1Q2-202021-2020-07-28".<br />
* '''Jetzt noch die notwendigen Libraries laden:'''<br />
** '''[[Datei:ECLIPSE-LIBRARIES.zip]]''' runterladen und entzippen.<br />
<br />
** Tools -> Preferences -> Libraries -> Add bzw.<br/>Werkzeuge -> Einstellungen -> Bibliotheken -> Hinzufügen<br />
<br />
** Den Ordner ECLIPSE_LIBRARIES suchen.<br />
** In diesem Ordner jede jar-Datei einzeln durch Anklicken hinzufügen (=etwas mühsam...)<br />
* Abschließend mit STRG+UMSCHALT+R die Virtuelle Maschine neu starten.<br />
* Testen: Im Package _test die Klasse Graphtest: <br/>rechte Maustaste -> main ausführen.</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik_Fachbegriffe&diff=3645Informatik Fachbegriffe2024-01-14T16:06:13Z<p>Akaibel: /* Operatoren */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
<br />
Hier werden die wesentlichen Fachbegriffe zusammengestellt, die für das Informatik-Abitur relevant sind.<br />
<br />
''Kursiv sind "interne" Begriffe, die anschaulich sind, aber keine echten Fachbegriffe.''<br />
=Operatoren=<br />
Die Operatoren definieren, was genau man in einer Aufgabe zu machen hat. Anders als in Mathe sind die Operatoren weitestgehend "intuitiv" verständlich - mit Ausnahme des Operators "Analysieren" (siehe unten).<br />
* '''Liste der Operatoren:'''<br/>analysieren, angeben, anwenden, begründen, beschreiben, bestimmen, beurteilen, darstellen, dokumentieren, entscheiden, entwerfen, entwickeln, erläutern, ermitteln, erweitern, implementieren, interpretieren, modellieren, modifizieren, Stellung nehmen, überführen, vergleichen, vervollständigen, zeigen<br />
* '''Vollständige Liste der Operatoren mit Erläuterungen:'''<br/>[https://www.standardsicherung.schulministerium.nrw.de/cms/zentralabitur-wbk/faecher/getfile.php?file=2282 Operatoren Informatik-Abitur (Standardsicherung NRW)]<br />
* '''Analysieren Sie ... '''.<br/>''Der Operator "Analysieren Sie..." heißt in Informatik nur so viel wie "Denken Sie nach über...". <br/>Das heißt: <font color='red'>Dazu muss man NICHTS aufschreiben!!</font><br/>Der Operator "Analysieren Sie..." steht immer zusammen mit einem anderen Operator - und für den muss man was tun.<br />
<br />
=Datenbanken=<br />
==Entity-Relationship-Modellierung==<br />
'''[[Entity-Relationship-Modell|zum Nachlesen hier klicken]]'''<br />
* Kardinalität<br />
* 1:n<br />
* n:m<br />
* Primärschlüssel<br />
* Attribut<br />
* Entitätsmenge<br />
* Entität (=ein Objekt einer Entitätsmenge)<br />
* Relation (=Beziehung)<br />
<br />
==relationales Datenmodell==<br />
'''[[Relationales Datenmodell|zum Nachlesen hier klicken]]'''<br />
* Tabelle<br />
* Relationenschema (damit meint das Zentralabitur eine Tabelle)<br />
* Datenbankschema (damit meint das Zentralabitur das ganze relationale Datenmodell)<br />
* Attribut<br />
* Primärschlüssel: <u>unterstrichen</u><br />
* Fremdschlüssel: ↑<br/>''...bezieht sich auf den Primärschlüssel der Tabelle ...''<br />
* kombinierter Primärschlüssel<br />
<br />
==Normalisierung==<br />
'''[[Normalisierung|zum Nachlesen hier klicken]]'''<br />
* atomar<br />
* nicht eindeutiger Primärschlüssel<br />
* funktional abhängig von einem Teil des Primärschlüssel (Verstoß gegen 2. NF)<br />
* funktional abhängig von einem Nicht-Schlüssel-Attribut (Verstoß gegen 3. NF)<br />
* Anomalien<br />
** Einfüge-Anomalie<br />
** Änderungs-Anomalie<br />
** Lösch-Anomalie<br />
** die können nach Normalisierung nicht mehr auftreten!<br />
<br />
==SQL==<br />
'''[[SQL|zum Nachlesen hier klicken]]'''<br />
* Kartesisches Produkt: "jede(r) mit jedem"<br />
* Abgleich zwischen Tabellen<br />
* Verknüpfen (Join) von zwei Tabellen, wobei ... mit ... abgeglichen wird.<br />
* ''"Drückeberger"'': <code>... LEFT JOIN ... WHERE ... IS NULL</code><br />
* Differenz: <code>NOT IN</code><br />
* Vereinigung: <code>UNION</code><br />
* selbstdefinierte Tabelle<br />
* Alias: <code>AS</code><br />
* zusammenfassen von Zeilen: <code>GROUP BY</code><br />
* sortieren nach: <code>ORDER BY</code><br />
<br />
==mit Java auf Datenbanken zugreifen==<br />
'''[[Java-SQL|zum Nachlesen hier klicken]]'''<br />
* DatabaseConnector<br />
* Query (=Abfrage)<br />
* Variablen (z.B. Parameter) im SQL-Statement<br />
* Zeilenzahl: <code>int zeilenZahl = queryResult.getRowCount();</code><br />
* Array (2-dim): <code>String[][] data = queryResult.getData();</code><br />
** durchlaufen:<br/><code>for(int i=0; i<data.length; i++){<br/>&nbsp;&nbsp;&nbsp;String name = data[i][0];<br/>&nbsp;&nbsp;&nbsp;String vorname = data[i][1];</code><br />
* In Zahl konvertieren: <code>int zahl = Integer.parseInt(data[i][0]);</code><br />
<br />
=Objektorientierte Modellierung und Programmierung=<br />
'''zum Nachlesen:'''<br />
* [[Klassen-_und_Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* [[Klasse|Klasse]]<br />
* [[Vererbung|Vererbung]]<br />
* [[Polymorphie|Polymorphie]]<br />
* [[Abstrakte Klasse|Abstrakte Klasse]]<br />
* [[Interface|Interface]]<br />
* [[Java_Basis-Sprachelemente|Java Basis Sprachelemente]], u.a. Bedingung, Schleife etc.<br />
* [[Array|Arrays]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Vererbung|Vererbung]]<br />
** erbt von <br />
** ist ein (gleichbedeutend mit "erbt von"!)<br />
** Super-Klasse<br />
** Sub-Klasse<br />
* [[Polymorphie|Polymorphie]]<br />
** polymorphe Methode<br />
* [[Abstrakte Klasse|Abstrakte Klasse]] (=Klasse mit mind. einer abstrakten Methode)<br />
* abstrakte Methode<br />
* [[Interface|Interface]]<br />
* [[Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* hat-Beziehung<br />
* Assoziation (=kennt-Beziehung)<br />
* Multiplizität<br />
* [[Klasse|Klasse]]<br />
** Objekt (Von einer Klasse kann man mehrere Objekte erzeugen.)<br />
** Attribut<br />
*** public / private<br />
** Konstruktor<br />
* [[Java_Basis-Sprachelemente#Methoden|Methode]]<br />
** Parameter<br />
** lokale Variable<br />
** Rückgabetyp<br />
** public / private<br />
* ContentType (z.B. für Listen kann man den ContentType angeben.)<br />
* [[Interface|Schnittstelle (interface, vgl. ComparableContent)]]<br />
* [[Struktogramm]]<br />
* Anweisung<br />
* Methodenaufruf<br />
* [[Java_Basis-Sprachelemente#Verzweigungen_(if-else)|Bedingung]]<br />
* [[Java_Basis-Sprachelemente#Schleifen_(while,_for,_do-while)|Schleife]]<br />
** Zählschleife (for)<br />
** bedingte Schleife (while)<br />
** mit Schleife ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
* [[Array|Arrays]]<br />
** Index<br />
** Wert<br />
** [[Array#Zweidimensionale_Arrays|zweidimensionales Array]], z.B.: <code> private int[][] einmalEinsTabelle;</code><br />
<br />
=Java-Programmierung mit linearen Datenstrukturen=<br />
'''zum Nachlesen:'''<br />
* [[Queue#Verwendung_von_Queues|Verwendung von Queues]]<br />
* [[Stack#Verwendung_von_Stacks|Verwendung von Stacks]]<br />
* [[List#Standardvorgehen_im_Umgang_mit_Listen|List: Standardvorgehen]]<br />
* [[Array#Ein_Array_mit_einer_for-Schleife_durchlaufen|Array: durchlaufen]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Laufzeit_von_Algorithmen|Laufzeit]]<br />
** O(log(n)): Suchen in einem [[Binärer Suchbaum|Binären Suchbaum]]<br />
** O(n): Suchen in einer unsortierten Liste<br />
** O(n*log(n)): Sortieren mit [[Quicksort|Quicksort]]<br />
** O(n<sup>2</sup>): Sortieren mit [[Bubblesort]], [[Insertionsort]], [[Selectionsort|Selectionsort]]<br />
* <u>statische</u> Datenstruktur (Array): <br/>''Man muss vorher angeben, wie viele Einträge das Array hat.''<br />
* <u>dynamische</u> Datenstrukturen: Stack, List, Queue (und auch BinaryTree, BinarySearchTree, Graph)<br/>''Dynamische Datenstrukturen können während der Laufzeit "wachsen" und "schrumpfen".''<br />
* [[Queue|Queue]]: Schlange (vorne - hinten)<br />
** vorderstes Element: <code>pQueue.front()</code><br />
** anhängen: <code>pQueue.enqueue(...)</code> <br />
** vorderstes Element entfernen: <code>pQueue.dequeue()</code><br />
** ist leer: <code>pQueue.isEmpty()</code><br />
** Hilfs-Queue: z.B. um einen Queue zu durchlaufen, ohne ihn zu zustören<br />
* [[Stack|Stack]]: Stapel (oben)<br />
** oberstes Element: <code>pStack.top()</code><br />
** oben drauflegen: <code>pStack.push(...)</code> <br />
** oberstes Element entfernen: <code>pStack.pop()</code><br />
** ist leer: <code>pStack.isEmpty()</code><br />
** Hilfs-Stack: z.B. um einen Stack zu durchlaufen, ohne ihn zu zustören<br />
* [[List|List]]: Liste.<br/>''Listen kann man einfach durchlaufen und irgendwo einfügen.''<br />
** anhängen: <code>pList.append(...)</code><br />
** einfügen vor dem aktuellen Element: <code>pList.insert(...);</code><br />
* [[Array|Array]]: <br/>''statische Datenstruktur - man muss die Anzahl der Elemente vorher festlegen.''<br />
* durchlaufen (Liste, Array)<br />
** ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
** eine Liste durchlaufen: <code>for(pList.toFirst(); pList.hasAccess(); pList.next())</code><br />
* aktuelles Element:<br />
** Array: <code>array[i];</code><br />
** Liste: <code>pList.getContent();</code><br />
* erzeugen<br />
** erzeugen eines Objektes: <code>Person p = '''new''' Person("Mustermann", "Max");</code><br />
** erzeugen einer Liste: <code>List<Person> ergebnisListe = '''new''' List<>();</code><br />
** erzeugen eines Arrays: <br/>z.B. <code>Person[] einwohner = '''new''' int[1000];</code><br/>''Vorsicht! In jedem der 1000 Werte steht <code>null</code>!''<br />
** erzeugen eines zweidimensionalen Arrays: <code>int[][] einmalEinsTabelle = new int[10][10];</code><br />
* Schleife<br />
** Schleife verlassen: <code>break;</code><br />
** Schleife beim nächsten Element fortsetzen: <code>continue;</code><br />
* Methode verlassen <code>return;</code><br />
* zurückgeben: <code>return ergebnis;</code><br />
* ausgeben: <code>System.out.println("Hallo");</code><br />
<br />
=Sortierverfahren=<br />
* [[Bubblesort]] <u>nur für Arrays!</u>, Laufzeit O(n<sup>2</sup>)<br />
* [[Insertionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* [[Selectionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* nur LK: [[Quicksort]] für Listen, Laufzeit O(n*log(n)) im Average Case<br />
* Sortieren mit einem [[Binärer Suchbaum|Binären Suchbaum ]]<br/>- Der Reihe nach in den Binären Suchbaum einfügen<br/>- Inorder-Traversierung<br/>Laufzeit O(n*log(n)) im Average Case<br />
<br />
=Binärbäume und binäre Suchbäume=<br />
* Rahmenmethode<br />
* rekursive Methode<br />
* Abbruchbedingung<br />
* ''Wurzelbehandlung''<br />
* ''Sachlogik''<br />
* rekursive Aufrufe<br />
* Traversierung<br />
* Preorder<br />
* Inorder (=im Suchbaum: Sortierte Ausgabe!)<br />
* Levelorder (nur LK)<br />
* Baumliste für Levelorder (nur LK)<br />
* ComparableContent<br />
* implementiert die Schnittstelle (ComparableContent)<br />
* ''Dummy'': zum Suchen in Suchbäumen.<br />
<br />
=Automaten und Grammatiken=<br />
'''zum Nachlesen:'''<br/><br />
[https://sibiwiki.de/wiki/index.php?title=Kategorie:Endliche_Automaten Kategorie endliche Automaten]<br />
<br/>''Da gibt es Links zu allen Unterüberschriften.''<br />
==endliche Automaten==<br />
* [[Deterministischer Endlicher Automat|Deterministischer endlicher Automat (DEA)]]<br />
** A, Z, d, Q<sub>0</sub>, E: ''allen Zuhörern doofen Quatsch erzählen''<br />
* Der DEA '''erkennt''' eine reguläre Sprache<br />
* Der DEA '''überprüft''' ein Wort, ob es zur Sprache gehört.<br />
* [[Nicht-deterministischer endlicher Automaten|Nicht-deterministischer endlicher Automat (NEA)]]<br />
** ''"es gibt einen Weg"''<br />
* Zustand<br />
**Anfangszustand<br />
**Endzustände<br />
* Übergang<br />
* Alphabet<br />
* Zustands-Übergangs-Graph<br />
* Zustands-Übergangs-Tabelle<br />
* Zustandsfolge<br />
** für einen NEA ggf. mit geschweifter Klammer mehrere Zustände zusammenfassen.<br />
* Senke (=ein Zustand, aus dem es keinen Ausweg mehr gibt)<br />
* [[Potenzmengenkonstruktion|Potenzmengenkonstruktion]]<br />
** Potenzmenge (=eine Menge von Zuständen)<br />
<br />
==[[Reguläre Grammatik|reguläre Grammatik]]==<br />
* G = {N, T, S, P} ''Nerds testen Sonys Playstation''<br />
* linkslineare Grammatik: Nicht-Terminal links<br />
* rechtslineare Grammatik: Nicht-Terminal rechts<br />
** <i>linkslineare und rechtslineare Regeln nicht mischen!!!<br/>z.B.: <code>S → aS | Sb</code><br/>ist nicht regulär!!!</i><br />
* Terminal-Symbol<br />
* Nicht-Terminal-Symbol<br />
**Startsymbol<br />
* Produktionsregeln<br />
* Produktion eines Wortes<br />
* die RG erzeugt eine (reguläre) Sprache<br />
<br />
==[[Kellerautomat|Kellerautomaten (nur LK)]]==<br />
* Keller-Alphabet<br />
* Keller-Zeichen<br />
* Epsilon (ε): Um den Endzustand zu erreichen, darf man das Zeichen ε (="nichts") schreiben.<br />
<br />
==[[Kontextfreie_Grammatik|kontextfreie Grammatik (nur LK)]]==<br />
* lässt sich durch Kellerautomaten prüfen<br />
<br />
==Parser==<br />
* [[Parser|Parser für DEA]]<br />
* [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomaten (nur LK)]]<br />
** Keller (=<code>Stack</code>)<br />
<br />
=[[Graph|Graph (nur LK!)]]=<br />
* Knoten<br />
* Kante<br />
* markieren (Knoten oder Kante)<br />
* Markierung aufheben<br />
* Gewicht<br />
* Traversierung (d.h. Breitendurchlauf oder Tiefendurchlauf)<br />
* [[Graph#Tiefendurchlauf|Tiefendurchlauf]]<br />
** rekursiv<br />
* [[Graph#Breitendurchlauf|Breitendurchlauf]]<br />
** Knotenliste<br />
* [[Dijkstra-Algorithmus|Dijkstra-Algorithmus]]<br />
* rote Liste (für Dijkstra-Algo)<br />
* gelbe Liste (für Dijkstra-Algo)<br />
<br />
=[[Datenschutz|Datenschutz]]=<br />
Schutz von Angaben, aus denen man einen bestimmten Menschen erkennen kann oder die einem bestimmten Menschen zugeordnet werden können. <br />
<br />
'''Prinzipien des Datenschutzes:'''<br />
* <u>Verbot mit Erlaubnisvorbehalt</u><br />
* Datenminimierung<br />
* Zweckbindung<br />
* Transparenz<br />
* <u>Erforderlichkeit</u><br />
<br />
=[[Backtracking|Backtracking (nur LK!)]]=<br />
* Stufe<br />
* Teillösungsschritt<br />
* Abbruchbedingung<br />
** Lösung erreicht<br />
** Lösung nicht mehr erreichbar<br />
** maximale Stufenzahl überschritten<br />
* rückgängig machen</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik_Fachbegriffe&diff=3644Informatik Fachbegriffe2024-01-14T16:05:47Z<p>Akaibel: /* Operatoren */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
<br />
Hier werden die wesentlichen Fachbegriffe zusammengestellt, die für das Informatik-Abitur relevant sind.<br />
<br />
''Kursiv sind "interne" Begriffe, die anschaulich sind, aber keine echten Fachbegriffe.''<br />
=Operatoren=<br />
Die Operatoren definieren, was genau man in einer Aufgabe zu machen hat. Anders als in Mathe sind die Operatoren weitestgehend "intuitiv" verständlich - mit Ausnahme des Operators "Analysieren" (siehe unten).<br />
* Liste der Operatoren:<br/>analysieren, angeben, anwenden, begründen, beschreiben, bestimmen, beurteilen, darstellen, dokumentieren, entscheiden, entwerfen, entwickeln, erläutern, ermitteln, erweitern, implementieren, interpretieren, modellieren, modifizieren, Stellung nehmen, überführen, vergleichen, vervollständigen, zeigen<br />
* Vollständige Liste der Operatoren mit Erläuterungen:<br/>[https://www.standardsicherung.schulministerium.nrw.de/cms/zentralabitur-wbk/faecher/getfile.php?file=2282 Operatoren Informatik-Abitur (Standardsicherung NRW)]<br />
* '''Analysieren Sie ... '''.<br/>''Der Operator "Analysieren Sie..." heißt in Informatik nur so viel wie "Denken Sie nach über...". <br/>Das heißt: <font color='red'>Dazu muss man NICHTS aufschreiben!!</font><br/>Der Operator "Analysieren Sie..." steht immer zusammen mit einem anderen Operator - und für den muss man was tun.<br />
<br />
=Datenbanken=<br />
==Entity-Relationship-Modellierung==<br />
'''[[Entity-Relationship-Modell|zum Nachlesen hier klicken]]'''<br />
* Kardinalität<br />
* 1:n<br />
* n:m<br />
* Primärschlüssel<br />
* Attribut<br />
* Entitätsmenge<br />
* Entität (=ein Objekt einer Entitätsmenge)<br />
* Relation (=Beziehung)<br />
<br />
==relationales Datenmodell==<br />
'''[[Relationales Datenmodell|zum Nachlesen hier klicken]]'''<br />
* Tabelle<br />
* Relationenschema (damit meint das Zentralabitur eine Tabelle)<br />
* Datenbankschema (damit meint das Zentralabitur das ganze relationale Datenmodell)<br />
* Attribut<br />
* Primärschlüssel: <u>unterstrichen</u><br />
* Fremdschlüssel: ↑<br/>''...bezieht sich auf den Primärschlüssel der Tabelle ...''<br />
* kombinierter Primärschlüssel<br />
<br />
==Normalisierung==<br />
'''[[Normalisierung|zum Nachlesen hier klicken]]'''<br />
* atomar<br />
* nicht eindeutiger Primärschlüssel<br />
* funktional abhängig von einem Teil des Primärschlüssel (Verstoß gegen 2. NF)<br />
* funktional abhängig von einem Nicht-Schlüssel-Attribut (Verstoß gegen 3. NF)<br />
* Anomalien<br />
** Einfüge-Anomalie<br />
** Änderungs-Anomalie<br />
** Lösch-Anomalie<br />
** die können nach Normalisierung nicht mehr auftreten!<br />
<br />
==SQL==<br />
'''[[SQL|zum Nachlesen hier klicken]]'''<br />
* Kartesisches Produkt: "jede(r) mit jedem"<br />
* Abgleich zwischen Tabellen<br />
* Verknüpfen (Join) von zwei Tabellen, wobei ... mit ... abgeglichen wird.<br />
* ''"Drückeberger"'': <code>... LEFT JOIN ... WHERE ... IS NULL</code><br />
* Differenz: <code>NOT IN</code><br />
* Vereinigung: <code>UNION</code><br />
* selbstdefinierte Tabelle<br />
* Alias: <code>AS</code><br />
* zusammenfassen von Zeilen: <code>GROUP BY</code><br />
* sortieren nach: <code>ORDER BY</code><br />
<br />
==mit Java auf Datenbanken zugreifen==<br />
'''[[Java-SQL|zum Nachlesen hier klicken]]'''<br />
* DatabaseConnector<br />
* Query (=Abfrage)<br />
* Variablen (z.B. Parameter) im SQL-Statement<br />
* Zeilenzahl: <code>int zeilenZahl = queryResult.getRowCount();</code><br />
* Array (2-dim): <code>String[][] data = queryResult.getData();</code><br />
** durchlaufen:<br/><code>for(int i=0; i<data.length; i++){<br/>&nbsp;&nbsp;&nbsp;String name = data[i][0];<br/>&nbsp;&nbsp;&nbsp;String vorname = data[i][1];</code><br />
* In Zahl konvertieren: <code>int zahl = Integer.parseInt(data[i][0]);</code><br />
<br />
=Objektorientierte Modellierung und Programmierung=<br />
'''zum Nachlesen:'''<br />
* [[Klassen-_und_Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* [[Klasse|Klasse]]<br />
* [[Vererbung|Vererbung]]<br />
* [[Polymorphie|Polymorphie]]<br />
* [[Abstrakte Klasse|Abstrakte Klasse]]<br />
* [[Interface|Interface]]<br />
* [[Java_Basis-Sprachelemente|Java Basis Sprachelemente]], u.a. Bedingung, Schleife etc.<br />
* [[Array|Arrays]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Vererbung|Vererbung]]<br />
** erbt von <br />
** ist ein (gleichbedeutend mit "erbt von"!)<br />
** Super-Klasse<br />
** Sub-Klasse<br />
* [[Polymorphie|Polymorphie]]<br />
** polymorphe Methode<br />
* [[Abstrakte Klasse|Abstrakte Klasse]] (=Klasse mit mind. einer abstrakten Methode)<br />
* abstrakte Methode<br />
* [[Interface|Interface]]<br />
* [[Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* hat-Beziehung<br />
* Assoziation (=kennt-Beziehung)<br />
* Multiplizität<br />
* [[Klasse|Klasse]]<br />
** Objekt (Von einer Klasse kann man mehrere Objekte erzeugen.)<br />
** Attribut<br />
*** public / private<br />
** Konstruktor<br />
* [[Java_Basis-Sprachelemente#Methoden|Methode]]<br />
** Parameter<br />
** lokale Variable<br />
** Rückgabetyp<br />
** public / private<br />
* ContentType (z.B. für Listen kann man den ContentType angeben.)<br />
* [[Interface|Schnittstelle (interface, vgl. ComparableContent)]]<br />
* [[Struktogramm]]<br />
* Anweisung<br />
* Methodenaufruf<br />
* [[Java_Basis-Sprachelemente#Verzweigungen_(if-else)|Bedingung]]<br />
* [[Java_Basis-Sprachelemente#Schleifen_(while,_for,_do-while)|Schleife]]<br />
** Zählschleife (for)<br />
** bedingte Schleife (while)<br />
** mit Schleife ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
* [[Array|Arrays]]<br />
** Index<br />
** Wert<br />
** [[Array#Zweidimensionale_Arrays|zweidimensionales Array]], z.B.: <code> private int[][] einmalEinsTabelle;</code><br />
<br />
=Java-Programmierung mit linearen Datenstrukturen=<br />
'''zum Nachlesen:'''<br />
* [[Queue#Verwendung_von_Queues|Verwendung von Queues]]<br />
* [[Stack#Verwendung_von_Stacks|Verwendung von Stacks]]<br />
* [[List#Standardvorgehen_im_Umgang_mit_Listen|List: Standardvorgehen]]<br />
* [[Array#Ein_Array_mit_einer_for-Schleife_durchlaufen|Array: durchlaufen]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Laufzeit_von_Algorithmen|Laufzeit]]<br />
** O(log(n)): Suchen in einem [[Binärer Suchbaum|Binären Suchbaum]]<br />
** O(n): Suchen in einer unsortierten Liste<br />
** O(n*log(n)): Sortieren mit [[Quicksort|Quicksort]]<br />
** O(n<sup>2</sup>): Sortieren mit [[Bubblesort]], [[Insertionsort]], [[Selectionsort|Selectionsort]]<br />
* <u>statische</u> Datenstruktur (Array): <br/>''Man muss vorher angeben, wie viele Einträge das Array hat.''<br />
* <u>dynamische</u> Datenstrukturen: Stack, List, Queue (und auch BinaryTree, BinarySearchTree, Graph)<br/>''Dynamische Datenstrukturen können während der Laufzeit "wachsen" und "schrumpfen".''<br />
* [[Queue|Queue]]: Schlange (vorne - hinten)<br />
** vorderstes Element: <code>pQueue.front()</code><br />
** anhängen: <code>pQueue.enqueue(...)</code> <br />
** vorderstes Element entfernen: <code>pQueue.dequeue()</code><br />
** ist leer: <code>pQueue.isEmpty()</code><br />
** Hilfs-Queue: z.B. um einen Queue zu durchlaufen, ohne ihn zu zustören<br />
* [[Stack|Stack]]: Stapel (oben)<br />
** oberstes Element: <code>pStack.top()</code><br />
** oben drauflegen: <code>pStack.push(...)</code> <br />
** oberstes Element entfernen: <code>pStack.pop()</code><br />
** ist leer: <code>pStack.isEmpty()</code><br />
** Hilfs-Stack: z.B. um einen Stack zu durchlaufen, ohne ihn zu zustören<br />
* [[List|List]]: Liste.<br/>''Listen kann man einfach durchlaufen und irgendwo einfügen.''<br />
** anhängen: <code>pList.append(...)</code><br />
** einfügen vor dem aktuellen Element: <code>pList.insert(...);</code><br />
* [[Array|Array]]: <br/>''statische Datenstruktur - man muss die Anzahl der Elemente vorher festlegen.''<br />
* durchlaufen (Liste, Array)<br />
** ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
** eine Liste durchlaufen: <code>for(pList.toFirst(); pList.hasAccess(); pList.next())</code><br />
* aktuelles Element:<br />
** Array: <code>array[i];</code><br />
** Liste: <code>pList.getContent();</code><br />
* erzeugen<br />
** erzeugen eines Objektes: <code>Person p = '''new''' Person("Mustermann", "Max");</code><br />
** erzeugen einer Liste: <code>List<Person> ergebnisListe = '''new''' List<>();</code><br />
** erzeugen eines Arrays: <br/>z.B. <code>Person[] einwohner = '''new''' int[1000];</code><br/>''Vorsicht! In jedem der 1000 Werte steht <code>null</code>!''<br />
** erzeugen eines zweidimensionalen Arrays: <code>int[][] einmalEinsTabelle = new int[10][10];</code><br />
* Schleife<br />
** Schleife verlassen: <code>break;</code><br />
** Schleife beim nächsten Element fortsetzen: <code>continue;</code><br />
* Methode verlassen <code>return;</code><br />
* zurückgeben: <code>return ergebnis;</code><br />
* ausgeben: <code>System.out.println("Hallo");</code><br />
<br />
=Sortierverfahren=<br />
* [[Bubblesort]] <u>nur für Arrays!</u>, Laufzeit O(n<sup>2</sup>)<br />
* [[Insertionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* [[Selectionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* nur LK: [[Quicksort]] für Listen, Laufzeit O(n*log(n)) im Average Case<br />
* Sortieren mit einem [[Binärer Suchbaum|Binären Suchbaum ]]<br/>- Der Reihe nach in den Binären Suchbaum einfügen<br/>- Inorder-Traversierung<br/>Laufzeit O(n*log(n)) im Average Case<br />
<br />
=Binärbäume und binäre Suchbäume=<br />
* Rahmenmethode<br />
* rekursive Methode<br />
* Abbruchbedingung<br />
* ''Wurzelbehandlung''<br />
* ''Sachlogik''<br />
* rekursive Aufrufe<br />
* Traversierung<br />
* Preorder<br />
* Inorder (=im Suchbaum: Sortierte Ausgabe!)<br />
* Levelorder (nur LK)<br />
* Baumliste für Levelorder (nur LK)<br />
* ComparableContent<br />
* implementiert die Schnittstelle (ComparableContent)<br />
* ''Dummy'': zum Suchen in Suchbäumen.<br />
<br />
=Automaten und Grammatiken=<br />
'''zum Nachlesen:'''<br/><br />
[https://sibiwiki.de/wiki/index.php?title=Kategorie:Endliche_Automaten Kategorie endliche Automaten]<br />
<br/>''Da gibt es Links zu allen Unterüberschriften.''<br />
==endliche Automaten==<br />
* [[Deterministischer Endlicher Automat|Deterministischer endlicher Automat (DEA)]]<br />
** A, Z, d, Q<sub>0</sub>, E: ''allen Zuhörern doofen Quatsch erzählen''<br />
* Der DEA '''erkennt''' eine reguläre Sprache<br />
* Der DEA '''überprüft''' ein Wort, ob es zur Sprache gehört.<br />
* [[Nicht-deterministischer endlicher Automaten|Nicht-deterministischer endlicher Automat (NEA)]]<br />
** ''"es gibt einen Weg"''<br />
* Zustand<br />
**Anfangszustand<br />
**Endzustände<br />
* Übergang<br />
* Alphabet<br />
* Zustands-Übergangs-Graph<br />
* Zustands-Übergangs-Tabelle<br />
* Zustandsfolge<br />
** für einen NEA ggf. mit geschweifter Klammer mehrere Zustände zusammenfassen.<br />
* Senke (=ein Zustand, aus dem es keinen Ausweg mehr gibt)<br />
* [[Potenzmengenkonstruktion|Potenzmengenkonstruktion]]<br />
** Potenzmenge (=eine Menge von Zuständen)<br />
<br />
==[[Reguläre Grammatik|reguläre Grammatik]]==<br />
* G = {N, T, S, P} ''Nerds testen Sonys Playstation''<br />
* linkslineare Grammatik: Nicht-Terminal links<br />
* rechtslineare Grammatik: Nicht-Terminal rechts<br />
** <i>linkslineare und rechtslineare Regeln nicht mischen!!!<br/>z.B.: <code>S → aS | Sb</code><br/>ist nicht regulär!!!</i><br />
* Terminal-Symbol<br />
* Nicht-Terminal-Symbol<br />
**Startsymbol<br />
* Produktionsregeln<br />
* Produktion eines Wortes<br />
* die RG erzeugt eine (reguläre) Sprache<br />
<br />
==[[Kellerautomat|Kellerautomaten (nur LK)]]==<br />
* Keller-Alphabet<br />
* Keller-Zeichen<br />
* Epsilon (ε): Um den Endzustand zu erreichen, darf man das Zeichen ε (="nichts") schreiben.<br />
<br />
==[[Kontextfreie_Grammatik|kontextfreie Grammatik (nur LK)]]==<br />
* lässt sich durch Kellerautomaten prüfen<br />
<br />
==Parser==<br />
* [[Parser|Parser für DEA]]<br />
* [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomaten (nur LK)]]<br />
** Keller (=<code>Stack</code>)<br />
<br />
=[[Graph|Graph (nur LK!)]]=<br />
* Knoten<br />
* Kante<br />
* markieren (Knoten oder Kante)<br />
* Markierung aufheben<br />
* Gewicht<br />
* Traversierung (d.h. Breitendurchlauf oder Tiefendurchlauf)<br />
* [[Graph#Tiefendurchlauf|Tiefendurchlauf]]<br />
** rekursiv<br />
* [[Graph#Breitendurchlauf|Breitendurchlauf]]<br />
** Knotenliste<br />
* [[Dijkstra-Algorithmus|Dijkstra-Algorithmus]]<br />
* rote Liste (für Dijkstra-Algo)<br />
* gelbe Liste (für Dijkstra-Algo)<br />
<br />
=[[Datenschutz|Datenschutz]]=<br />
Schutz von Angaben, aus denen man einen bestimmten Menschen erkennen kann oder die einem bestimmten Menschen zugeordnet werden können. <br />
<br />
'''Prinzipien des Datenschutzes:'''<br />
* <u>Verbot mit Erlaubnisvorbehalt</u><br />
* Datenminimierung<br />
* Zweckbindung<br />
* Transparenz<br />
* <u>Erforderlichkeit</u><br />
<br />
=[[Backtracking|Backtracking (nur LK!)]]=<br />
* Stufe<br />
* Teillösungsschritt<br />
* Abbruchbedingung<br />
** Lösung erreicht<br />
** Lösung nicht mehr erreichbar<br />
** maximale Stufenzahl überschritten<br />
* rückgängig machen</div>Akaibelhttps://sibiwiki.de/wiki/index.php?title=Informatik_Fachbegriffe&diff=3643Informatik Fachbegriffe2024-01-14T16:00:25Z<p>Akaibel: /* zu den Operatoren */</p>
<hr />
<div>[[Kategorie:Informatik-Abitur]]<br />
<br />
Hier werden die wesentlichen Fachbegriffe zusammengestellt, die für das Informatik-Abitur relevant sind.<br />
<br />
''Kursiv sind "interne" Begriffe, die anschaulich sind, aber keine echten Fachbegriffe.''<br />
=Operatoren=<br />
* Vollständige Liste der Operatoren: <br/>[https://www.standardsicherung.schulministerium.nrw.de/cms/zentralabitur-wbk/faecher/getfile.php?file=2282 Operatoren Informatik-Abitur (Standardsicherung NRW)]<br />
* '''Analysieren Sie ... '''.<br/>''Der Operator "Analysieren Sie..." heißt in Informatik nur so viel wie "Denken Sie nach über...". <br/>Das heißt: <font color='red'>Dazu muss man NICHTS aufschreiben!!</font><br/>Der Operator "Analysieren Sie..." steht immer zusammen mit einem anderen Operator - und für den muss man was tun.<br />
<br />
=Datenbanken=<br />
==Entity-Relationship-Modellierung==<br />
'''[[Entity-Relationship-Modell|zum Nachlesen hier klicken]]'''<br />
* Kardinalität<br />
* 1:n<br />
* n:m<br />
* Primärschlüssel<br />
* Attribut<br />
* Entitätsmenge<br />
* Entität (=ein Objekt einer Entitätsmenge)<br />
* Relation (=Beziehung)<br />
<br />
==relationales Datenmodell==<br />
'''[[Relationales Datenmodell|zum Nachlesen hier klicken]]'''<br />
* Tabelle<br />
* Relationenschema (damit meint das Zentralabitur eine Tabelle)<br />
* Datenbankschema (damit meint das Zentralabitur das ganze relationale Datenmodell)<br />
* Attribut<br />
* Primärschlüssel: <u>unterstrichen</u><br />
* Fremdschlüssel: ↑<br/>''...bezieht sich auf den Primärschlüssel der Tabelle ...''<br />
* kombinierter Primärschlüssel<br />
<br />
==Normalisierung==<br />
'''[[Normalisierung|zum Nachlesen hier klicken]]'''<br />
* atomar<br />
* nicht eindeutiger Primärschlüssel<br />
* funktional abhängig von einem Teil des Primärschlüssel (Verstoß gegen 2. NF)<br />
* funktional abhängig von einem Nicht-Schlüssel-Attribut (Verstoß gegen 3. NF)<br />
* Anomalien<br />
** Einfüge-Anomalie<br />
** Änderungs-Anomalie<br />
** Lösch-Anomalie<br />
** die können nach Normalisierung nicht mehr auftreten!<br />
<br />
==SQL==<br />
'''[[SQL|zum Nachlesen hier klicken]]'''<br />
* Kartesisches Produkt: "jede(r) mit jedem"<br />
* Abgleich zwischen Tabellen<br />
* Verknüpfen (Join) von zwei Tabellen, wobei ... mit ... abgeglichen wird.<br />
* ''"Drückeberger"'': <code>... LEFT JOIN ... WHERE ... IS NULL</code><br />
* Differenz: <code>NOT IN</code><br />
* Vereinigung: <code>UNION</code><br />
* selbstdefinierte Tabelle<br />
* Alias: <code>AS</code><br />
* zusammenfassen von Zeilen: <code>GROUP BY</code><br />
* sortieren nach: <code>ORDER BY</code><br />
<br />
==mit Java auf Datenbanken zugreifen==<br />
'''[[Java-SQL|zum Nachlesen hier klicken]]'''<br />
* DatabaseConnector<br />
* Query (=Abfrage)<br />
* Variablen (z.B. Parameter) im SQL-Statement<br />
* Zeilenzahl: <code>int zeilenZahl = queryResult.getRowCount();</code><br />
* Array (2-dim): <code>String[][] data = queryResult.getData();</code><br />
** durchlaufen:<br/><code>for(int i=0; i<data.length; i++){<br/>&nbsp;&nbsp;&nbsp;String name = data[i][0];<br/>&nbsp;&nbsp;&nbsp;String vorname = data[i][1];</code><br />
* In Zahl konvertieren: <code>int zahl = Integer.parseInt(data[i][0]);</code><br />
<br />
=Objektorientierte Modellierung und Programmierung=<br />
'''zum Nachlesen:'''<br />
* [[Klassen-_und_Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* [[Klasse|Klasse]]<br />
* [[Vererbung|Vererbung]]<br />
* [[Polymorphie|Polymorphie]]<br />
* [[Abstrakte Klasse|Abstrakte Klasse]]<br />
* [[Interface|Interface]]<br />
* [[Java_Basis-Sprachelemente|Java Basis Sprachelemente]], u.a. Bedingung, Schleife etc.<br />
* [[Array|Arrays]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Vererbung|Vererbung]]<br />
** erbt von <br />
** ist ein (gleichbedeutend mit "erbt von"!)<br />
** Super-Klasse<br />
** Sub-Klasse<br />
* [[Polymorphie|Polymorphie]]<br />
** polymorphe Methode<br />
* [[Abstrakte Klasse|Abstrakte Klasse]] (=Klasse mit mind. einer abstrakten Methode)<br />
* abstrakte Methode<br />
* [[Interface|Interface]]<br />
* [[Implementationsdiagramm|Klassen- und Implementationsdiagramm]]<br />
* hat-Beziehung<br />
* Assoziation (=kennt-Beziehung)<br />
* Multiplizität<br />
* [[Klasse|Klasse]]<br />
** Objekt (Von einer Klasse kann man mehrere Objekte erzeugen.)<br />
** Attribut<br />
*** public / private<br />
** Konstruktor<br />
* [[Java_Basis-Sprachelemente#Methoden|Methode]]<br />
** Parameter<br />
** lokale Variable<br />
** Rückgabetyp<br />
** public / private<br />
* ContentType (z.B. für Listen kann man den ContentType angeben.)<br />
* [[Interface|Schnittstelle (interface, vgl. ComparableContent)]]<br />
* [[Struktogramm]]<br />
* Anweisung<br />
* Methodenaufruf<br />
* [[Java_Basis-Sprachelemente#Verzweigungen_(if-else)|Bedingung]]<br />
* [[Java_Basis-Sprachelemente#Schleifen_(while,_for,_do-while)|Schleife]]<br />
** Zählschleife (for)<br />
** bedingte Schleife (while)<br />
** mit Schleife ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
* [[Array|Arrays]]<br />
** Index<br />
** Wert<br />
** [[Array#Zweidimensionale_Arrays|zweidimensionales Array]], z.B.: <code> private int[][] einmalEinsTabelle;</code><br />
<br />
=Java-Programmierung mit linearen Datenstrukturen=<br />
'''zum Nachlesen:'''<br />
* [[Queue#Verwendung_von_Queues|Verwendung von Queues]]<br />
* [[Stack#Verwendung_von_Stacks|Verwendung von Stacks]]<br />
* [[List#Standardvorgehen_im_Umgang_mit_Listen|List: Standardvorgehen]]<br />
* [[Array#Ein_Array_mit_einer_for-Schleife_durchlaufen|Array: durchlaufen]]<br />
<br />
'''Fachbegriffe:'''<br />
* [[Laufzeit_von_Algorithmen|Laufzeit]]<br />
** O(log(n)): Suchen in einem [[Binärer Suchbaum|Binären Suchbaum]]<br />
** O(n): Suchen in einer unsortierten Liste<br />
** O(n*log(n)): Sortieren mit [[Quicksort|Quicksort]]<br />
** O(n<sup>2</sup>): Sortieren mit [[Bubblesort]], [[Insertionsort]], [[Selectionsort|Selectionsort]]<br />
* <u>statische</u> Datenstruktur (Array): <br/>''Man muss vorher angeben, wie viele Einträge das Array hat.''<br />
* <u>dynamische</u> Datenstrukturen: Stack, List, Queue (und auch BinaryTree, BinarySearchTree, Graph)<br/>''Dynamische Datenstrukturen können während der Laufzeit "wachsen" und "schrumpfen".''<br />
* [[Queue|Queue]]: Schlange (vorne - hinten)<br />
** vorderstes Element: <code>pQueue.front()</code><br />
** anhängen: <code>pQueue.enqueue(...)</code> <br />
** vorderstes Element entfernen: <code>pQueue.dequeue()</code><br />
** ist leer: <code>pQueue.isEmpty()</code><br />
** Hilfs-Queue: z.B. um einen Queue zu durchlaufen, ohne ihn zu zustören<br />
* [[Stack|Stack]]: Stapel (oben)<br />
** oberstes Element: <code>pStack.top()</code><br />
** oben drauflegen: <code>pStack.push(...)</code> <br />
** oberstes Element entfernen: <code>pStack.pop()</code><br />
** ist leer: <code>pStack.isEmpty()</code><br />
** Hilfs-Stack: z.B. um einen Stack zu durchlaufen, ohne ihn zu zustören<br />
* [[List|List]]: Liste.<br/>''Listen kann man einfach durchlaufen und irgendwo einfügen.''<br />
** anhängen: <code>pList.append(...)</code><br />
** einfügen vor dem aktuellen Element: <code>pList.insert(...);</code><br />
* [[Array|Array]]: <br/>''statische Datenstruktur - man muss die Anzahl der Elemente vorher festlegen.''<br />
* durchlaufen (Liste, Array)<br />
** ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code><br />
** eine Liste durchlaufen: <code>for(pList.toFirst(); pList.hasAccess(); pList.next())</code><br />
* aktuelles Element:<br />
** Array: <code>array[i];</code><br />
** Liste: <code>pList.getContent();</code><br />
* erzeugen<br />
** erzeugen eines Objektes: <code>Person p = '''new''' Person("Mustermann", "Max");</code><br />
** erzeugen einer Liste: <code>List<Person> ergebnisListe = '''new''' List<>();</code><br />
** erzeugen eines Arrays: <br/>z.B. <code>Person[] einwohner = '''new''' int[1000];</code><br/>''Vorsicht! In jedem der 1000 Werte steht <code>null</code>!''<br />
** erzeugen eines zweidimensionalen Arrays: <code>int[][] einmalEinsTabelle = new int[10][10];</code><br />
* Schleife<br />
** Schleife verlassen: <code>break;</code><br />
** Schleife beim nächsten Element fortsetzen: <code>continue;</code><br />
* Methode verlassen <code>return;</code><br />
* zurückgeben: <code>return ergebnis;</code><br />
* ausgeben: <code>System.out.println("Hallo");</code><br />
<br />
=Sortierverfahren=<br />
* [[Bubblesort]] <u>nur für Arrays!</u>, Laufzeit O(n<sup>2</sup>)<br />
* [[Insertionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* [[Selectionsort]] für Listen, Laufzeit O(n<sup>2</sup>)<br />
* nur LK: [[Quicksort]] für Listen, Laufzeit O(n*log(n)) im Average Case<br />
* Sortieren mit einem [[Binärer Suchbaum|Binären Suchbaum ]]<br/>- Der Reihe nach in den Binären Suchbaum einfügen<br/>- Inorder-Traversierung<br/>Laufzeit O(n*log(n)) im Average Case<br />
<br />
=Binärbäume und binäre Suchbäume=<br />
* Rahmenmethode<br />
* rekursive Methode<br />
* Abbruchbedingung<br />
* ''Wurzelbehandlung''<br />
* ''Sachlogik''<br />
* rekursive Aufrufe<br />
* Traversierung<br />
* Preorder<br />
* Inorder (=im Suchbaum: Sortierte Ausgabe!)<br />
* Levelorder (nur LK)<br />
* Baumliste für Levelorder (nur LK)<br />
* ComparableContent<br />
* implementiert die Schnittstelle (ComparableContent)<br />
* ''Dummy'': zum Suchen in Suchbäumen.<br />
<br />
=Automaten und Grammatiken=<br />
'''zum Nachlesen:'''<br/><br />
[https://sibiwiki.de/wiki/index.php?title=Kategorie:Endliche_Automaten Kategorie endliche Automaten]<br />
<br/>''Da gibt es Links zu allen Unterüberschriften.''<br />
==endliche Automaten==<br />
* [[Deterministischer Endlicher Automat|Deterministischer endlicher Automat (DEA)]]<br />
** A, Z, d, Q<sub>0</sub>, E: ''allen Zuhörern doofen Quatsch erzählen''<br />
* Der DEA '''erkennt''' eine reguläre Sprache<br />
* Der DEA '''überprüft''' ein Wort, ob es zur Sprache gehört.<br />
* [[Nicht-deterministischer endlicher Automaten|Nicht-deterministischer endlicher Automat (NEA)]]<br />
** ''"es gibt einen Weg"''<br />
* Zustand<br />
**Anfangszustand<br />
**Endzustände<br />
* Übergang<br />
* Alphabet<br />
* Zustands-Übergangs-Graph<br />
* Zustands-Übergangs-Tabelle<br />
* Zustandsfolge<br />
** für einen NEA ggf. mit geschweifter Klammer mehrere Zustände zusammenfassen.<br />
* Senke (=ein Zustand, aus dem es keinen Ausweg mehr gibt)<br />
* [[Potenzmengenkonstruktion|Potenzmengenkonstruktion]]<br />
** Potenzmenge (=eine Menge von Zuständen)<br />
<br />
==[[Reguläre Grammatik|reguläre Grammatik]]==<br />
* G = {N, T, S, P} ''Nerds testen Sonys Playstation''<br />
* linkslineare Grammatik: Nicht-Terminal links<br />
* rechtslineare Grammatik: Nicht-Terminal rechts<br />
** <i>linkslineare und rechtslineare Regeln nicht mischen!!!<br/>z.B.: <code>S → aS | Sb</code><br/>ist nicht regulär!!!</i><br />
* Terminal-Symbol<br />
* Nicht-Terminal-Symbol<br />
**Startsymbol<br />
* Produktionsregeln<br />
* Produktion eines Wortes<br />
* die RG erzeugt eine (reguläre) Sprache<br />
<br />
==[[Kellerautomat|Kellerautomaten (nur LK)]]==<br />
* Keller-Alphabet<br />
* Keller-Zeichen<br />
* Epsilon (ε): Um den Endzustand zu erreichen, darf man das Zeichen ε (="nichts") schreiben.<br />
<br />
==[[Kontextfreie_Grammatik|kontextfreie Grammatik (nur LK)]]==<br />
* lässt sich durch Kellerautomaten prüfen<br />
<br />
==Parser==<br />
* [[Parser|Parser für DEA]]<br />
* [[Kellerautomat#Parser_für_einen_Kellerautomaten|Parser für Kellerautomaten (nur LK)]]<br />
** Keller (=<code>Stack</code>)<br />
<br />
=[[Graph|Graph (nur LK!)]]=<br />
* Knoten<br />
* Kante<br />
* markieren (Knoten oder Kante)<br />
* Markierung aufheben<br />
* Gewicht<br />
* Traversierung (d.h. Breitendurchlauf oder Tiefendurchlauf)<br />
* [[Graph#Tiefendurchlauf|Tiefendurchlauf]]<br />
** rekursiv<br />
* [[Graph#Breitendurchlauf|Breitendurchlauf]]<br />
** Knotenliste<br />
* [[Dijkstra-Algorithmus|Dijkstra-Algorithmus]]<br />
* rote Liste (für Dijkstra-Algo)<br />
* gelbe Liste (für Dijkstra-Algo)<br />
<br />
=[[Datenschutz|Datenschutz]]=<br />
Schutz von Angaben, aus denen man einen bestimmten Menschen erkennen kann oder die einem bestimmten Menschen zugeordnet werden können. <br />
<br />
'''Prinzipien des Datenschutzes:'''<br />
* <u>Verbot mit Erlaubnisvorbehalt</u><br />
* Datenminimierung<br />
* Zweckbindung<br />
* Transparenz<br />
* <u>Erforderlichkeit</u><br />
<br />
=[[Backtracking|Backtracking (nur LK!)]]=<br />
* Stufe<br />
* Teillösungsschritt<br />
* Abbruchbedingung<br />
** Lösung erreicht<br />
** Lösung nicht mehr erreichbar<br />
** maximale Stufenzahl überschritten<br />
* rückgängig machen</div>Akaibel