Statische Finitheit -> Die Beschreibung des Algorithmus besitzt feste Länge

Dynamische Finitheit -> Die bei Abarbeitung entstehenden Zwischenergebnisse sind endlich.

Terminiertheit -> Das Ergebnis wird nach endlich vielen Schritten geliefert

Determiniertheit -> Gleiche Eingabedaten führen zu gleichem Ergebnis

Determinismus -> Der nächste anzuwendende Schritt ist stets eindeutig bestimmt

Definition: Ein abstrakter Datentyp (ADT) besteht aus einem Wertebereich (d.h. einer Menge von
Objekten) und darauf definierten Operationen. Die Menge der Operationen bezeichnet man auch als
Schnittstelle des Datentyps.

Definition: Eine Datenstruktur ist eine Realisierung bzw. Implementierung eines ADT mit den Mitteln
einer Programmiersprache (Variablen, Funktion, Schleifen, usw.).

-Java warnt nicht vor Überlauf/Unterlauf

-größtes int (2147483647) + 1 = kleinstes int (-2147483648) -> überlauf

-kleinstes int (-2147483648) - 1 = gröstes int (2147483647) -> unterlauf

-Überlauf/Unterlauf liefert die Werte POSITIVE_INFINITY bzw. NEGATIVE_INFINITY bei den 2

Gleitkomma-Zahlen float und double.

-Gleitkomma-Konstanten im Programm werden automatisch als double aufgefasst. Zur

Unterscheidung kann man an die Zahl f (oder F) bzw. d (oder D) anhängen.

-Das Ergebnis einer Operation auf float kann aus dem Bereich von float herausführen. Dann ergibt
sich der Wert Infinity oder -Infinity. Das gleiche gilt für double.

-Wird der Operator “+” auf einen Wert vom Typ String und einen anderen Wert x angewendet, wird x
automatisch in seine String-Darstellung konvertiert

-Die Anzahl der Elemente eines Feldes name ist name.length.

-Java unterstützt direkt nur ein-dimensionale Felder.

-Ein zwei-dimensionales Feld ist ein Feld von Feldern

-Leere Felder sind nicht wirklich leer, sondern mit etwas Unbekanntem (von früheren Berechnungen)
gefüllt.

-Die Operatoranwendungen ++x und x++ inkrementieren beide den Wert der Variablen x.

- ++x tut das, bevor der Wert des Ausdrucks ermittelt wird (Pre-Increment).

- x++ tut das, nachdem der Wert ermittelt wurde (Post-Increment).

BEISPIEL KOMMT
VORSICHT!

continue; und break; sind nicht das Gleiche:

-Gelegentlich stellt man fest, dass die Ausführung der aktuellen Anweisung s sofort abgebrochen
werden sollte. Nehmen wir an, wir hätten s mit einer Markierung A versehen. Dann setzt break A; die
Berechnung hinter s fort:

A: while (true) {

if (y <= 0) break A; // hier ist das Label A optional, weil wir nur in einer schleife sind, nur break; reicht

x = x * y;

y = y - 1;

-Je nachdem, wo die Markierung angebracht ist, kann man sogar aus mehreren Schleifen gleichzeitig
heraus springen.

-Besonders häufig ist allerdings, dass man genau die umliegende Schleife verlassen will. Dann kann
man auf das Label verzichten (siehe den obigen code)

-Ebenfalls häufig kommt vor, dass man die Schleife zwar noch nicht verlassen, aber die Ausführung
des Rumpfs abbrechen möchte.-Dazu stellt Java die Anweisung continue zur Verfügung :

int x = N; int z = 0;

for (int i = 0; i<a.length; i++) {

if (a[i] == 0) continue;

x = x /a[i];

z++;

hier werden bei a[i] == 0 die folgenden Anweisungen (der Rumpf der Schleife) nicht ausgeführt, aber
die Bedingung wird für die nächsten Elemente (also i+1 usw.) erneut geprüft.

-Manche Funktionen, deren Ergebnistyp void ist, geben gar keine Werte zurück – im Beispiel: write()
und main(). Diese Funktionen heißen Prozeduren.

-Die Halde (Heap) ist ein Speicherbereich, aus dem zur Laufzeit eines Programms
zusammenhängende Speicherabschnitte angefordert und in beliebiger Reihenfolge wieder
freigegeben werden können.

* Jedes dynamisch allokierte Objekt wird auf dem Heap angelegt, egal ob die Allokation im
Hauptprogramm oder in einer Funktion stattfindet.

-Der Stapel (Stack) ist ein Speicherbereich, auf den Elemente nur `oben ́ gespeichert und auch nur
von dort wieder gelesen werden. Elemente werden übereinander gestapelt und in umgekehrter
Reihenfolge vom Stapel genommen. Dies wird auch Last In–First Out Prinzip (LIFO) genannt.
* Beim Aufruf von main und den Funktionen/Prozeduren werden die jeweils lokalen Variablen (und
evtl. die Rücksprungadresse) als sogenannte Frames auf den Stack gespeichert

* Während der Programmausführung ist jeweils nur der oberste Frame `sichtbar ́, und die als global
definierten Variablen

-Länge des arrays : array.length

-Länge der liste : list.size()

-Lokale Variablen sind nur im eigenen Funktionsrumpf sichtbar, nicht in den aufgerufenen Funktionen

-Damit die aufgerufenen Hilfsfunktionen auf b zugreifen können, muss b explizit als Parameter
übergeben werden!

Objekt toString() Methode für unsere selbst kreierte Liste:

public String toString() {

String result = "[" + info;

for(List t=next; t!=null; t=t.next)

result = result + ", " + t.info;

return result + "]";

* Weil Objekt-Methoden nur für von null verschiedene Objekte aufgerufen werden können, kann die
leere Liste nicht mittels toString() als String dargestellt werden.

* Der Konkatenations-Operator “+” ist so schlau, vor Aufruf von toString() zu überprüfen, ob ein null-
Wert vorliegt. Ist das der Fall, wird "null" ausgegeben.

* Wollen wir eine andere Darstellung, benötigen wir eine Klassen-Methode String toString(List l)

public static String toString (List l) {

if (l == null)

return "[]"; else

return l.toString();

-Stack = Keller (LIFO) -> NEW STACK

-Queue = Schlange (FIFO) -> NEW LINKEDLIST

-public -> member can be seen from everywhere in the project

-default (no access modifier) -> member can be seen within package

-protected -> zugriff auf dem gleichen package und den unterklassen -> symbol #

-private -> member can be seen only within the class it is declared

* Beim Anlegen eines Objekts werden sämtliche Attribute mit dem default Wert ihres Typs vorbelegt.

* // für Objekte null

* // für int 0

* // für double .0

* // für boolean false

* In Java darf nicht mehr als eine öffentliche Klasse in einer Übersetzungseinheit enthalten sein (Java
Datei), eine Übersetzungseinheit darf aber mehrere (nicht-öffentliche) Klassen enthalten.

-variable hiding -> die Unterklasse verdeckt die geerbte Variable ohne sie zu ersetzen. Achtung:
Verweist die Referenz vom Typ der Oberklasse auf ein Objekt der Unterklasse, dann wird die Variable
aus der Oberklasse adressiert.

-overRIDE -> die Methode in der Unterklasse, die die Methode in der Oberklasse überschreibt,
ersetzt die überschriebene Methode. Achtung: Verweist die Referenz vom Typ der Oberklasse auf ein
Objekt der Unterklasse, dann wird die Methode aus der Unterklasse adressiert.

-overLOAD -> es existieren zwei oder mehr separate Methoden mit demselben Namen jedoch
unterschiedlichen formalen Parameterlisten (die Rückgabetypen können gleich oder
unterschiedlich sein).