Hauptseite | Alphabetische Liste | Auflistung der Klassen | Auflistung der Dateien | Klassen-Elemente

Beispiel1 Klassenreferenz

Aufstellung aller Elemente

Ausführliche Beschreibung

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.

Definiert in Zeile 72 der Datei Beispiel1.java.

Öffentliche, statische Methoden

static void main (String[] args)
 Jedes Java-Programm muss eine Methode enthalten die als public static void main(String[] args) deklariert ist.


Dokumentation der Elementfunktionen

static void Beispiel1.main String[]  args  )  [static]
 

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.

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:

Ganzzahlige Variable, z.B., -5, +4, 7, 32Bit

Gleitkommazahl, z.B. 1.4, 32 Bit, 1E-2

Gleitkommazahl, z.B. 1.4, 64 Bit

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.

Ausgabeanweisung: (Eingabeanweisungen werden später eingeführt)

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.

Arrays können bei ihrer Definition mit Werten vorbelegt werden. Dabei wird die Größe automatisch ermittelt (5 in diesem Beispiel)

Boolsche Operatoren sind and (&&), or (||), not (!)

Ausdruecke ueber Vergleichsoperatoren werten zum Typ boolean aus. Vergleichsoperatoren sind <, <=, >, >=, !=, ==

Kontrollstrukturen sind

  • if () { ... } else { .... }
  • while ()
  • ; (Anweisungsfolge)

  • for () { ... }
  • do { ... } while ();
  • switch() { }

if-Zweig Diese Anweisungsfolge wird ausgeführt, wenn die Boolesche Bedingung zu true auswertet

"else-Zweig" Falls (f[0] == f[1]) == false

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.

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.

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.

Zu beachten:
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.
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.

Definiert in Zeile 116 der Datei Beispiel1.java.

00116                                            {
00117 
00141         int n; 
00142         float x; 
00143         double z;
00144         boolean b; 
00173         n = 10; 
00174         n = n + 1; 
00175         n = ( n +1 ) * n;
00176 
00180         System.out.println("n = " + n);
00181 
00182         System.out.println("Erster Aufrufparameter: " 
00183                                + args[0]);
00184 
00185 
00186 
00187 
00210         int a[] = new int[2]; 
00211 
00212         a[0] = 1; 
00213         a[1] = 2;
00214         System.out.println("Array-Elemente: " 
00215                            + a[0] + " " + a[1]);
00216 
00217 
00223         float f[] = { 1.0f, 3.6f, 7.1f, 4.4f, 5.5f };
00224 
00225         boolean b2;
00226         b2 = true;
00227         b = false;
00228 
00232         b = b && b2; 
00233 
00238         b = f[4] < f[0]; 
00239         b = (f[0] == f[1]);
00240 
00241 
00255         if ( f[0] == f[1] ) {
00262             n = n +1;
00263 
00264         }
00265         else { 
00268             n = n + 2;
00269 
00277         }
00278  
00293         switch(n - 1) {
00294 
00295             case 1:
00296                 System.out.println("n-1 == 1");
00297                 break;
00298 
00299             case 2:
00300                 System.out.println("n-1 == 2");
00301                 break;
00302 
00303             default:
00304                 System.out.println("n-1 hat Wert " + (n - 1));
00305                 break;
00306         }
00307 
00308 
00309 
00310 
00311 
00312 
00313 
00314 
00323         int i;
00324         i = 0;
00325         while ( f[i] < f[i+1] && i < 4 ) {
00326 
00327             System.out.println("f["+i+"] = " + f[i]);
00328             i = i + 1;
00329 
00330         }
00331 
00346         i = 0;
00347         do {
00348             b = f[i] < f[i+1];
00349             if ( b ) {
00350                 System.out.println("f["+i+"] = " + f[i]);
00351             }
00352             i = i + 1;
00353         } while ( b ) ;
00354 
00355 
00375         for ( int j=0; j < 4 && f[j] < f[j+1]; j = j + 1 ) {
00376 
00377             if ( f[j] < f[j+1] ) {
00378                System.out.println("f["+j+"] = " + f[j]);
00379             }
00380 
00381         }
00382 
00383     }


Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:
Erzeugt am Tue Nov 14 06:51:42 2006 für Imperative Programmierung - Einführung in Java von  doxygen 1.4.4