XML (Extensible Markup Language)
wird wie auch HTML beschrieben nach einer DTD (Document Type Definition)
SGML (Standard Generalized Markup Language) legt fest, wie DTDs zu behandeln sind
Zweck: allgemeiner und schneller als HTML und SGML
Markup = Kennzeichnung (Besonderes wird mit Tags gekennzeichnet)

<buch>
	<author>
		Goethe
	</author>
	<title>
		Faust
	</title>
	<erscheinungsjahr>
		1973
	</erscheinungsjahr>
</buch>

• Beim ersten Start wird gemeldet, daß das Paket org.apache.xerces.parsers nicht existiert.
• Erst Xerces-J-bin.2.0.2.tar.gz nach C: oder C:xml oder so
• Pfad zu xercesImpl.jar (z.B. C:rces-2_0_2) in die Umgebungsvariablen-Systemvariablen unter Win eintragen => NEU oder vorhanden => Name: CLASSPATH => Wert: .;C:rces-2_0_2rcesImpl.jar;%CLASSPATH% => Eingabeaufforderung neu starten

alle Tags müssen geschlossen werden, auch <br>

keine Umlaute, sondern entities, z.B. ß (sonst UTFDataFormatException)

innere class UnserContentHandler ... { // vgl. XMLTest.java
// -> vgl. org.xml.sax.ContentHandler
// -> siehe 1.4/api/org/xml/sax

java.util.StringTokenizer
String s = "Es gibt nichts Gutes, außer man tut es.";
StringTokenizer st = new StringTokenizer(s);
while(st.hasMoreTokens()){
	System.out.println(st.nextToken());
}
int i = st.countTokens();
StringTokenizer st2 = new StringTokenizer(s,("iuea");
// trennt bei jedem Buchstaben, wobei die Trennzeichen i,u,e und a verschwinden

Problem: Dateien, die Daten über Bücher enthalten, in Bücher umformen.
Ansatz 1: Reguläre Ausdrücke (java.util.regex)
Ansatz 2: XML-Parser (xerces von org.apache / org.xml)
Parser interpretieren die Sprache

Reguläre Ausdrücke
[PRT]est ->> "Pest", "Rest", "Test"
.est -> siehe oben + " est", "4est"
t.ste -> teste, taste
T.*st -> "Toast", "Trost", aber auch "Tst", "Tödlicher Ernst" (greedy)
* -> kein oder mehrmal
? -> kein oder einmal
+ -> ein oder mehrmal
t.?ste

[aeiou] eines der Zeichen von
[0-9]
/s space
/S kein Space
/w word (hier wohl Buchstabe)
/W Gegenteil von /w, also alle Nicht-Buchstaben
/d digit (Ziffer)

// in Perl würden wir nach <\s*body.*?> suchen
// Der Backslash muß in Java auskommentiert werden:
static String regex = "<\s*body.*?>";

Pattern und Matcher (vergleiche Regex.?.java)

Quantifiers
- greedy sucht möglichst großen String z.B. "Tasten im Kasten" statt "Tasten" bei Ta*en (*)
- noch ein Fragezeichen, dann gibt es sich mit dem erstbesten zufrieden
- *? (zögerlich) sucht nach der kleinsten Zeichenkette
- ??
- +?
- possessive mit noch einem + dahinter
- zögerlich ??

Stellenangaben
^ Zeilenanfang (^A -> Zeile, die mit "A" beginnt)
$ Zeilenende, (^A.*Z$ -> Zeile beginnt mit A und endet mit Z)

Gruppenbildung mit ()
"dies ist ein beispiel" nach s.*?s durchsucht -> "s is". Dies ist die Gruppe mit Index 0.
dto. nach s.*?b -> "s ist ein b"
dto. nach s(.*?)b ergibt 2 Gruppen: "s ist ein b" und " ist ein "
dto. nach dies(.*?)b.* ergibt: "dies ist ein beispiel" und " ist ein "
dto. nach dies(.*?)ein(.*) ergibt: "dies ist ein beispiel" und " ist " und " beispiel"
=> pro Klammernpaar eine zusätzliche Gruppe

prüfen, ob in "<ul><li>eintrag</ul>" alle Tags geschlossen wurden:
	Suche nach "<li>(.*?)<(.*?>" und frage, ob Gruppe 3 gleich "/li" ist

"<(.*?)>.*?</\1)>" findet alle Tags, die auch geschlossen wurden
	\1 gleich Gruppe 1, also das was zwischen < und > steht
	\0 ist immer der gesamte Ausdruck

eine Variable gilt nur
     - in dem {}-Block, in dem sie initialisiert wurde
     - und in den darunterliegenden Blöcken
     ! aber nicht in den darüberliegenden!!!

String.methoden()
s.indexOf(String) liefert >=0 wenn String enthalten in s
charAt(i)
toCharArray() liefert char[]
s.substring(2,7)
s.startsWith(s2)
s.endsWith(s2)

Collections != Collection
unmodifiableSet(Set s)
	Set s = new HashSet();
	//...
	Set x = Collections.unmodifiableSet(s)
Dieses Konzept ist eine Ansicht, d.h.:
- Keine Kopie, nur das Schreibrecht ist genommen!
- x ändert sich auch, wenn s verändert wird

Dateien und Datenströme java io.File
- File f = new File("file://E:/java/test.txt");

String newline = System.getProperty("line.separator"); // Zeilenumbruch des BS

Beim Aufruf von javac x.java sollte automatisch alles compiliert werden,
	was für x gebraucht wird.

map
Map m = new HashMap; // oder auch SortedMap m = new TreeMap;
m.put("schluessel",new Object());
Object x = m.put("schluessel",xxxx);	wird einfach überschrieben
if(!m.containsKey("Martin"))
	{m.put("Martin","12345");}else{// Rückmeldung: Anderen Namen wählen;}
// Wenn der Schlüssel bereits verwendet wird, wird er überschrieben(!) und put()liefert
// das Object zurück, welches vorher unter dem Schlüssel abgelegt war, sonst null
Object o = m.get("schluessel");
oder: m.put("rot",java.awt.Color.red);
      java.awt.Color r = (java.awt.Color)m.get("rot");
m.remove("rot");
alle Elemente durchlaufen:
Set schluesselMenge = m.keySet();	// oder entrySet
Iterator it = schluesselMenge.iterator();
while(it.hasNext()){
	Object o = m.get(it.next());	// Object key = it.next(); Object o = m.get(key);
}
// kuerzer: for(Iterator it = m.keySet().iterator();it.hasNext();)
//	{Object o = m.get(it.next());}

SET (Mengen)
Set eins = new HashSet();
Set zwei = new HashSet();
// Vereinigungsmenge
boolean b = eins.addAll(zwei);
// Schnittmenge
boolean b = eins.retainAll(zwei);	// behalte alles in der Menge, was auch in zwei ist
// Mengendifferenz (zum Teil)
boolean b = eins.removeAll(zwei);	// entferne alles, was auch in zwei ist
// Mengendifferenz (komplett) = Vereinigungsmenge - Schnittmenge
// , wobei b jeweils true ergibt, wenn etwas verändert wurde
primitiv -> Collection
Integer x = new Integer(56);	// verkapseln, damit es in die Collection paßt
c.add(x);
Collection -> primitiv
int i = x.intValue(); // nachdem wir x aus c bekommen haben
Konstruktor TreeSet(Comparator com) (vgl. PotenzenSortedSet.java)
ein Comparator-Objekt hat eine methode compare(o1, o2), in der festgelegt ist,
wie zwei Objekte o1 und o1 zu vergleichen sind
Comparator ist ein Interface, also schreiben wir am besten eine innere Klasse

LIST (Listen)
java.util.ArrayList (Absicht: Arrays nachbilden), wie Set, aber mit:
List al = new ArrayList(); (~String[] s_array = new String[12];)
al.set(0,"erste Stelle"); ERSETZEN (~s_array[0] = "erste Stelle";)
al.add(0,"erste Stelle"); EINFÜGEN
String s = (String)al.get(0); (~String s = s_array[0];)
for(int i=0;i<al.size();i++){	// ist nicht verwendbar, wenn al Lücken hat,
	String s = (String)al.get(i);	// denn es liefert auch die leeren Elemente
}
alternativ und besser listet der ListIterator nur die Elemente, die enthalten sind:
for(ListIterator li = al.listIterator();li.hasNext();){
	String s = (String)li.next();
}

java.lang.Object bietet außer toString(), equals(), hashCode() auch noch:
getClass(). Dies liefert uns ein Objekt vom Typ:
java.lang.Class vergleiche getClassBsp.java
Class.forName("java.lang.String") - prüft ob die Klasse existiert und lädt sie ggfs.
	try{
	    Class.forName("Klassenname"); // ab hier kann die Klasse verwendet werden
	} catch(ClassNotFoundException cnfe){ // was passiert, falls es die Klasse nicht gibt
	}

Für den Anfang wichtig:
java.lang: Object, Class, Boolean etc., Math, System, String
java.util: Collections

Besonderheiten von Arrays
- Zugriff durch Indize, z.B. array[6]
  konsequent objektorientiert müßte es eher heißen:    array.getElement(6)
- Herstellung int[] array = new int[5];    statt    IntArray array = new IntArray[5];
- array.length    statt    array.getLength()
- int dieses = array[i];    statt    DatenTyp dieses = array.getElementAt(i);

Nachteile von C/C++-typischen Arrays:
- Länge nach Erstellung nicht veränderbar
- Datentyp muß einheitlich sein

Collections-Framework
Klassen, die Objekte beschreiben, die beliebige andere Objekte enthalten,
         aber keine primitiven Datentypen, außer man verpackt sie in Objekte (wrap?)
1. Set (Mengen)
   Sammlung von beliebig vielen beliebigen Objekten,
   wobei kein objekt mehr als einmal in einer Menge sein kann
2. List (Listen)
   Sammlung in Reihenfolge, mehrfaches Vorkommen möglich
3. Map (Zuordnungen)
   Schlüssel-Set kann auch eine Zeichenkette sein (wie hashes in Perl)
   Werte-Collection: zugeordnete Objekte

In JavaScript möglich (wie hashes in Perl):
int[] groessen = new int[4];
groessen["ball"] = 12;
groesse 1 = groessen["ball"]; Zeichenkette statt Index
In Java brauchen wir dazu eine Zuordnung von Zeichenketten zu Zahlen, dazu dienen Maps

Methoden im Interface Collection:
- erstellen mit Set s = new Hashset(); oder Collection c = new Hashset();
- add(Object o), z.B. c.add("hallo"); - fügt das neue Element hinzu
- remove(o), z.B. c.remove("hallo");
- size()
- isEmpty()
- contains(Object o) liefert true, wenn o enthalten, z.B if(c.contains("hallo"))
- toArray() liefert ein Object[]-Array
------------
- iterator() liefert ein zur Collection passendes Iterator-Object,
  welches Elemente herausholen kann. Es hat 2 von 3 wichtigen Methoden:
  1. hasNext() fragt, ob noch ein Element übrig ist
  2. next() gibt es

java.awt( abstract windowing toolkit): Grafikgestaltung
java.lang enthält die wichtigsten mathematischen Methoden
	(java.math nur weitere)
java.util Hilfklassen: Collections, Zeit, Random
java.text Internationalisierung
java.util.regex neu auf 1.4: reguläre Ausdrücke von Perl übernommen

Observer-Pattern (Beobachter-Rezept)
- Beobachterklasse und beobachtete Klasse
- Eine beobachtete Klasse führt eine Liste ihrer Beobachter
z.B. der Beobachter B, die beobachtete Klasse K
B bekommt eine Methode nehmeNotizvon()
K ruft diese Methode bei Bedarf auf
auf Seite von B
auf Seite von K: Methode, mit deren Hilfe sich Beobachter eintragen können

accessor-methods (get- und set-Methoden): Methoden, um Variablen zu lesen oder zu setzen

toString hashCode und equals werden saubererweise überschrieben (siehe Buch / Test)

Interfaces sollten auf "-bar", "-faehig" oder "-able" enden.
nur eine Oberklasse möglich, aber mehrere Interfaces.

extends ^= ist eine Art von

Konstuktoren
- beginnen (immer ?) mit new
- normalerweise public, damit sie von außen benutztbar sind
Object o = new Object();
1. Referenz wird angelegt
2. Speicher wird bereitgestellt
   - Klasse Object.class wird geladen
   - statische Bestandteile der Klasse Object werden angelegt
3. Objekt wird dort angelegt
   - nichtstatische Bestandteile werden angelegt
   - Konstruktor wird ausgeführt
String s = o.toString();	// kann benutzt werden
Deklaration: [Sichtbarkeit] KlassenName( [Datentyp var, ...] ){}
z.B.    class X{X(){}}    // einfachster Konstruktor
Standard-Konstruktor	class Beliebige{public Beliebige(){}}
    Superklassen-Konstruktor wird automatisch angelegt
spezieller Konstruktoraufruf this():
- nur innerhalb von Konstruktoren
- nur in der ersten Zeile des Konstruktors

Speicher leeren
- b.finalize();	// allerdings erst, wenn Java es für günstig hält (nichts anderes zu tun)
- b = null;	// neue Referenz zu nicht gefülltem Objekt; alter Speicher wird frei
- eigene Methode schreiben, meist finalize überschreiben	// siehe finalize
- ganz eigene Methode schreiben

Boolean b = new Boolean(true);	// Konstruktor belastet jedesmal new Speicher
Boolean b = Boolean.valueOf(true);	// factory method liefert vorgefertigtes Objekt
AppletContext c = getAppletContext();	// Lieferantenmethode

class Gott{
	private static Gott g = new Gott();
	// nur ein Gott, der direkt hier erstellt wird;
	// verhindern, daß der Konstruktor ausgeführt wird
	// -> Standard-Konstruktor überschreiben:
	private Gott(){}
	// dadurch brauchen wir eine Lieferanten-Methode
	public static Gott getInstance(){
		return g;
	}
}
// Aufruf mit Gott.getInstance()

schleife: while(){
	if(ausnahme){break schleife;}
} <= hier landet break schleife;

Innerhalb einer Klasse kann es mehrere Methoden mit dem gleichen Namen geben:
    methode() , methode(int i, double j) , methode(double j, int i)

public class Bsp{
	private int i = 0;
	public void oeffentlich(){}
	public static void statisch(){}
	private void privat(){}
}
public class Verwender{
    // nur statisch kann direkt von hier aus benutzt werden:
    Bsp.statisch();    // mit Bezug auf Klasse
    // aber auch auf oeffentlich kann zugegriffen werden:
    Bsp b = new Bsp();
    int i = b.oeffentlich();    // mit Bezug auf Instanz
    // der Rest ist nicht verwendbar
}

public class Bsp{
    private java.awt.Point p = new java.awt.Point(12,12);
    public java.awt.Point oeffentlich(){
        return p;
    }
}
public class Verwender{
    Bsp b = new Bsp();
	java.awt.Point point = b.oeffentlich();
    point.x = 4;    // Original ändert sich zu 4,12
}

Überladen
zwei Methoden mit unterschiedlicher Signatur, aber gleichem Namen erklären, z.B.
- public void zeichne(Strings){} und public void zeichne(char c){}
- der "+"-Operator

Überschreiben, Überdecken, Überschatten
ein Ding durch ein anderes ersetzen, wie ein Feld durch eine lokale Variable, z.B.
public class Ueberschreiben{
    static int i = 0;
    public void methode(){
        int i = 3;    // Klassenfeld wird überschattet
        Ueberschreiben.i = 5;    // spricht das Klassenfeld i an
    }
}
public class Ueberschreiben2{
    int x=3;
    public void methode(){
    int x = 2;    // bleibt unverändert durch die nachfolgende Zeile
    this.x = 5;    // setzt das Instanzfeld von 3 auf 5
}
    Ueberschreiben2 u = new Ueberschreiben2();
    u.methode();
	Ueberschreiben2 u2 = new Ueberschreiben2();
    u2.methode();

static für feste Variablen und Methoden (, die von main aufgerufen werden können)
non-static für Instanzen (z.B. Rechner r, Rechner, s) -> r.methode;
    auf nicht-statische Methoden kann nicht direkt von main zugegriffen werden,
    es geht nur über das Bilden einer Instanz

Variablen
- static klassenweit
  ansprechbar mit KlassenName.VariablenName
- non-static pro Instanz (wobei Instanz eine Variable für ein Objekt ist)
  ansprechbar mit this.VariablenName oder InstanzName.VariablenName
- innerhalb von Methoden nur dort

Methoden
- static klassenweit
  aufrufbar mit KlassenName.methodenName
- non-static pro Instanz (wobei Instanz eine Variable für ein Objekt ist)
  this.methodenName oder InstanzName.methodenName

class Emu{
static int anzahl = 1000;
static String attribut = selten;
String name = "Greta";
in gewicht = 100;
public static int zaehle(){return anzahl;}
public Emu balz(Emu e){anzahl++;return new Emu();
}
dann nur in einer statischen Methode:
Emu e = new Emu();    // kann auf non-static class zugreifen
Emu e2 = new Emu();    // dto.
Emu e3 = e.balz(e2);    // auf die non-static methode jedoch nur über die class
         this kann hier korrekterweise eingefügt werden
public void methode(){
    int i = Emu.zaehle();
    Emu e = this.balz(new Emu());
}           this kann hier korrekterweise eingefügt werden


Mit << und >> können wir die 2er-Potenzen sehr schnell bearbeiten.
Negative Zahlen beginnen im Bit-Muster mit einer 1, z.B.
	1000 0000 = -128
	1111 1111 = -1
>> füllt mit 1 auf, z.B.
	1000 0100 >>1 = 1100 0010
>>> füllt mit 0 auf, z.B.
	1000 0100 >>1 = 0100 0010

switch case
- funktioniert auch mit Sonderzeichen
- break springt hinter }
- continue springt hinter {

Operatoren-Reihenfolge:
1. Mathematische Operatoren
2. Vergleichs-Operatoren
3. Logische Operatoren

Vergleichsoperatoren vor logischen:    a & b == true                a & (b == true)
und vor oder:                          a & b | c                    (a & b) | c
einfach vor doppelt:                   a && b & c                   a && (b & c)
Zuweisungen zuletzt:                   a = 2 + 3 == 5 || b          a = (2 + 3 == 5 || b)
String-Verkettung vor Addition:        "x+5 ist " + x + 5           (Ausgabe: x+5 ist 25)

Achtung:    k *= i + j;    entspricht    k = k * i + j;

int x,y,z; x = y = y = 3; boolean b = x == y == z;
	// nicht möglich, da (x == y) ein boolscher Wert ist und
	// nicht mit einer Zahl verglichen werden kann.

Modulo:
- while (true) {i = (i+1)%23;} zählt endlos von 0 bis 22
- 1056 Cent = 1056/100 Euro + 1056%100 Cent (1056%10=6)

for (int x=0,y=1000;x<4;x++,y/=10)

ternärer Operator ?:
i = (j>k) ? 5 : 3; // wenn j>k dann i=5, sonst i=3    entspricht    if(j>k){i=5;}else{i=3;}

besser Zahl als Bitmuster interpretieren als boolsches Array:
- if ((z & 8) != 0)    true, wenn das viertletzte Bit gesetzt ist.
- z |= 8;              set; setzt viertletztes Bit auf 1.
- z &= ~8;             unset; abschalten, da ~ das Komplement bildet (~8 = ...1110111).
- z ^= 8;              toggle; umschalten, ^ (XOR) bildet ein ausschließendes Oder.

Der HTML-Befehl blink funktioniert nur in Netscape
Dies wird durch den HTML-Befehl em bewirkt

HTML-Datei erstellen durch Umlenkung, z.B. java Telefon > telefon.html (DOS)

java.awt.Point[] p = new java awt.Point[5];
for (int i=0;i<p.length;i++)
{
	p[i].x = 5;
}
führt zu einer NullPointerException, da zuerst jeder Punkt mit
	- p[i] = new java.awt.Point();   oder
	- if(p[i]!=null)p[i].x = 5;      initialisiert werden muß.

~ bildet ein bitweises Komplement, also aus 1001 -> 0110, z.B. ~j,
	so wie !bedingung ein boolean-Komplement bildet

if(x instanceof String)    -    Ist x vom Datentyp String?

if(x==2 && y==3); falls 1.Bedingung false wird sofort abgebrochen, die 2. nicht mehr geprüft
if(x==2 & y==3); alle Bedingungen werden bedingungslos geprüft,

                 wichtig für if(x++ == 2 & y-- = 3) oder if(x == 0 & methode(i))

StringBuffer java.lang.StringBuffer ist besser als einzelne Strings zu addieren:
anstatt String text = " eins "; text += " zwei "; ist es RAM-schonender:
StringBuffer sb = new StringBuffer();
sb.append(" eins ");
sb.append(" zwei ");
String ergebnis = sb.toString(); // gleichwertig mit String sb = " eins " + " zwei ";

array.length ist eine Variable, aber string.length() ist eine Methode

Bei einem mehrdimensionalen array[][]:
	int[][] tabelle = {{1,2,3},{4,5,6},{7,8,9}};
oder
    stundenplan = new String[5][8];
    stundenplan[0][2] = "Java";
oder
    String[][] stundenplan;
    stundenplan = new String[5][];    // Jede 1.Dimenstion kann versch. 2. haben:
    stundenplan[0] = new String[8];   // Montags 8 Stunden, aber
    stundenplan[4] = new String[4];   // Freitags nur 4 Speicherplätze!
    stundenplan[0][2] = "Java";

//Array-Literale können nur unmittelbar mit Typangabe zurückgegeben werden:
    public int[] dreiEinsen()
    {
        return new int[]{1,1,1};
        // return {1,1,1};    //nicht möglich
        // int[] ergebnis; ergebnis = {1,1,1}; return ergebnis;    //nicht möglich
    }

• String[] n = {"Petra","Bernd","Kai"}; Arrays.sort(n);
• BINÄRSUCHE (schnell): Arrays.binarySearch(n,"Bernd"); liefert Index oder negativen Wert (vorher sortieren!)
• Array.fill(n,""); z.B. zum Löschen
• Array.equals(n,weiteres_array) prüft auf Gleichheit;
  im Gegensatz zu if(x=="test"), was auf Selbigkeit prüft (muß die selbe Speicheradresse sein)

Katze felix = new Katze();
Definition des Datentyps: Katze
Konstruktor: Katze()
    class Tier{}
    class Katze extends Tier implements Haustier{}
    class Elefant extends Tier{}
    class Fisch extends Tier implements Haustier{}
    interface Haustier{}
        Katze felix = new Katze();
        Tier t = (Tier)felix;
        Haustier h = (Haustier)felix;
        Fisch fred = new Fisch();
        fred = (Fisch)felix;            -> COMPILERFEHLER
        Katze k = (Katze)h;
        Haustier h2 = (Haustier)fred;
        Katze k = (Katze)h2;            -> LAUFZEITFEHLER

Einzige Möglichkeit, einer Zeichenkette eine primitive Variable zuzuweisen: String s = "" + 12;

Primitive Datentypen werden per Wert übergeben
- Wert des Originals bleibt erhalten
- Kopie wird bearbeitet
Referenz-Datentypen werden per Referenz übergeben
- Kopie der Referenz zeigt auf Original-Objekt
- Original wird verändert

String eins = "test";
String zwei = "test";
if (eins.equals(zwei)) oder if ("test".equals(zwei))

Mehrzeilige Zeichenketten:
String text = "Wir haben gerade nichts zu tun, so wie jeden Tag, schon"
            + "morgens läuft die Glotze und der erste Schnaps ist da..."

1. [Sichtbarkeit]
• public erscheint in der Doku; ist auch in anderen Klassen verwendbar
• private empfohlen
• protected
2. [Modifikatoren]
• static: Klassenfeld, kein Instanzfeld (alles, was zur Klasse gehört)
• transient: (bezüglich threads/Multitasking)
• volatile
• final: Konstant (GROßSCHREIBUNG!)
3. Datentyp
4. Variable
5. [Wertzuweisung]

1. Cast (Typumwandlung): b = (float)12.0;
2. Zuweisung:            byte b = 42;
3. Methodenaufruf:       public void Methode (byte b){} (Methode verlangt Bytewert)
4. Rechenoperationen:    b = 12.0 + 8; (ergibt 20.0)