/**
 * Beispiel Code zur Vorlesung PI1 - WS2002/2003
 * jp@informatik.uni-bremen.de
 *
 * 
 * Java-Programme bestehen aus logischen Einheiten, die
 * als KLASSEN (Classes) bezeichnet werden. Klassen besitzen 
 * einen Namen, so dass ihre Bestandteile über den Namen
 * referenziert werden können.
 */

public class HelloWorldDoc {


    /**
     * Klassen enthalten MITGLIEDER (Members), die zur Speicherung von Daten
     * und zur Ausführung von Operationen auf Daten und Schnittstellen dienen.
     * Erstere heissen FELDER (Fields), letztere METHODEN (Methods).
     * 
     */

    // Felder: Der ZUSTANDSRAUM der Klasse, bestehend aus VARIABLEN
    // Das Schluesselwort static bewirkt, dass für die Variable zur
    // Übersetzungszeit bereits Speicher allokiert wird.
    //
    // HINWEIS: In Java wird zwischen der
    // VARIABLENDEKLARATION (DECLARATION) und der VARIABLENERZEUGUNG
    // (CREATION) unterschieden: Bei der Deklaration sind der 
    // Variablen-Identifikator und der zugehörige Typ bekannt.
    // Der Speicherplatz wird erst im Moment der Variablenerzeugung
    // zugewiesen.
    //
    // HINWEIS AUF SPAETERE VORLESUNGEN: Das Schluesselwort 'static'
    // bewirkt bei den Feldern weiterhin, dass alle Instanzen der Klasse
    // diese Variablen als gemeinsamen Speicher benutzen: Der Speicher
    // wird nur einmal allokiert und ist allen Instanzen gleichermaßen
    // zugänglich. Im Gegensatz dazu können andere Variablen dynamisch
    // bei der Objektinstantiierung erzeugt werden, nur das Objekt kann
    // auf diese Variablen zugreifen.
    //
    //
    //
    // Variablendeklarationen bestehen aus Paaren
    //
    //     type name
    //
    // Für Variablennamen - allgemeiner: für Java
    // Identifikatoren - kann der Unicode Zeichensatz 
    // verwendet werden. Jedes Zeichen ist dort mit 16 Bit
    // codiert, anstatt wie zB im ASCII Zeichensatz nur
    // 8 Bit für die Codierung zu verwenden.
    //
    // Als  Identifikatoren dürfen keine Java-SCHLÜSSELWORTE
    // verwendet werden.
    //
    // Der Programmbereich, in welchem eine Variable über ihren
    // einfachen Namen angesprochen werden kann, heisst SCOPE.
    //
    // Java unterscheidet PRIMITIVE TYPEN und
    // REFERENZ-TYPEN. Variablen vom REF-TYP speichern
    // nicht das Objekt selber, sondern die REFERENZ, dh
    // die Adresse, welche auf das durch die Variable
    // gekennzeichnete Objekt verweist. 
    //Die primitven Typen sind
    // 
    static byte v1;
    static short v2;
    static int mu;  // anscheinend wird  µ; nicht von allen Systemen akzeptiert
    static long v4;
    static float v5;
    static double v6;
    static char v7;
    static int x = 5;
    static int y = 6;
    static boolean v8;
    static int myFirstVar;

    // Konstanten - dh. identifikatoren, denen
    // ein unveränderlicher Wert zugeordnet wurde,
    // heissen in Java FINALE VARIABLEN. Ihnen darf genau einmal
    // ein Wert zugewiesen werden.
    static final int theArrayLength = 2000;


    // Von den Referenztypen lernen wir zunächst nur den
    // Array kennen.
    // Wir benutzen zunächst nur die einfachste Form: den
    // eindimensionalen Array, der bereits mit der Deklaration
    // angelegt wird.    
    // HINWEIS AUF SPÄTERE VORLESUNGEN:
    // Referenztypen können auf beliebige Objekte und Schnittstellen
    // verweisen.
    // Array Deklaration mit gleichzeitiger
    // Array Erzeugung.
    //
    // int[]: nachfolgende Variable wird 
    // ein int-array.
    //
    // new: Schlüsselwort für Allokation
    // (Speicherplatzerzeugung) des Objektes
    // myArray.
    // Die einzelnen Arraylemente werden angesprochen
    // mit myArray[0]..myArray[1999], d.h. von 0
    // bis 'Größe -1';
    static int[] myFirstArray = new int[theArrayLength];

    // Die Erzwugung von Arrays kann auch durch explizite
    // Angabe der Initialwerte geschehen:
    static int[] myArray = {3,7,6,4,5,9};


    /**
     * Der ausführbare Code einer Java-Class wird in METHODEN
     * zusammengefasst ("gekapselt").
     *
     * Ein Java-Programm beginnt seine Ausführung immer bei
     * einer bestimmten Methode, welche die Deklaration
     * public static void main(String[] args)
     * tragen muss. 
     */   
    public static void main(String[] args) {

	// Variablen können auch lokal in einer Methode
	// deklariert werden. Sie sind dann ausserhalb der Methode
	// nicht zugänglich. Die Erzeugung der Variablen 
	// erfolgt dann im Falle der 'primitiven Typen'
	// dynamisch bei Aufruf der
	// Methode. Die Allokation des Speichers geschieht
	// auf dem Methoden-STACK (hierzu weitere Erläuterungen in 
	// der Vorlesung)

	int myLocalVar = 2;

 

	// Java bietet eine Standardausgaberoutine, die 
	// auszugebende Werte automatisch typgerecht formatiert.
	System.out.println("Hello World ...");    


        // Die auszugebenden Objekte werden mit '+'
	// konkateniert.
	// verschiedene Verwendung von '+': Operator Overloading
	mu = x + y;
	System.out.println
	    ("It's a fact that "+x+" + "+y+" = "+mu);

        // Über den args[]-Array können die beim Programmstart
	// übergebenen Argumente angesprochen werden.
	System.out.println("The start arguments were "+args[0]);

    
	// Felder haben DEFAULT VALUES als Initialwerte;
	// diese werden zur Übersetzungszeit vergeben, wenn
	// kein expliziter Initialwert von der Programmiererin
	// angegeben wurde.
	System.out.println("v8 is initialised by default value "+v8); 

	// Im Programmtext verwendete Konstanten heissen LITERALE
	System.out.println
	    ("Die long-Konstante "
	     + 1234567891234L
	     +" ist ganz schön long");   

	// Zugriff auf ein Array-Element über seinen Index
	myFirstArray[0] = 99;
	System.out.println("in myFirstArray[0] steht " + myFirstArray[0]);


	/*
	 * LITERALE - VARIABLEN - OPERATOREN - AUSDRUECKE - ANWEISUNGEN 
	 *
	 * Ein Ausdruck ist eine Folge von Literale, Variablen, Operatoren
	 * und Methodenaufrufen, die syntaktisch zulässig sind und in einem
	 * einzigen Wert resultieren. Wird ein oder mehrere Ausdrücke
	 * zu einer ausführbaren Einheit zusammengefasst, wird diese
	 * Zusammenfassung als ANWEISUNG bezeichnet. Anweisungen werden
	 * mit ';' abgeschlossen.
	 */
        // 1 + 27 AUSDRUCK (EXPRESSION) 
	// + OPERATOR
        // 1, 27 OPERANDEN
        // ZUWEISUNGS-ANWEISUNG  myFirstVar = 1 + 27;         

	/*
	 * einige Operatoren .....
	 */
	//Boolsche Vergleichsoperatoren:
        // > greater than
	// >= greater or equal than
	// < less than
	// <= less or equal than
	// == equal to
	// != not equal to
 
        // Boolsche Verknüpfungen
	// & logical AND (binary operator)
	// | logical inclusive OR (binary operator)
	// ^ logical exclusive or (XOR) (binary operator)
	// ! logical negation (unary operator)
	// && conditional AND (binary operator)
	// || conditional OR (binary operator)

        // && und || brechen die Auswertung ab, sobald der Wahrheitswert
	// des Ausdrucks feststeht.

        if ( (mu = 2) < 3  )
          System.out.println("det jeht in Java");

        v1 = 0;
        mu = 0;
        if ( (v1 == mu) || v1/mu == 0 )
 	    System.out.println("... gerade nochmal gut gegangen");

        // hier knallt's:
        //if ( true | v1/mu == 0 )
 	//    System.out.println("... das hier wird nicht gehen ...");
        
        // Bit-Manipulationsoperatoren für Integer-Variablen
        // & bitwise AND (binary operator)
	//   0111 & 0100 == 0100
	// | bitwise OR (binary operator)
	//   0111 | 0100 == 0111
	// ^ bitwise XOR (binary operator)
	//   0111^0100 == 0011
	// ~ bitwise negation (unary operator)
	//   ~0111 == 1000
        // << shift left - fill with zeros from the right
	// 8-Bit Worte:
	//    0000 0001 << 1 == 0000 0010
	//    0000 0001 << 3 == 0000 1000
        //    0101 0000 << 3 == 1000 0000
	//    BEACHTE: Vorzeichenbit wird ignoriert:
	//    0100 0000 << 1 == 1000 0000
        //    i << 1 == 2*i "wenn i klein genug ist"
        // >> shift right - fill with the highest bit (sign bit) from left
        // >>> shift right - fill with zeroes from left.
        System.out.println(" (1<<2) & (24>>>1) = "+((1<<2) & (24>>>1))); 


	/*
	 * Zuweisungen mit Type Casts
	 * ANWENDUNG: "Hilfestellung" für den Compiler,
	 *            wie der Ergebnistyp von Berechnungen
	 *            zu erzeugen ist.
	 */
         // Integer-Division wird auf float-variable zugewiesen
	mu = 5;
	v5 = 1/mu;
	System.out.println("1/µ = "+v5); 

	// Die Operanden der Division werden mit cast nach 
	// float gewandelt
	v5 = 1/(float)mu;
	System.out.println("1/(float)mu = "+v5); 


	/*
	 * Kontrollfluss-Anweisungen
	 */

	// Sequenz-Operator ;
	mu = x + y;
	mu = mu + 5;

        // bedingte Verzweigung: if
        if ( mu <= x ) { // IF-ZWEIG 
            System.out.println("mu ist kleiner gleich  x");
	}             
        else { // ALTERNATIVE
	    System.out.println("mu ist echt größer als klein x");  
	} 

         
	// Bedingte Verzweigung: switch
	switch ( mu ) {
	case 1: System.out.println("mu is' 1");
	    break;
	case 2: System.out.println("mu is' 2");
	    break;
	default: System.out.println("mu is' weiss nich was");
	    break;
	}


	// for-Schleife
	//iCnt: Schleifenzähler
	// int iCnt=0 : Zähler-Erzeugung und 
	// Initiialisierung
        // iCnt<6 : Abbruchbedingung, sobald false
	//     : dh Fortsetzungsbedingung, solange true
	//      wird immer bei Schleifenbeginn ausgewertet
	// iCnt++ : Abkürzung für die Zuweisung
	// iCnt = iCnt+1 Wird nach jedem Schleifenduchlauf
	// 1x ausgeführt.
	for ( int iCnt=0; iCnt<6;iCnt++) {
	    //Schleifenkörper
	    System.out.println("myArray["
			       +iCnt
			       +"] = "
			       + myArray[iCnt]);
        }
    
	myFirstVar = 0;

        // while - Schleife:
	// läuft so lange, wie Schleifenbedingung
	// ( myFirstVar < 6 ) 
	// erfüllt ist
        while ( myFirstVar < 6 ) {
            //Schleifenkörper
	    System.out.println("while : myArray["
			       +myFirstVar
			       +"] = "
			       + myArray[myFirstVar]);


	    // break führt zum sofortigen Verlassen des umgebenden
	    // Schleifenblocks
            if ( myArray[myFirstVar] == 22 )
		break;

	    myFirstVar++;  
	}       

	// do-while Schleife: wird mindestens einmal durchlaufen      
	myFirstVar = 0;
        do {
            //Schleifenkörper
	    System.out.println("do-while : myArray["
			       +myFirstVar
			       +"] = "
			       + myArray[myFirstVar]);
	    myFirstVar++;   
	}    while ( myFirstVar < 6 );

        


    }

}