/**
* @file Beispiel1.java
* Anhand des nachfolgenden Beispiels werden die
* Grundbegriffe
* imperativer Programmiersprachen am Beispiel von
* Java eingeführt.
*
* IMPERATIVE PROGRAMMIERSPRACHEN bieten eine
* Abstraktion des
* von Neumann'schen Rechnerorganisationsmodells,
* um die Implementierung
* von Algorithmen zu erleichtern.
* Die Grundbegriffe der imperativen
* Programmierung sind
*
*
* - Variablen - dies sind
* Abstraktionen von Speicherzellen, welche die
* im Algorithmus verarbeiteten Daten enthalten:
* Der Variablenname
* abstrahiert die Speicheradresse,
* der Variablenwert den Dateninhalt
* der adressierten Speicherzelle(n).
*
*
- Anweisungen - dies sind Abstraktionen
* der Maschineninstruktionen, welche
* Speicherplatz für Variablen reservieren,
Variablenwerte auswerten, umrechnen und verändern.
*
*
* Zur Erzeugung von Variablen und zur Gruppierung
* zusammengehöriger Anweisungen
* verwendet man
*
*
* - Deklarationen - dies sind Festlegungen
* oder Vereinbarungen für
* die Verwendung benutzerdefinierter Namen,
* die Klassen, Methoden oder Variablen
* repräsentieren.
*
*
* Weitere Details werden anhand des nachfolgenden
* Beispielcodes erläutert.
*/
/** Die Klassendeklaration
*
* Anweisungsfolgen werden in Java in Methoden
* zusammengefasst. Methoden
* sind einzeln ausführbare Programmeinheiten,
* die in Klassen gruppiert werden.
* Die Betrachtung des Klassenbegriffs aus
* objekt-orientierter Sicht erfolgt später -
* zunächst spielt hier für uns nur eine Rolle,
* dass der Compiler (javac) Klassen als
* kleinste Übersetzungseinheiten erkennt.
*
* Eine Klasse wird mit dem Schlüsselwort
* class deklariert und erhält
* einen eindeutigen Namen; die Bestandteile
* einer Klasse werden innerhalb von
* geschweiften Klammern { ... }
* gruppiert. (Die präzise Beschreibung der
* Grammatik mit Hilfe der erweiterten
* Backus-Naur-Form EBNF erfolgt später).
*
* Die Schlüsselworte public, static
* werden zu einem späteren Zeitpunkt
* erläutert.
*/
public class Beispiel1 {
/**
* Jedes Java-Programm muss eine Methode enthalten
* die als
* public static void main(String[] args)
* deklariert ist.
* Diese Deklaration definiert die Startadresse der
* ersten Anweisung,
* die bei Programmstart auszuführen ist.
*
* Bei Programmstart werden intern, d.h. ohne dass
* spezielle Anweisungen
* im Java-Programmcode erforderlich sind,
* folgende Instruktionen
* ausgeführt:
*
*
* - Die Java-Laufzeitumgebung (virtuelle Maschine)
* wird initialisiert
* (Details hierzu später)
*
- Die optionalen Zusatzparameter
*
p1, p2, ..., welche im Aufruf
* java Beispiel1 p1 p2 ...
* verwendet wurden, werden in die
* Array-Variable args kopiert.
*
*
* Methoden bestehen aus Variablendeklarationen
* (sog. lokale Variablen
* der Methode) und Anweisungsfolgen.
* Variablendeklarationen führen beim Methodenaufruf
* zur automatischen
* Ausführung von Instruktionen, welche die
* Variablendefinition, d.h. die
* Allokation des Speicherplatzes für die Variable auf
* dem Stack (Erläuterung
* des Stack erfolgt später) vornehmen:
* Der Speicherplatz für lokale Variablen
* wird also nicht statisch zur Übersetzungszeit,
* sondern dynamisch zur
* Laufzeit, d.h. bei Aufruf der Methode, angelegt.
*/
public static void main(String[] args) {
/** Variablendeklarationen
*
* Java kennt zwei Typen von Variablen:
*
*
* - Variablen von Basistypen
* für ganzzahlige Variablen,
* Gleitkommavariablen,
* Boolesche Variablen
* (Wertebereich { true, false })
*
- Referenzvariablen, welche die
* Adressen (=Referenzen) von Objekten
* enthalten.
*
*
* Jede Variablendeklaration erfolgt in der Form
* Typname Variablenname,
* die Syntaxrestriktionen für Variablennamen werden
* später im Detail besprochen.
*
* Java bietet folgende Basistypen:
*
*/
int n; /** Ganzzahlige Variable, z.B., -5, +4, 7, 32Bit */
float x; /** Gleitkommazahl, z.B. 1.4, 32 Bit, 1E-2 */
double z;/** Gleitkommazahl, z.B. 1.4, 64 Bit */
boolean b; /** Boolesche Variable */
/** Anweisungen gliedern sich in
*
* - Zuweisungen: Verändern Variablenwerte
*
- Kontrollstrukturen: Steuern die Sequenz
* der Anweisungsausführung
*
- Ein-/Ausgabeanweisungen: Übertragung von
* Daten zwischen dem Programm und den Peripheriegeräten
* (Tastatur, Bildschirm, Maus, Platte, ...)
*
*/
/** Zuweisungen werden in der Form
* Zielvariable = Ausdruck;
* notiert. Die Zielvariable definiert durch
* ihren Namen den Ort im Speicher, an welchen
* der Wert des Ausdrucks geschrieben werden soll.
* Das `=' hat die Bedeuting einer STORE-Instruktion.
* Da Java eine getypte Programmiersprache ist,
* muss der Ausdruck zum Typ der Zielvariablen
* auswerten.
* Ausdrücke bestehen aus Konstanten, Variablen oder
* syntaktisch zulässigen Kombinationen von Operanden
* und Operatoren. Die Operanden können wieder
* Konstanten oder Variablen oder geschachtelte Ausdrücke
* weiterer Operanden und Operatoren in Klammern (...)
* sein.
*/
n = 10;
n = n + 1;
n = ( n +1 ) * n;
/** Ausgabeanweisung: (Eingabeanweisungen
* werden später eingeführt)
*/
System.out.println("n = " + n);
System.out.println("Erster Aufrufparameter: "
+ args[0]);
/**
* Arrays sind indizierte Variablen:
* Mit einem Namen werden
* so viele Variablen eingeführt, wie der
* Indexbereich vorgibt.
* Arrays Typ a
* mit Wertebereich {0..n-1}
* realisieren mathematische Funktionen
*
*
* a : {0..n-1} ---> Typ
*
*
* Array-Definition zur Laufzeit: "Lege
* 2 Speicherplätze der Größe int (32Bit)
* zur Speicherung von a[0] bzw. a[1] an.
* Ist die Länge der Arrays mit n angegeben, so
* ist der zulässige Indexbereich 0..(n-1).
*
* Mehrdimensionale Arrays und andere Grenzdefinitionen
* werden später besprochen.
*/
int a[] = new int[2];
a[0] = 1;
a[1] = 2;
System.out.println("Array-Elemente: "
+ a[0] + " " + a[1]);
/**
* Arrays können bei ihrer Definition mit Werten vorbelegt
* werden. Dabei wird die Größe automatisch ermittelt
* (5 in diesem Beispiel)
*/
float f[] = { 1.0f, 3.6f, 7.1f, 4.4f, 5.5f };
boolean b2;
b2 = true;
b = false;
/** Boolsche Operatoren sind
* and (&&), or (||), not (!)
*/
b = b && b2;
/** Ausdruecke ueber
* Vergleichsoperatoren werten zum Typ boolean aus.
* Vergleichsoperatoren sind <, <=, >, >=, !=, ==
*/
b = f[4] < f[0];
b = (f[0] == f[1]);
/**
* Kontrollstrukturen sind
*
* -
if () { ... } else { .... }
* -
while ()
* -
; (Anweisungsfolge)
*
* -
for () { ... }
* -
do { ... } while ();
* -
switch() { }
*
*
*/
if ( f[0] == f[1] ) {
/**
* if-Zweig
* Diese Anweisungsfolge wird ausgeführt,
* wenn die Boolesche Bedingung zu true
* auswertet
*/
n = n +1;
}
else { /** "else-Zweig"
* Falls (f[0] == f[1]) == false
*/
n = n + 2;
/**
* Alle Kontrollstrukturen können
* geschachtelt auftreten:
* Hier oder im if-Block kann eine beliebige weitere
* Kontrollstruktur auftreten
*/
}
/**
* Hier geht es weiter, sobald if- oder
* else-Zweig ausgefuehrt wurden
*
* Die switch(Ausdruck) { ... } Anweisung
* bietet die Möglichkeit, if-Bedingungen über Vergleiche
* mit ganzzahligen Werten auf elegantere Weise zu formulieren.
* Ausdruck muss dabei zu einer ganzen Zahl auswerten.
* Zwischen case Wert: und break; stehen die Anweisungen,
* welche auszuführen sind, falls Ausdruck zu Wert auswertet.
* Ist Ausdruck mit keinem der Werte identisch,
* werden die Anweisungen
* des default:-Zweiges ausgeführt.
*/
switch(n - 1) {
case 1:
System.out.println("n-1 == 1");
break;
case 2:
System.out.println("n-1 == 2");
break;
default:
System.out.println("n-1 hat Wert " + (n - 1));
break;
}
/**
* Die while ( b ) { ... } Schleife
* führt den Schleifenkörper { ... }
* wiederholt aus, so lange die Boolsche Bedingung b zu true
* auswertet. Falls b == false bei Erreichen
* der while-Schleife, wird der Schleifenkörper
* überhaupt nicht durchlaufen.
*/
int i;
i = 0;
while ( f[i] < f[i+1] && i < 4 ) {
System.out.println("f["+i+"] = " + f[i]);
i = i + 1;
}
/**
* Die do { ... } while ( b ); Schleife
* führt den Schleifenkörper { ... }
* wiederholt aus, so lange die Boolsche Bedingung b zu true
* auswertet. Da die while-Bedingung am Ende des
* Schleifenkörpers ausgewertet wird, wird dieser mindestens
* einmal durchlaufen.
*
* @note Das hier gezeigte Beispiel ist besser für die
* while-Schleife als für die do-while-Schleife geeignet.
* Das sieht man bereits daran, dass im Schleifenkörper
* der do-while-Schleife eine if-Bedingung auftritt, die mit
* der Schleifenbedingung identisch ist.
*/
i = 0;
do {
b = f[i] < f[i+1];
if ( b ) {
System.out.println("f["+i+"] = " + f[i]);
}
i = i + 1;
} while ( b ) ;
/**
* Die
*
* for (Index-Initialisierung;
* Schleifenbedingung;
* Indexinkrementausdruck) { ... }
*
* Schleife
* führt den Schleifenkörper { ... }
* wiederholt aus, so lange die Schleifenbedingung zu true
* auswertet. Im Prinzip können hier beliebige
* Bedingungen wie bei den while-Schleifen verwendet werden;
* typischweise verwendet man aber for-Schleifen dann,
* wenn eine ganzzahlige Zählvariable verwendet wird,
* deren Größe über den Abbruch der Schleife entscheidet.
* Im Indexinkrementausdruck können ebenfalls beliebige
* Anweisungen stehen, man verwendet ihn aber üblicherweise
* zum inkrementieren oder dekrementieren des Schleifenindex.
*/
for ( int j=0; j < 4 && f[j] < f[j+1]; j = j + 1 ) {
if ( f[j] < f[j+1] ) {
System.out.println("f["+j+"] = " + f[j]);
}
}
}
}