Grundstruktur

Grundstruktur
/* .... */
//
import java.io.*;
import java.util.*;
import java.sql.*;
Kommentar
Kommentar
Bibliothek Ein/Ausgabe
Datum
SQL
Date in beiden enthalten:
java.util.Date
int = +/- 2 Mrd.
Datentyp
(double) Faktor
Typumwandlung
public class HelloWorld
{
public static void main(String args[])
{
try
{
System.out.println("Hallo Welt");
System.in.read();
}
catch(Exception e)
{
System.out.println("Exception = " + e + "\n");
}
}
}
Name der Klasse
Wie void main()
Zum Fehler abfangen
Anweisungen
Falls Fehler auftritt innerhalb try
Fehler ausgeben
Kontrollstrukturen
while(test<zahler)
{
Bedingungen;
}
0 = falsch,
Bsp. while(test)
>0 = richtig
= solange test wahr ist
while(test)
= Endlosschleife
for(zahler=0;test<zahler;zahler++)
{
Bedingungen;
wird auch im letzten
}
Durchgang erhöht
for(;;)
= Endlosschleife
if(test<zahler)
{
Bedingungen;
}
else
{
Bedingungen;
}
Vergleiche: == && ||
switch(test)
{
case 1: Bedingung;
break;
default: Bed.;
}
(test)
(!test)
= wahr = 1
= falsch = 0
if(test<zahler) Bedingung;
else Bedingung;
break
continue
Auch bei while, for
möglich
= Abbruch
=Am Schleifenanfang weitermachen
Datumsfunktionen
Date d1;
d1 = new Date(1999-1900,9-1,27)
Date = Klasse, d1 = Objekt
bei eingeben = -1 / -1900
bei ausgeben = +1 / +1900
d1.setMonth(1-1)
int Tag = d1.getMonth() +1
if(d1.after(d2))
Daten verändern
Daten bekommen
Daten vergleichen
d1.toGMTString();
d1.toLocaleString();
Daten ausgeben
Daten ausgeben
setDate() = Methode
wenn d1 nach d2 kommt
in Verbindung mit
System.out.println
Tastatureingaben
int Buchstabe = System.in.read();
StreamTokenizer Eingabe = new Stream Tokenizer(System.in);
Eingabe.nextToken();
int Kapital = (int)Eingabe.nval;
nval = double, sval = String
if(eingabe.ttype == StreamTokenizer.TT_NUMBER)
if(eingabe.ttype == StreamTokenizer.TT_WORD) Abfrage ob Wort
Abfrage ob Nummer
Strings
String s1;
s1 = new String("Test");
String s2 = new String(s1);
s1 = "Test";
s1 = s2 + "Test");
oder String s1 = new String();
oder String s1 = "Text";
s1.length();
s1.toUpperCase();
s1.substring(4,7);
s1.charAt(1);
s1.concat(s2);
d1.equals(d1);
Länge bestimmen
Großbuchstaben umwandeln
gibt Buchstaben der Pos. 4 bis 6 zurück (von 0 aus)
gibt 2. Buchstaben zurück
hängt s2 an s1 an
gibt true oder false zurück
if(s1.compareTo(s2) < 0)
if(s1.compareTo("Text") == 0)
wenn s1 kleiner als s2 ist
wenn s1 gleich "Text" ist
Arrays
int a[];
a = new int[5];
a.length
a[0] = 1;
System.out.println(a[0]);
a=b
String Array[] = new String[10]
Array[zahler] = ""
5 Felder groß
gibt 5 zurück
Inhalt a[0] wird ausgegeben
Array a nimmt Daten u. Größe von b an  Werte vorher in for-Schleife zuweisen
am besten in for-Schleife mit "" initialisieren, um evtl. Fehler in
anderen for-Schleifen auszuschließen (Out of Bounce)
Funktionen (Methoden) call by ref
call by value
public static int sortieren(int Umsatz[], String Wort) innerhalb der Klasse
{
vor oder nach void main
return(Ergebnis);
}
Ergebnis = sortieren(Umsatz, Wort);
Konvertierung
String  Int
int Zahl = Integer.valueOf(Wort).intValue();
Konvertierung
Int  String
String Wort = String.valueOf(Zahl);
Aus Datei lesen
FileReader EingabeDatei = new FileReader("artikel.dat");
StreamTokenizer Eingabe = new StreamTokenizer(EingabeDatei);
Eingabe.whitespaceChars(',',',');
Eingabe.nextToken();
while(Eingabe.ttype != StreamTokenizer.TT_EOF)
{
String Enum = Eingabe.sval;
Eingabe.nextToken();
double EVK = Eingabe.nval;
Eingabe.nextToken();
String SQLBef = "Insert into artikel (Num,VK) "
+" values ('"+ENum+"',"+EVK+")";
Befehl.executeUpdate(SQLBef);
}
In Datei schreiben
FileWriter AusgabeDatei = new FileWriter("artikel.dat");
while(Ergebnisse.next())
{
String ENum = Ergebnisse.getString("Num");
String EVK = Ergebnisse.getDouble("Num");
String Azeile = "\""+Enum+"\","+EVK+"\n";
System.out.print (Azeile);
AusgabeDatei.write(Azeile,0,Azeile.length());
}
AusgabeDatei.close();
Sortieren - Aufsteigend
String zwischen;
int zahler1 = 0;
int zahler2 = 0;
int anzahl = 20;
for(zahler1 = 0; zahler1 < anzahl - 1; zahler1 ++)
{
for(zahler2 = zahler1 + 1; zahler2 < anzahl; zahler2 ++)
{
if(Name[zahler1].compareTo(Name[zahler2]) > 0)
{
zwischen = Name[zahler1];
Name[zahler1] = Name[zahler2];
Name[zahler2] = zwischen;
}
}
}
Komma zu Leerzeichen
Maximum
oder sortieren u. letzten Wert nehmen
double Max = 0.0;
if(Wert1 > Wert2) Max = Wert1;
else Max = Wert2;
String max = "";
for(int z = 0; z < 10; z++)
{
if(max.compareTo(Array[z]) < 0) max = Array[z];
}
Minimum
double Min = Wert2;
if(Wert1 < Wert2) Min = Wert1;
else Min = Wert2;
String min = a[0];
for(int z = 0; z < 10; z++)
{
if(min.compareTo(Array[z]) > 0) min = Array[z];
}
Array kann auch sein:
String Array[] = new String[10];
Datum in Datenbank einfügen (mit SQL-Date)
java.sql.Date Datum = new java.sql.Date(99,11,05);
java.sql.Time Zeit = new java.sql.Time(12,35,10);
String SQLBef = "Insert into Lagerort(Regal,Fach,Art,Datum) "
+ "values("+ERegal+","+EFach+",'"+EArt+"',#"+Datum+" "+Zeit+"#)";
Klassen - Statisch
public class Ctest
{
private static int Dlaenge;
//Optional
public Ctest()
{
Dlaenge = 0;
}
public static String holeTest()
{
return("test");
}
 Anzahl kann mit jeder neuen Instanz der
Klasse erhöht werden (Methoden mit ++
vorausgesetzt)
Zugriff möglich mit: Ctest.holeTest()
oder Variable.holeTest()
holeLaenge()  nicht erlaubt, da Klasse nicht initialisiert (static)
}
Klassen - Vererbung
public class Ctest extends COber
{
private int DLaenge;
Methoden aus der Oberklasse können nur auf
Variablen aus der Oberklasse zugreifen
public Ctest()
{
super(0,0);
setzeLaenge(0);
}
Oberklasse kann Methoden der Unterklasse verwenden, wenn
diese Methoden in der Unterklasse überschrieben wurde (also
auch in der Oberklasse enthalten ist)
public void setzeLaenge(pLaenge)
{
DLaenge = pLaenge;
}
}
Klassen - Polymorphismus
COber test[] = new COber[5];
test[0] = new COber();
test[0] = new CTest();
test[z].setzeLaenge  Je nachdem welches Objekt enthalten ist, wird die
Methode der Ober-/Unterklasse verwendet (vorausgesetzt die
Methode wurde in der Unterklasse überschrieben)
Klassen - Abstrakt
public abstract class COber
{
private int DLaenge;
public COber()
{
Dlaenge = 0;
}
public abstract setzeLaenge(pLaenge);
}
- Es können keine Instanzen von Oberklasse erstellt werden
- Methode der Oberklasse muss in Unterklasse überschrieben
werden
Vector
Vector Figuren = new Vector();
Figuren.addElement(aktRechteck);
Figuren.size()
Object Vector erstellen
Rechteck in Liste aufnehmen
Größe Vector
Bei normaler Klasse
Object aktFigur = Figuren.elementAt(z);
if(aktFigur instanceof CRechteck)
CRechteck aktRechteck = (CRechteck) aktFigur;
aktRechteck.zeichne();
Umwandlung von Vector zu Object
prüfen bei Object ein CRechteck ist
Umwandlung von Object zu CRechteck
Zugriff auf Methode von CRechteck
Bei Polymorphismus
CFigur aktFigur = (CFigur)Figuren.elementAt(z);
aktFigur.zeichne();
Umwandlung von Vector zu CFigur
Zugriff auf Methode von CRechteck
Exceptions
public class Ctest
{
private int DLaenge;
public Ctest() throws Exception
{
super(0,0);
setzeLaenge(0);
}
public void setzeLaenge(pLaenge) throws Exception, IllegalArgumentException
{
DLaenge = pLaenge;
Exception enthält alle Fehler
If(Dlaenge < 0)
{
Exception e = new Exception("Fehler");
throw en;
}
}
}
Im Hauptprogramm
try
{ ......
}
catch(IllegalArgumentException e)
{
System.out.println("Fehler" + e);
}
catch(Exception en)
{
System.out.println(en.getMessage());
en = new Exception("Fehler");
}
finally
{
Verbindung.close();
}
gibt komplette Meldung von e aus
Exception immer am Schluß
Gibt nur Textmeldung von en aus (ohne Uhrzeit, etc.)
da Exception schon erstellt, kann man direkt neuen Wert zuweisen
wird immer ausgeführt
Datumskonvertierung
(es können alle Zahlen 1- oder 2-stellig angegeben werden, Datum nur 4-stellig)
String

Datum
String Datum = "31.03.1999";
Bsp. 01.03.1999 / 1.3.1999 / etc.
int Punkt1 = 0;
int Punkt2 = 0;
for(int z = 0; z < Datum.length();z++)
{
if (Datum.charAt(z) == '.' && Punkt2 == 0) Punkt1 = z;
if (Datum.charAt(z) == '.' && Punkt1 != 0) Punkt2 = z;
}
int Tag = Integer.parseInt(Datum.substring(0,Punkt1));
int Monat = Integer.parseInt(Datum.substring(Punkt1+1,Punkt2));
int Jahr = Integer.parseInt(Datum.substring(Punkt2+1,Datum.length()));
Date Datumneu = new Date(Jahr - 1900, Monat - 1, Tag);
String Datum = "01.03.1999 02:03:06";
Bsp. 1.3.1999 02:03:06 / 1.3.1999 2:3:6
int Punkt1 = 0;
int Punkt2 = 0;
int DPunkt1 = 0;
int DPunkt2 = 0;
for(int z = 0; z < Datum.length();z++)
{
if (Datum.charAt(z) == '.' && Punkt2 == 0) Punkt1 = z;
if (Datum.charAt(z) == '.' && Punkt1 != 0) Punkt2 = z;
if (Datum.charAt(z) == ':' && DPunkt2 == 0) DPunkt1 = z;
if (Datum.charAt(z) == ':' && DPunkt1 != 0) DPunkt2 = z;
}
int Tag = Integer.parseInt(Datum.substring(0,Punkt1));
int Monat = Integer.parseInt(Datum.substring(Punkt1+1,Punkt2));
int Jahr = Integer.parseInt(Datum.substring(Punkt2+1,Punkt2+5));
int Std = Integer.parseInt(Datum.substring(Punkt2+6,DPunkt1));
int Min = Integer.parseInt(Datum.substring(DPunkt1+1,DPunkt2));
int Sek = Integer.parseInt(Datum.substring(DPunkt2+1,Datum.length()));
Date Datumneu = new Date(Jahr - 1900, Monat - 1, Tag, Std, Min, Sek);
/ etc.
CGI
void CGI()
{
String Server = getDocumentBase().getHost();
String cgiScript = "GET /cgi-bin/f98/wenz/bspcgi";
Socket sock = new Socket(Server,80);
DataOutputStream Ausgabe = new Data Output Stream(sock.getOutputStream());
StreamTokenizer Eingabe = new StreamTokenizer(sock.getInputStream());
String sAusgabe = txtInhalt.getText();
sAusgabe = sAusgabe.replace(' ','+');
Ausgabe.writeBytes(cgiScript + "?" + sAusgabe + "\n\n");
String Antwort = "";
while (Eingabe.nextToken() != StreamTokenizer.TT_EOF)
{
Antwort = Antwort + Eingabe.sval + " ";
}
txtAntwort.setText(Antwort);
sock.close();
Thread
public class AusThread extends Thread
Tread-Programm
{
private String
private int
DName;
DMSek;
public AusThread(String pName, int pSek)
{
DName = pName;
DMSek = pSek;
}
static synchronized void Ausgabe(String pName, int pSek)
Zur Synchronisation: Zur gleichen Zeit kann
{
nur einer diese Methode ausführen
System.out.println("Ich gebe eine Meldung aus");
try{ Thread.sleep(pSek); }
catch(InterruptedException e) {}
}
public void run()
Wartet pSek lang und wirft dann Fehler
{
while(true)
{ this.Ausgabe(DName,DMSek); }
}
}
public class Haupt extends java.lang.Object
Hauptprogramm
{
public static void main(String args[])
{
try{
AusThread t1 = new AusThread("Task1", 2000);
Erzeugt Tread
t1.start();
Startet Thread-Ausführung
System.out.println("Fertig");
}
catch(Exception e)
{}
}
}