home	Stand: 07.04.2007

Java – kurze Übersicht über Befehle & Theorie

Gedacht als "Nachschlagewerk" für (Gelegenheits-)Programmierer
und als Stoffübersicht zur Vorlesung "Softwarepraktikum" an der UniBA

eMail
Aktuelleste Version www.SchoSchi.de

Inhalt

Theorie
Operatoren
Befehle (Beispiel-Code, wie "primitive" Dinge genutzt werden können)
zur Vertiefung (Bücher + Web-Ressourcen)
To-Do

Theorie

• Literale: Kleinste Einheiten, aus denen Programmen bestehen (Zeichen). 
• Einfache Zeichen (ASCII 32 bis 128) können direkt mit der Tastatur eingegeben werden und sind unkritisch, abgesehen von Sonderzeichen, die als Escape-Sequenz dargestellt werden müssen. 

  \t	Tabulator	\b	Rückschritt	\"	Anführungszeichen
  \n	Zeilenvorschub	\r	Zeilenrücklauf	\'	Hochkomma
  \f	Seitenvorschub	\\	Backslash	\ooo	Oktale Konstante

• Oktale Konstanten werden im Zeichensatz der Plattform interpretiert, auf der das Programm kompiliert wird.
• Ansonsten gibt es noch Unicode-Steuersequenzen der Form \uXXXX wobei XXXX eine hexadezimale Zahl ist, z.B. \u0041 für A. Wichtig: Verschiedene Versionen von Java unterstützen verschiedene Versionen von Unicode, und es gibt Unicodezeichen mit 20bit-Schlüssel, die nicht direkt in einem char repräsentiert werden können.
  
• Signatur einer Methode: Rückgabetyp Name(ggf. ParameterTyp LoaklerVariablenName)
  nicht Zugangsberechtigung (private, public...) usw!
• Vererbung
  • Ist eine Art "Baukastenprinzip". Klassen und Interfaces werden zunächst so allgemein wie möglich definiert, dann Schrittweise verfeinert/spezialisiert, in Klassen werden Interfaces eingebaut sie bilden so neue, komplexere Klassen als die Eltern
  • Superklassen vererben alle Eigenschaften (Attribute, Methoden,..) an ihre Subklassen. Konstruktoren sollten neu definiert werden, selbst wenn er nur super() (= nur Konstruktor der Superklasse aufgerufen) enthält.
  • Subklassen sollen Superklassen nicht verkrüppeln, sondern erweitern! (teils Ausnahmen)
  • Variablen und Methoden in der Hierarchie so hoch ziehen wie möglich (gelegentlich Ausnahmen sinnvoll)
  • Polymorphismus: in zwei verwandten Klassen Methode mit gleicher Signatur? Die unterste wird genommen (also die der Subklasse)
  • von den Subklassen aus sind die Methoden der Superklasse über  super.Methode();  erreichbar
• Attribute
  • Klassenattribute (Zugriff aus der ganzer Klasse, werden meist zu Beginn notiert) anders benennen als Methodenattribute (existieren nur lokal). Das vermeidet Verwirrung. Klassenattribute (auch Membervariablen genannt) wird oft ein Unterstrich "_" vorangestellt.
  • Attribute ermöglichen die Datenhaltung in Objekten (Variablen werden mit Werten gefüllt).
• Konstruktoren erzeugen eine neue Instanz einer Klasse.
  • Aufruf mit new-Schlüsselwort, z.B.  KlassenName var = new KlassenName(ggf. Argumente);
  • bei Subklassen wird der allgemeine Konstruktor der Superklasse (ohne Argumente) immer aufgerufen, entspricht SubklassenKonstruktor() { super() }
    Existiert der allgemeine Konstruktor bei der Superklasse nicht, so gibt es einen Fehler bei der Subklasse. Weil normalerweise jede Klasse weiter spezialisiert werden kann (vgl. final) und die Subklasse den Standardkonstruktor aufrufen könnte, sollte jede Klasse einen Standardkonstruktor enthalten.
  • Wozu sind sie da? Zur Initialisierung von Objekten (Eigenschaften mit Standardwerten füllen etc).
  • Wann werden sie benutzt? Beim erzeugen eines Objekts durch den new-Operator.
  • Eine Klasse kann mehrere Konstruktoren haben. Sie unterscheiden sich nur durch ihre Parameterliste (was ihnen übergeben wird).
• Methoden
  • Methoden stellen den Funktionsumfang einer Klasse dar. Sie machen zudem den Code wartbarer, indem sie ihn sinnvoll unterteilen.
  • Kein Rückgabewert = void (leer, nichtig) als Rückgabetyp
    void MethodenName() {
      if (abbruchBedinung)
        return; // oder: retrun null; Trotz void möglich. Hat keinen Zweck, außer die Methode zu beenden.
      else
        ...;
    }
  • Falls Rückgabewert:
    RückgabeTyp MethodenName() { ...; return var; }    // RückgabeTyp ist z.B. int oder String
    Per  return VARIABLE_vom_Typ_RückgabeTyp;  wird Rückgabewert an Aufrufenden übergeben und Methode beendet (wird nicht weiter ausgeführt, d.h. Rest des Codes ist nicht erreichbar).
  • Aufruf und innerhalb der Klasse mit MethodenName(); und von außen KlassenName_oder_Instanz.MethodenName();
  • Typische Methoden: Get() und Set() - Methode gibt den Variablenwert zurück bzw. ändert interne (Variablen-)Werte, möglichst nicht direkt von außen auslesen/setzen (Klasse.VarName = XX) weil evtl. noch Veränderungen erfolgen müssen (z.B. dauerhaft abspeichern, Vektoren ändern etc). Is()-Methoden geben boolsche Eigenschaften zurück.
• Zugriffseinschränkung auf Attribute einer Klasse (oder Klassen selbst, Methoden,...) kommen bei sauberem Programmierstil vor jede Methode, Variable und Konstruktor.
  Faustregeln:
  • so wenig wie möglich von außen zugreifbar machen
  • Konstruktoren meist public, teilweise protected, fast nie private
  • Attribute meist private oder protected, selten public
  • private: nur die Klasse selbst hat Zugriff. z.B. für Anzahl der gezogenen Instanzen (in static-Membervariable gespeichert)
  • protected: zusätzlich die Subklassen (Vererbung), aber nicht von außerhalb der Hierarchie
  • package:
    • alles im gleichen Package bzw. Verzeichnis
    • ist der Standartwert (d.h. man schreibt keines der 4 hin und dieses gilt)
  • public: offener Zugang von außen. z.B. für Get() und Set()
• static
  • liegt vom Programmstart an fertig im Speicher, existiert genau ein Mal, ist in allen Instanzen gleich.
  • Nur wichtig, wenn mehrere Instanzen (oder gar keine) existieren sollen.
  • existiert auch + man kann daruf zugreifen, wenn keine Instanz gezogen wurde. Selten benötigt, z.B. für Klassenattribute (wie viele Instanzen wurden gezogen?) oder bei Klasse Math sollen die Rechenoperationen direkt verfügbar sein, ohne daß man erst mit new eine neue Instanz erzeigen muß java.lang.Math.pow(double a, double b)
    
  • Alles, was in einer static-Methode verwendet wird, muß auch static sein (z.B. Variablen)
• final: definiert Konstanten
  • Final Klassen können keine Unterklassen haben (können nicht vererben)
  • Final Methoden können nicht overridden verden (z.B. von ner Unterklassenmethode mit gleicher Signatur)
  • Final Variablen haben immer denselben Wert, einmalige Wertzuweisung (nämlich bei Initialisierung).
• static final: existiert nur ein Mal und ist nicht änderbar, aufrufbar per  KlassenName.KONSTANTE
• Polymorphismus ist eine Eigenschaft der Sprache Java. Bedeutung: Name sharing
  • Early Binding
    • Einfache Form von Polymorphismus
    • Overloading
    • Verschiedene Methoden haben den gleichen Namen aber unterschiedliche Parameter (Signatur), d.h.
      • unterschiedliche Anzahl
      • unterschiedliche Typen
      • unterschiedliche Reihenfolge
      Der Rückgabewert ist nicht relevant.
      Bsp: java.lang.String.compareTo(Object o) und String.compareTo(String anotherString) oder
      String.indexOf(int ch) und String.indexOf(int ch, int fromIndex)
      
    • Die technische Bezeichung early binding bedeutet: Die richtige (passende) Methode wird schon beim Kompilieren (in Bytecode übersetzen) herausgefunden.
    • Namensauflösung geschieht zur Compiletime
  • Late Binding
    • Die interessante Form von Polymorphismus
    • Overriding
      Bei Overriding müssen alle derartigen Methoden in den Superclasses gleiche, oder schwächere Zugriffsbeschränkungen haben, wie in den Subclasses.
    • Tritt auf, wenn eine Subclass eine Methode mit gleichem Namen und Signatur hat wie eine Superclass. Diese Methode muß nicht unbedingt in allen Klassen der Vererbungshierarchie vorhanden sein.
    • Die technische Bezeichung late binding bedeutet: Die richtige Methode, für welches Objekt auch immer, wird zur Laufzeit herausgefunden.
    • Namensauflösung geschieht zur Runtime.

• Interfaces kann man als besonders abstrakte Klassen betrachten, da ausschließlich abstrakte Methoden erlaubt sind (private daher semantisch unmöglich) – sozusagen eine abstrakte Klasse ganz ohne Implementierung. Statt des Keywords class werden sie durch das Keyword interface eingeleitet.

  • Ein Interface kann Signaturen von Methoden und Konstanten enthalten. Konstruktoren sind in Interfaces nicht erlaubt.
    Beispiel:

    interface X   {
      int    Konstante_1 = 25;
      short  Konstante_2 = 8;
    
      void     f1();
      int      f2(String s);
      boolean  f3(int n);
    }
    

  • Variablen sind implizit static final (= Konstanten) und Methoden sind implizit public [abstract] (abstract muß nicht hingeschrieben werden). Alles andere (z.B. Methoden-Körper, also der Code zwischen { und }) ist demnach nicht zulässig. Variablen müssen direkt einen Wert zugewiesen bekommen.
  • Interfaces verwendet man, wenn Eigenschaften einer Klasse beschrieben werden sollen, die nicht in der normalen Vererbungshierarchie abgebildet werden können (keine richtige, sondern nur eine technische is-a-Beziehung).
  • Interfaces können voneinander erben. interface Y extends X { ... }
  • Klassen, die Interfaces verwenden benutzen das Keyword implements, Bsp: class C implements X { ... }
  • Eine Klasse kann mehrere Interfaces implementieren. Hierdurch kann man in Java so eine Art Mehrfachvererbung realisieren. Eine implementierende Klasse muß mindestens alle Methoden des/der Interface(s) enthalten, und zwar mit gleicher Signatur wie im Interface.
    Bsp:

    import java.awt.*;
    import java.awt.event.*;
    class About extends Dialog implements ActionListener, KeyListener {
      About(Frame f)  { //Konstruktor
        super(f, true);
        setTitle("About");
        setLayout( new GridLayout (1,1) );
        add( new Label("Test Text", Label.CENTER));
        Button b = new Button("Continue");
        b.addActionListener( (ActionListener) this);
        b.addKeyListener( (KeyListener) this);
        add("South", b);
        pack();
      }
    
      public void actionPerformed(ActionEvent ae) { //noetig, um ein ActionListener zu sein (1 von 1)
        dispose();
      }
    
      public void keyTyped(KeyEvent e) { //noetig, um ein KeyListener zu sein (1 von 3)
        keyReleased(e);
      } 
      public void keyPressed(KeyEvent e) { //noetig, um ein KeyListener zu sein (2 von 3)
        keyReleased(e);
      } 
      public void keyReleased(KeyEvent e) { //noetig, um ein KeyListener zu sein (3 von 3)
        if ( e.getKeyCode() == java.awt.event.KeyEvent.VK_ESCAPE )
          dispose();
      } 
    } //Class About
    

Operatoren

Typen: Unäre Operatoren haben ein Argument, binäre 2 und ternäre 3 Argumente.

• Unary Minus: -
  Beispiele:
  

    int a, b = 5;
    a = -b; //a ist danach -5
    short k = -78; 

• In-/Decrement: ++ und --
  Meist in Schleifen verwendet. Beispiele:
  

    int a = 5, b = 5;
    a++; // der Wert von a wird um 1 erhoeht, a ist also 6
    ++a; // der Wert von a wird um 1 erhoeht, a ist also 7
    int c = b--; // danach ist c 5 (!) und b 4 (zuerst Zuweisung, dann Dekrement).
    int d = --b; // danach sind d und b 3 (zuerst Dekrement, dann Zuweisung). 

• Mathematische Operatoren: + - * / % und += -= *= /= %=
  Beispiele:
  

    int zahl = 4;
    zahl += 8; // zahl wird um 8 erhoeht, ergibt 12
               // Andere, gleichwertige Schreibweise: zahl = zahl + 8;
    zahl -= 5; // der Wert von zahl wird um 5 erniedrigt, ergibt 7
    zahl %= 3; // zahl modulo 3, ergibt 1 weil 7/3=2 Rest (Modulo) 1 
    zahl = 2*3.4; // zahl ist 5 (nicht 6.8 oder 7), weil Nachkommastellen bei 			
                  // Zuweisung zu einer int-Variable einfach abgeschnitten werden

• Relationale / Vergleichs-Operatoren:
  

  <	kleiner
  <=	kleiner-gleich
  >	größer
  >=	größer-gleich
  !=	ungleich
  ==	gleich. Obacht: = ist Wertzuweisung, == ist vergleichen! == prüft, ob Referenzen auf gleiches Objekt zeigen (auch Strings!), während obj1.equals(obj2) auf gleichen Inhalt prüft.

  
  Das Ergebnis des Vergleichs ist boolean. Beispiel:
  

    int kmh = 30; boolean b; 
    b = (kmh <= 30); // true
    b = (kmh+5 <= 30); // false, weil Berechnung Vorrang vor Vergleich hat

• Logische Operatoren: Arbeiten nur auf booleans.
  

    & und &&  AND 
    | und ||  OR 
       !      NOT 
       ^      XOR

  Beispiele:
  

    boolean isTrue = true; boolean b;
    b = !isTrue; // entspricht b = false;
    b = (isTrue & false); // ist false.
  

  Kurzauswertung / Short Circuit: Ein logischer Ausdruck wird bei Nutzung von verdoppeltem AND/OR (&& und ||) nur solange evaluiert, bis er eindeutig true oder false ist. Anschaulicher: Wenn der linkeste Ausdruck bereits das Ergebnis des Gesamtausdrucks bestimmt, werden alle weiter rechts liegende Ausdrücke nicht mehr ausgewertet. Beispiel:
  
    String s = null;
    if ( (s == null) || (s.equals("")) ) // s.equals() wird gar nicht mehr betrachtet
       System.out.println("Nix da!");
  
  
• Bitwise operators:
  Manipulation einzelner Bits in einem ganzzahligen elementaren Datentyp (zB char).
  

    & AND	&= 
    | OR	|= 
    ^ XOR	^=
    ~ NOT unary complement operator

  Nicht ohne Grund bei booleans statt der logischen Operatoren verwenden, da Performance unnötig verschenkt wird!
• Shift Operatoren:
  

    << left shift, inserting zeroes at the lower-order bits 
    int op = 8; 
    op << 2;   //ergibt 32.
   

  op >> 2 signed right shift	>>> unsigned right shift
  Ist der Operand op positiv, werden Nullen  negativ, werden Einsen in die higher order Bits geschrieben.	Es werden immer Nullen in die higher order Bits geschrieben.

  
  Kombinierte Operatoren:
  

    <<= >>= >>>=

  Der Operand, dem zugewiesen wird (oben im Bsp op) wird immer zu int, wenn er char, short oder byte ist.
  
• Ternary if-else Operator:
  Sehr praktisch zur Auswertung von Ja-Nein-Antworten des Nutzers und Auswertung von flags. Bei Nutzung von Methodenaufrufen wird dies schnell unübersichtlich.
  

    boolean-expr ? valueT : valueF    // ((Boolscher Ausdruck) ? falls_true : falls_false)

  Dieser Operator produziert einen Wert, z.B.:
  

    int alter = 22; 
    String altersklasse = (alter >= 18) ? "volljaehrig" : "minderjaehrig";
    boolean minderjaehrig = (alter >= 18) ? false : true;

Befehle

Hinweise:
{ } ist ein Anweisungsblock. Es kann stattdessen auch immer Befehl; stehen.
Mit  bool ist eine boolsche Variable bzw. ein boolscher Ausdruck, z.B.(a == b) gemeint.

• Minimale Klasse (muß zum Kompilieren den Dateinamen MINIMAL.java haben! Groß- / Kleinschreibung beachten!)
  

  class MINIMAL{ 
  	public static void main(String[] args) {
  
  	}
  }

• Falls Übergabe von Parametern erwünscht, prüfen, ob welche übergeben wurden (und ob korrekt), dann übernehmen (JArgs ansehen, ist schon bei recht simplen Parameter-Strukturen ein sehr hilfreiches Paket)
  

  public static void main(String[] args) {
  	if (args.length == 0)	{
  		System.err.println("Bitte Zahl eingeben");
  		System.exit(1);							// beenden des Programms (kompletter Abbruch)
  	}
  	int m = new Integer(args[0]).intValue();	//Umwandlung des Strings in int
  }

• Erbende Klassen
  

  class Kunde extends Person {
  }

• Abstrakte Klasse
  • muß mindestens eine abstract-Methode (erkennbar an fehlenden geschweiften Klammern, d.h. keine Implementierung) enthalten
  • erzwingt, daß irgendwo weiter unten in der Hierarchie eine Methode mit bestimmter Signatur implementiert wird
  • kann nicht instanziiert werden. Ist sinnvoll, da die Methode keinen Inhalt hat (die Instanz würde bei dieser Methode ja nichts machen, wäre also nicht funktionstüchtig)
  • Bsp einer abstrakten Methode: abstract void bewegeX(int i);
    
• Variablendefinition, mit oder ohne Instanziierung, z.B.      int eineZahl; int weitereZahl = 42;
• primitive Datentypen
  

  // Definition unterschiedlicher ganzzahliger Variablen
  char ch; // 16 bit, ohne Vorzeichen (fuer 16bit-Unicodezeichen gedacht)
  byte  b = -128; // -128 bis +127
  short s = 12675;
  int   i, cnt = 23, eineZahl;	// definiert 3 Variablen (i, cnt, eineZahl)	
  long grosseZahl = 87263664646L;	// L ist die  "long"-Kennzeichnung
  
  // Wertzuweisung an eine Variable vom Typ char
  ch = 'A'; // alternative Schreibweisen: ch=65 oder ch='\u0041'
  
  boolean nochUnbestimmt, istWahr = true;

• Eindimensionale Arrays: Definition, Initialisierung, Verwendung

  int[]   a1;		// Definition einer Verweisvariablen (Handle auf ein Array)
  				// Ist noch kein Array, könnte nur eines aufnehmen!
  
  int[]   a2 = new int[8];			// Verweisvariable auf ein Array mit 8 Elementen
  
  int[]   a3 = {6, 3, 65, 9, 98, 10}; // Literales Initialisieren eines Arrays
  
  
  
  i = a3.length;	// i ist 6 (da 6 Elemente), a3[6] gibt es aber nicht 
  
  				// (da abzählen mit 1 und adessieren mit 0 begonnen wird)
  
  i = a3[3];		// i ist 65
  
  char[] chars_toReplace = {'a', 'e', 'i'}; // Achtung, bei char ' und nicht " nutzen!!
  

• Zweidimensionale Arrays: Definition, Initialisierung.

  int[][]   b1;	// Definition einer Verweisvariablen (Handle auf ein Array von Arrays) 
  				// Ist noch kein Array, könnte nur eines aufnehmen!
  
  int[][]   b2 = new int[8][];	// Verweisvariable auf ein Array mit 8 Arrays
  
  int[][]   b2 = new int[8][5];	// Verweisvariable auf ein Array mit 8 mal 5 Elementen
  
  
  
  int[][]   b3 = {{6, 3, 65}, {9, 98}, {10, 32, 0, 8}};	// Literales Initialisieren
  
  
  
  i = b3[1][2];	// i ist 3 (erstes Tupel, zweites Element im Tupel)

• Strings. Achtung: Wenn lange Strings (tausende Zeichen) verändert werden, besser StringBuffer verwenden. Grund: Strings sind unveränderlich, d.h. bei jeder Manipulation wird ein neues String-Objekt angelegt und der Inhalt kopiert. Dies dauert bei langen Strings spürbar lang.
  

  String s1; boolean bool;  // Deklaration, keine Initialisierung, zeigen nichtmal auf nix (null)
  String s2 = "Stringtext"; // Initialisierung (Verweis auf automatisch erzeugte Instanz der Klasse String)
  String s3 = new String("Stringtext");  // expliziter Konstruktoraufruf, erzeugt eine neue Instanz
  
  int len = s2.length();    // Anzahl Zeichen im String
  
  s1 = new String(s2);      // s1 hat jetzt denselben Inhalt wie s2, aber andere Speicheradresse (Kopie)
  bool = (s1 == s2);        // false. Es wird nicht der Inhalt verglichen, sondern die Speicheradresse
  
  s1 = s2;                  // Weist s1 die Speicheradresse von s2 zu (Umlenken)
  bool = (s1 == s2);        // true, weil Speicheradressen jetzt übereinstimmt (s1+s2 "physisch identisch")
  
  s2 = "EUR";	          // s2 zeigt zu einer neuen Instanz der Klasse String 
  bool = (s1 == s2);        // false, da s2 mit der neuen Instanz einen neuen Speicherplatz bekam
  s2 = 3 + s2;              // int-Zahl 3 wird automatisch zu String konvertiert/gecastet; s2 ist "3EUR"
  
  bool = s1.equals(s3);     // true. Vergleicht den Inhalt der Strings, vgl. equalsIgnoreCase()
  
  s2 = s1.replace( 'S', '\u0024'); // s2 beginnt jetzt mit $. Fuer Unicode-Zeichen siehe
                                   // www.unicode.org/charts Achtung, bei char ' und nicht " nutzen!!

• Ausgabe auf dem Bildschrim:
  Bitte die Devices out und err unterscheiden, z.B. JBuilder zeigt err-Ausgaben in rot an, was bei Fehlersuche hilft.
  

  System.out.println();		// Ausgabe einer Leerzeile
  
  System.out.println("\t \"Zeile1\" \nZeile2");	
  		// Zunächst macht \t einen Tab Einzug (sog. Escape-Sequenz) auf dem Bildschirm
  		// Dann " wieder mit Escape-Sequenz
  		// Dann Zeile1 und wieder ein " ausgeben
  		// Dann mit \n (linefeed) in die nächste Zeile (geht auch mit \r (carriage return))
  		// Dort Zeile2 ausgeben
  
  System.out.print( ((i < 0) ? "-" : "+") + i);	// i mit passendem Vorzeichen

• Integer Arithmetik wird immer mit 4 bzw. 8 Byte durchgeführt. z.B.:
  

  int summe;
  byte b1, b2;
  summe = b1 + b2;

  Das Ergebnis der Addition kann nur von einer Variablen des Typs int oder long aufgenommen werden.
• Explizite Typumwandlung (Cast), float und double zu integer schneidet Nachkommastellen ab, integer zu byte übernimmt nur die Hälfte der Stellen.
  

  byte b, b1 = 7, b2 = 9;
  b = (byte)(b1 + b2);	// schlecht, da Informationsverlust!!

• Anweisungsblöcke per { und } definieren,
  Reichweite (Exsistenz bzw. Gültigkeit) von Variablen (Scope) nur innerhalb der geschweiften Klammern, in denen sie definiert wurden
  

  if (bool) Befehl_1;
  if (bool) { Befehl_1; Befehl_2; }
  if (bool) { ... } else { ... }
  if (bool) { ... } else if (bool) { ... } else { ... }
  
  
  switch (integral) {	
    // integral: int (97) oder char ('a') sind gleichwertig (durch '' ASCII-Code)
    // alle anderen Datentypen als byte, short, char, int: Serie von if-Bedingungen nötig
    case integralKonstante1: // ohne Statement => einfach nächster Code ausgeführt (z.B. bei gleicher Ausgabe)
    case integralKonstante2: 
      Befehl_1; 
      Befehl_2;  // { } nicht nötig
      break;             //optional, falls nicht => Code des folgenden Case auch ausführen
    case integralKonstante3:   
    default: // wird angesprungen, wenn keine andere Stelle angesprungen wurde ODER drüber kein break steht
  }

• Schleifen
  

  while (bool) { };      // Überprüfung der Bedingung am Anfang 
                         // (falls anfangs falsch => Körper überpringen)
  do { } while (bool);   // Überprüfung der Bedingung am Ende 
                         // (falls anfangs falsch => Körper ein Mal durchlaufen)
  
  for (int i = 0; i < 5; i++)  
    { ... };             // Normale For-Schleife, 3 Argumente. Letztlich eine spezielle While-Schleife
                         // i existiert nur innerhalb der FOR-Schleife
  
  for (int i = 0; i < 5; ) 
    {...; i++; ...; };   // Inkrement irgendwo in Schleife statt in Definition
  
  for (int i = 0; ; )    // Inkrement und Abbruch innerhalb der Schleife
    {...; if (i > 4) break; ....; i++; ....;};	
  
  for (;;i++)            // Verwendung einer Variablen, die ausserhalb der for-Schleife existiert
    {if (i > 4) break;};		
  	
  for(int i = 1, j = i + 10;  i != j;   i++, j--)   
    {...}; // Definiert 2 Variablen (desselben Typs!) und 2 Inkrements, z.B. für 1*10, 2*9, 3*8,...
  
  for (Enumeration e = zipFile.entries(); e.hasMoreElements(); ) {
    ZipEntry ze = (ZipEntry) e.nextElement();	// Eine etwas andere Iterator-Konstruktion
    String zeName = ze.getName(); 
  }
  
  break;             // Beendet die aktuelle Schleife, man kann Sprungadressen (ähnlich Goto) definieren
  break Sprungmarke; // irgendwo steht Sprungmarke:, DIREKT danach die Schleife (nix Statements dazwischen!)
                     // z.B. falls verschachtelte Schleifen, innere & äußere stoppen, aber RETURN; unmöglich
  
  continue;             // Springt zurück an den Anfang einer Schleife, bei FOR Iteration 
                        // um eins (z.B. i++) durchgeführt
  continue Sprungmarke; // springt zurück zum Anfang der Schleife, die nach Sprungmarke: beginnt 
                        // z.B. bei verschachtelten Schleifen, von der inneren aus direkt die äußere neu ansetzen

• Klasse StringBuffer
  

  StringBuffer antwort = new StringBuffer();  // Konstruktoraufruf
  char zeichen = '\u0024';           // Unicode-Zeichen $, siehe www.unicode.org/charts
  antwort.append("Kostet 3");        // haengt String an
  antwort.append( (char)zeichen );   // haengt das Char an

• java.util.vector (siehe auch HashTable, LinkedList etc). Ähnlich wie Array, aber mit flexibler Größe, daher für Gruppen unbekannter / veränderlicher Größe geeignet. Kann ausschließlich Objekte aufnehmen - also z.B. Instanzen von Klassen etc. - und daher muß der Inhalt beim Auslesen gecastet werden. Bsp:

  String st = "Hallo";
  Vector v = new Vector();
  v.add(st);
  print_out( (String) v.elementAt(0) ); //cast zum String, sonst wuerde was mit @ ausgegeben

 

zur Vertiefung

• unklare Befehle in der API nachschlagen. Zur API ein paar Worte:
  • basale Dinge wie String etc. finden sich unter packages.java.lang
  • depricated heißt veraltet (von java 1.3 oder älter), noch lauffähig, soll man aber nicht mehr benutzen, da es in einer der nächsten Versionen nicht mehr funktionieren wird. Meistens bei Methoden, deren Namen über alle packages angepasst wurden (meist get / set / is - Methoden).
  • Wenn man sich nur innerhalb eines packages bewegt, frames-Version, oben links das package wählen, unten links ist eine recht kurze Liste von Klassen
  • Wenn man sich viel zwischen packages bewegt, no-frames-Version nehmen und den Index nutzen (Suche im Browser-Fenster per Strg+F)
  • Bei komplizierteren Dingen (z.B. LayoutManager) stehen meist oben Erklärungen, wie eine Klasse funktioniert. Bei "einfachen" Dingen fehlt dies meist komplett, da muß man auf Bücher/Tutorials ausweichen.
• Für Windows-Nutzer ist es zeitsparend, im Startmenü oder auf dem Desktop eine Verknüpfung namens "javaAPI Index" mit der Befehlszeile "C:\Programme\Internet Explorer\IEXPLORE.EXE" -k "file:///D:/Java-Zeug/SDK14%20Doc/api/index-files/index-1.html" anzulegen (Pfad zur Doku + zum Browser anpassen). Dann reichen 3 Tasten, um in der Duku zu landen ("Windows-Taste, j, Enter") und die ist gleich im Kiosk-Mode (maximale Bildschirmfläche genutzt).
• Ressourcen
  • Bücher, die man gelegentlich online zum kostenfreien und legalen Download bzw. Onlinelesen findet (z.B. bei www.galileocomputing.de - OpenBook, Markt und Technik-Leseecke oder um Weihnachten bei Computerzeitschriften)
    • Goto To Java 2 (deutsch), Addison Wesley, © 1999 Guido Krüger, www.gkrueger.com
    • Thinking in Java, Bruce Eckel, www.BruceEckel.com
    • Java 2 in 21 Tagen, Laura Lemay / Roger Cadenhead, MuT
    • Java 2 Kompendium, Ralph Steyer, MuT
    • Java 2 – Designmuster und Zertifizierungswissen, Friedrich Esser, Galileo-Download
    • Java ist auch eine Insel, Christian Ullenboom, http://www.tutego.com/javabuch/ und Galileo-Download
    • Java Kurs, Kurt Huwig, www.huwig.de und http://www.iku-ag.de/
    • Make Java Performance, Sebastian Ritter, www.Bastie.de
    • Java-Dokumentation "SelfJAVA", Brit Schröter, www.selfjava.de/
      
  • Tutorials von SUN (engl., sehr gut und praktisch orientiert, auch "höhere" Sachen [Netz, Grafik, Tabellen + Bäume etc]). Lassen sich auch als thematische Archive runterladen.
    http://java.sun.com/docs/books/tutorial/
    
  • Seiten zur Vorlesung
    www.buva.wiai.uni-bamberg.de/javakurs/
    

 

To-Do

Befehle ergänzen

• enumeratoren, iteratoren
• regex
  
• import
  import java.util.Vector;
  import java.util.Enumeration;
  
• Keyword super
• try, catch, finally
• throws
• throw
• Keyword interface ?
• class Thread
• interface Runnable
• Starten und beenden von Threads.
• outputstream siehe 00-11-27
• instanceOf sinnvoll zum Prüfen, ob ein neues Element gültig ist (z.B. soll in einen Vector oder eine verkettetete Liste)
• Methode clone() (java.lang.Object) klont eine Instanz, d.h. eine echte Kopie (zwei verschiedene Instanzen im Speicher)
• zeichen von Tastatur lesen

Sonstiges

• Design Pattern ansehen (bei Sun und in Goto Java, Kap 10.3) + hier kurze Übersicht + Link(s)
• benutzung packages
• Javadoc erklären
• JARs (wie aufrufen, bei fehlern entpacken, java-konforme Pfade [Bilder etc], wie erstellen)
• Bücher kommentieren (wofür geeignet [nachschlagen/lernen/...], welches Niveau, praktisch/theoretisch)

End of File