Informatik Fachbegriffe: Unterschied zwischen den Versionen
Zur Navigation springen
Zur Suche springen
Zeile 113: | Zeile 113: | ||
=Java-Programmierung mit linearen Datenstrukturen= | =Java-Programmierung mit linearen Datenstrukturen= | ||
* Schlange (vorne - hinten): <code> | * <u>statische</u> Datenstruktur (Array): <br/>''Man muss vorher angeben, wie viele Einträge das Array hat.'' | ||
* Stapel (oben): <code> | * <u>dynamische</u> Datenstrukturen: Stack, List, Queue (und auch BinaryTree, BinarySearchTree, Graph)<br/>''Dynamische Datenstrukturen können während der Laufzeit "wachsen" und "schrumpfen".'' | ||
* | * [[Queue|Queue]]: Schlange (vorne - hinten) | ||
** vorderstes Element: <code>pQueue.front()</code> | |||
** anhängen: <code>pQueue.enqueue(...)</code> | |||
** vorderstes Element entfernen: <code>pQueue.dequeue()</code> | |||
** ist leer: <code>pQueue.isEmpty()</code> | |||
** Hilfs-Queue: z.B. um einen Queue zu durchlaufen, ohne ihn zu zustören | |||
* [[Stack|Stack]]: Stapel (oben) | |||
** oberstes Element: <code>pStack.top()</code> | |||
** oben drauflegen: <code>pStack.push(...)</code> | |||
** oberstes Element entfernen: <code>pStack.pop()</code> | |||
** ist leer: <code>pStack.isEmpty()</code> | |||
** Hilfs-Stack: z.B. um einen Stack zu durchlaufen, ohne ihn zu zustören | |||
* [[List|List]]: Liste.<br/>''Listen kann man einfach durchlaufen und irgendwo einfügen.'' | |||
** anhängen: <code>pList.append(...)</code> | ** anhängen: <code>pList.append(...)</code> | ||
** einfügen vor dem aktuellen Element: <code>pList.insert(...);</code> | ** einfügen vor dem aktuellen Element: <code>pList.insert(...);</code> | ||
* [[Array|Array]]: <br/>''statische Datenstruktur - man muss die Anzahl der Elemente vorher festlegen.'' | |||
* durchlaufen (Liste, Array) | * durchlaufen (Liste, Array) | ||
** ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code> | ** ein Array durchlaufen: <code>for(int i=0; i<array.length; i++)</code> | ||
Zeile 124: | Zeile 137: | ||
** Array: <code>array[i];</code> | ** Array: <code>array[i];</code> | ||
** Liste: <code>pList.getContent();</code> | ** Liste: <code>pList.getContent();</code> | ||
* | * erzeugen | ||
* | ** erzeugen eines Objektes: <code>Person p = '''new''' Person("Mustermann", "Max");</code> | ||
* erzeugen eines Objektes: <code>Person p = new Person("Mustermann", "Max");</code> | ** erzeugen einer Liste: <code>List<Person> ergebnisListe = '''new''' List<>();</code> | ||
* erzeugen eines Arrays: <code>int[] | ** erzeugen eines Arrays: <br/>z.B. <code>Person[] einwohner = '''new''' int[1000];</code><br/>''Vorsicht! In jedem der 1000 Werte steht <code>null</code>!'' | ||
** erzeugen eines zweidimensionalen Arrays: <code>int[][] einmalEinsTabelle = new int[10][10];</code> | |||
* Schleife | * Schleife | ||
* | ** Schleife verlassen: <code>break;</code> | ||
* Schleife verlassen: <code>break;</code> | ** Schleife beim nächsten Element fortsetzen: <code>continue;</code> | ||
* Schleife beim nächsten Element fortsetzen: <code>continue;</code> | |||
* Methode verlassen <code>return;</code> | * Methode verlassen <code>return;</code> | ||
* zurückgeben: <code>return ergebnis;</code> | * zurückgeben: <code>return ergebnis;</code> |
Version vom 14. Januar 2024, 13:03 Uhr
Hier werden die wesentlichen Fachbegriffe zusammengestellt, die für das Informatik-Abitur relevant sind.
Kursiv sind "interne" Begriffe, die anschaulich sind, aber keine echten Fachbegriffe.
Datenbanken
Entity-Relationship-Modellierung
- Kardinalität
- 1:n
- n:m
- Primärschlüssel
- Attribut
- Entitätsmenge
- Entität (=ein Objekt einer Entitätsmenge)
- Relation (=Beziehung)
relationales Datenmodell
- Tabelle
- Relationenschema (damit meint das Zentralabitur eine Tabelle)
- Datenbankschema (damit meint das Zentralabitur das ganze relationale Datenmodell)
- Attribut
- Primärschlüssel: unterstrichen
- Fremdschlüssel: ↑
...bezieht sich auf den Primärschlüssel der Tabelle ... - kombinierter Primärschlüssel
Normalisierung
- atomar
- nicht eindeutiger Primärschlüssel
- funktional abhängig von einem Teil des Primärschlüssel (Verstoß gegen 2. NF)
- funktional abhängig von einem Nicht-Schlüssel-Attribut (Verstoß gegen 3. NF)
- Anomalien
- Einfüge-Anomalie
- Änderungs-Anomalie
- Lösch-Anomalie
- die können nach Normalisierung nicht mehr auftreten!
SQL
- Kartesisches Produkt: "jede(r) mit jedem"
- Abgleich zwischen Tabellen
- Verknüpfen (Join) von zwei Tabellen, wobei ... mit ... abgeglichen wird.
- "Drückeberger":
... LEFT JOIN ... WHERE ... IS NULL
- Differenz:
NOT IN
- Vereinigung:
UNION
- selbstdefinierte Tabelle
- Alias:
AS
- zusammenfassen von Zeilen:
GROUP BY
- sortieren nach:
ORDER BY
mit Java auf Datenbanken zugreifen
- DatabaseConnector
- Query (=Abfrage)
- Variablen (z.B. Parameter) im SQL-Statement
- Zeilenzahl:
int zeilenZahl = queryResult.getRowCount();
- Array (2-dim):
String[][] data = queryResult.getData();
- durchlaufen:
for(int i=0; i<data.length; i++){
String name = data[i][0];
String vorname = data[i][1];
- durchlaufen:
- In Zahl konvertieren:
int zahl = Integer.parseInt(data[i][0]);
Objektorientierte Modellierung und Programmierung
zum Nachlesen:
- Klassen- und Implementationsdiagramm
- Klasse
- Vererbung
- Polymorphie
- Abstrakte Klasse
- Interface
- Java Basis Sprachelemente, u.a. Bedingung, Schleife etc.
- Arrays
Fachbegriffe:
- Vererbung
- erbt von
- ist ein (gleichbedeutend mit "erbt von"!)
- Super-Klasse
- Sub-Klasse
- Polymorphie
- polymorphe Methode
- Abstrakte Klasse (=Klasse mit mind. einer abstrakten Methode)
- abstrakte Methode
- Interface
- Klassen- und Implementationsdiagramm
- hat-Beziehung
- Assoziation (=kennt-Beziehung)
- Multiplizität
- Klasse
- Objekt (Von einer Klasse kann man mehrere Objekte erzeugen.)
- Attribut
- public / private
- Konstruktor
- Methode
- Parameter
- lokale Variable
- Rückgabetyp
- public / private
- ContentType (z.B. für Listen kann man den ContentType angeben.)
- Schnittstelle (interface, vgl. ComparableContent)
- Struktogramm
- Anweisung
- Methodenaufruf
- Bedingung
- Schleife
- Zählschleife (for)
- bedingte Schleife (while)
- mit Schleife ein Array durchlaufen:
for(int i=0; i<array.length; i++)
- Arrays
- Index
- Wert
- zweidimensionales Array, z.B.:
private int[][] einmalEinsTabelle;
Java-Programmierung mit linearen Datenstrukturen
- statische Datenstruktur (Array):
Man muss vorher angeben, wie viele Einträge das Array hat. - dynamische Datenstrukturen: Stack, List, Queue (und auch BinaryTree, BinarySearchTree, Graph)
Dynamische Datenstrukturen können während der Laufzeit "wachsen" und "schrumpfen". - Queue: Schlange (vorne - hinten)
- vorderstes Element:
pQueue.front()
- anhängen:
pQueue.enqueue(...)
- vorderstes Element entfernen:
pQueue.dequeue()
- ist leer:
pQueue.isEmpty()
- Hilfs-Queue: z.B. um einen Queue zu durchlaufen, ohne ihn zu zustören
- vorderstes Element:
- Stack: Stapel (oben)
- oberstes Element:
pStack.top()
- oben drauflegen:
pStack.push(...)
- oberstes Element entfernen:
pStack.pop()
- ist leer:
pStack.isEmpty()
- Hilfs-Stack: z.B. um einen Stack zu durchlaufen, ohne ihn zu zustören
- oberstes Element:
- List: Liste.
Listen kann man einfach durchlaufen und irgendwo einfügen.- anhängen:
pList.append(...)
- einfügen vor dem aktuellen Element:
pList.insert(...);
- anhängen:
- Array:
statische Datenstruktur - man muss die Anzahl der Elemente vorher festlegen. - durchlaufen (Liste, Array)
- ein Array durchlaufen:
for(int i=0; i<array.length; i++)
- eine Liste durchlaufen:
for(pList.toFirst(); pList.hasAccess(); pList.next())
- ein Array durchlaufen:
- aktuelles Element:
- Array:
array[i];
- Liste:
pList.getContent();
- Array:
- erzeugen
- erzeugen eines Objektes:
Person p = new Person("Mustermann", "Max");
- erzeugen einer Liste:
List<Person> ergebnisListe = new List<>();
- erzeugen eines Arrays:
z.B.Person[] einwohner = new int[1000];
Vorsicht! In jedem der 1000 Werte stehtnull
! - erzeugen eines zweidimensionalen Arrays:
int[][] einmalEinsTabelle = new int[10][10];
- erzeugen eines Objektes:
- Schleife
- Schleife verlassen:
break;
- Schleife beim nächsten Element fortsetzen:
continue;
- Schleife verlassen:
- Methode verlassen
return;
- zurückgeben:
return ergebnis;
- ausgeben:
System.out.println("Hallo");
Binärbäume und binäre Suchbäume
- Rahmenmethode
- rekursive Methode
- Abbruchbedingung
- Wurzelbehandlung
- Sachlogik
- rekursive Aufrufe
- Traversierung
- Preorder
- Inorder (=im Suchbaum: Sortierte Ausgabe!)
- Levelorder (nur LK)
- Baumliste für Levelorder (nur LK)
- ComparableContent
- implementiert die Schnittstelle (ComparableContent)
- Dummy: zum Suchen in Suchbäumen.
Automaten und Grammatiken
endliche Automaten
- Deterministischer endlicher Automat (DEA)
- A, Z, d, Q0, E: allen Zuhörern doofen Quatsch erzählen
- Der DEA erkennt eine reguläre Sprache
- Der DEA überprüft ein Wort, ob es zur Sprache gehört.
- Nicht-deterministischer endlicher Automat (NEA)
- "es gibt einen Weg"
- Zustand
- Anfangszustand
- Endzustände
- Übergang
- Epsilon (ε):
damit kann man den Endzustand erreichen. (Nur bei Keller-Automaten im LK.) - Alphabet
- Zustands-Übergangs-Graph
- Zustands-Übergangs-Tabelle
- Zustandsfolge
- für einen NEA ggf. mit geschweifter Klammer mehrere Zustände zusammenfassen.
- Senke (=ein Zustand, aus dem es keinen Ausweg mehr gibt)
- Potenzmengenkonstruktion
- Potenzmenge (=eine Menge von Zuständen)
reguläre Grammatik
- G = {N, T, S, P} Nerds testen Sonys Playstation
- linkslineare Grammatik: Nicht-Terminal links
- rechtslineare Grammatik: Nicht-Terminal rechts
- linkslineare und rechtslineare Regeln nicht mischen!!!
z.B.:S → aS | Sb
ist nicht regulär!!!
- linkslineare und rechtslineare Regeln nicht mischen!!!
- Terminal-Symbol
- Nicht-Terminal-Symbol
- Startsymbol
- Produktionsregeln
- Produktion eines Wortes
- die RG erzeugt eine (reguläre) Sprache
Kellerautomaten (nur LK)
- Keller-Alphabet
- Keller-Zeichen
kontextfreie Grammatik (nur LK)
- lässt sich durch Kellerautomaten prüfen
Parser
- für DEA
- mit switch-case:
switch(zustand){
case 1: ... - mit if-else if:
if(zustand == 1){
...
}
else if(zustand == 2){
...
}
else{
...
}
- mit switch-case:
- für Kellerautomaten (nur LK)
- Keller (=
Stack
)
- Keller (=
Graph (nur LK!)
- Knoten
- Kante
- markieren (Knoten oder Kante)
- Markierung aufheben
- Gewicht
- Traversierung
- Breitendurchlauf
- Tiefendurchlauf
- rekursiv (für Tiefendurchlauf)
- Knotenliste (für Breitendurchlauf)
- rote Liste (für Dijkstra-Algo)
- gelbe Liste (für Dijkstra-Algo)
Datenschutz
- Erlaubnisvorbehalt
- Erforderlichkeit
Backtracking (nur LK!)
- Stufe
- Teillösungsschritt
- Abbruchbedingung
- Lösung erreicht
- Lösung nicht mehr erreichbar
- maximale Stufenzahl überschritten
- rückgängig machen