|
|
www.guentherschulz.de
|
|
|
Programmierbeispiele Java
|
Inhaltsverzeichniss
Kommentare im Programm
Klassen vorab, ein lauffähiges Programm
Bildschirmausgabe auf Standart Out
Literale
Variablenvereinbarung
Operatoren
Verzweigung
Wiederholung
while
for
Das Switch Statement
Klassen Einführung
Definieren einer Klasse
Definieren von Datenmitgliedern
Definieren von Funktionsmitgliedern
Klassen Vertiefung
Zugriffskontrolle
Objektreferenzen
Felder
Laufzeitfehler bearbeiten, die Exceptions
Dateizugriff
Java als Applet
Kommentare im Programm
// mit zwei Vorwärtsschrästrichen, gilt nur für diese Zeile
/* mit Vorwärtsschrägstrich und Sternchen, gilt bis mit
Sternchen Vorwärtsschrägstrich der Kommentar beendet wird. */
Seitenindex
Klassen vorab, ein lauffähiges Programm
// Jede Funktion, auch die hier gezeigt Funktion main(), die beim Start
// eines Programms aufgerufen wird, muss in einer Klasse sein, hier in
// der Klasse prog
public class prog
{
public static void main(String args[])
{
// Hauptfunktion, wird beim Start der Klasse aufgerufen.
// Die Datei unter dem Klassennamen mit dem Anhang ".java"
// abspeichern. Der Dateiname heißt allso
// Klassennamen.java
// Vorsicht, java unterscheidet zwischen Groß- und
// Kleinschreibung bei Klassen und Dateinamen.
// Desweiteren hat die Main-Funktion "public" zu sein.
// laut Buch muss die definition exact so sein, wie oben
// eingegeben, stimmt das ?
}
}
Seitenindex
Bildschirmausgabe
// System ist ein Objekt, das auf das System verweist, in dem das
// Programm ausgeführt wird. Out ist das default output Gerät
System.out.println(" string "); // ein string in einer Zeile
System.out.println(" string1 " + " string2"); // zwei string in einer Zeile
Seitenindex
Literale
String Literale
"Das ist ein Stringliteral" // Ein Stringliteral ist ein in Gänse-
// füßchen eingeschlossener Text
Character Literale
\n Neue Zeile
\t Horizontaler Tabulator
\b Backspace
\r Carriage return
\f Form feed
\' Halbes Gänsefüßchen
\" Gänsefüßchen
\\ Backslash
Beispiel
System.out.println(" zusätzlicher Zeilenvorschub\n ");
char cChar1;
cChar1 = '\n'; // cChar1 beinhaltet einen Zeilenvorschub
Integer Literale
Alle folgenden Literale haben denselben Wert
0377 Literale die mit einer "0" beginnen sind oktal
0xff die mit 0x beginnen sind hexadezimal
0XFF die mit 0X beginnen sind ebenfals hexadezimal
255 ohne prefix, die sind dezimal
Beispiel
char cChar1;
char cChar2;
cChar1 = 0x42; // cChar1 und cChar2 beinhalten das
cChar2 = 'B'; // selbe Zeichen
Seitenindex
Variablenvereinbarung
von Variablentypen, die Java selbst beinhaltet
// Vor dem Benutzen einer Variable ist zu beachten, daß sie
// initialisiert werden muss, also es muß ihr ein Wert zugeordnet
// werden
boolean bFlag; // Boolsche Variable
byte yByte; // ein Byte, zum Vereinbaren von Feldern
char cEinZeichen; // zum Vereinbaren von einem Zeichen
short sKurz; // nummerischer Wert
int nInteger; // nummerischer Wert
long lLong; // nummerischer Wert
float fFloat; // nummerischer Wert
double dDouble; // nummerischer Wert
// initialisieren bei der Vereinbarung
int nIntegerVariable = 0;
// Wird vor dem Variablentyp ein static angegeben, wird die Variable
// nicht im Objekt sondern in einem gemeinsamme Speicherbereich der
// Klasse gespeichert. Dies ist wichtig, wenn z.B. kein Applet sonder
// eine Java Anwendung geschrieben wird, da die main()-Funktion
// als static definiert werden muss und damit auch die Klassenvariablen
// auf die aus main() zugegriffen werden muss.
static int m_iInteger
// Wird einer Variablenvereinbarung final static vorangestellt,
// ist ihr Wert nicht mehr veränderbar, praktisch eine
// Konstante
final static int m_iJahr = 1778;
von Feldern
int iFeld[] = new int[10]; // Variable iFeld, ein Feld mit 10 Elementen
int iFeld2[][] = new int[10][10]; // Variable iFeld2, ein Feld
// mit 10 mal 10 Elementen
Umwandeln von Typen, z.B. long in integer
long lLong;
int iInteger;
iInteger = 100;
lLong = (long) iInteger; // man stellte vor die Quellvarialble den
// gewünschten Typ in runden Klammern davor
Umwandeln von Typen, z.B. char in byte und umgekehrt
byte bByte;
char cChar;
bByte = (byte) 'A';
cChar = (char) bByte;
Seitenindex
Operatoren
Operatoren an Integer und Fließkommazahlen
unäre Operatoren
++ eine nummerische Variable um eins erhöhen
binäre Operatoren
+ zwei nummerische Variablen zusammenzählen
- eine nummerische Variable von einer anderen abziehen
Operatoren an Boolsche Variablen
Operatoren an Strings
+ fügt zwei Strings zusammen
Seitenindex
Verzweigung
// Das if Statement
if (i == 10) // führt den If Zweig aus, wen i = 10 ist
{
// Statements
}
else // führt den else Zweig aus, wenn i nicht 10 ist
{
// Statements
}
Seitenindex
Wiederholung
Die while Schleife
Kopfgesteuer, wird evtl. garnicht durchlaufen
while (i < 10)
{
// statements
}
Fußgesteuert, wird auf jeden Fall einmal durchlaufen
do
{
// statements
} while ( i < 10);
Abbrechen einer Schleife, der Befehl break
ohne Sprungadresse
do
{
// statements
break; // mit break wird eine Schleife sofort beendet.
} while ( i < 10);
mit Sprungadresse
do
{
// statements
break EinSprungsPunkt; // es wird zum Punkt EinSprungsPunkt gesprungen.
} while ( i < 10);
// Statements
EinSprungsPunkt:
Abbrechen einer Schleife, der Befehl continue
while (i < 10)
{
// statements
continue; // Die Steuerung wird ab hier der schließenden
// Klammer der Schleife übergeben, der Rest der
// Schleife wird in diesem Durchlauf also nicht ausgeführt
// weiter statements
}
Die for Schleife
for (i=0;i<10; i++) // (i bekommt Startwert; solange i kleiner ist als 10;
// i bei jedem durchlauf um 1 erhöhen
{
// statements
}
Seitenindex
Das Switch Statement
switch (i)
{
case 1 : // statement
// statement
break; // ohne break würeden auch die anderen case
// geprüft werden
case 2 :
case 3 :
default :
}
Seitenindex
Klassen Einführung
Definieren einer Klasse
class MeineErste
{
// Die Daten- und Funktionsmitglieder einer Klasse
// Datenmitglieder
double m_dDouble; // eine nummerische Variable des Typs double
int m_iInteger; // eine nummerische Varialbe des Typs integer
// Funktionsmitglieder
static void BildschirmAusgabe()
{
System.out.println("Funktion Bildschirmausgabe");
}
public static void main(String args[])
{
BildschirmAusgabe();
}
}
Definieren eines Datenmitglieds
Datenmitglieder werden gebraucht, um die Dateneigenschaften einer
Klasse zu beschreiben. Es werden die selben Regeln wie das Vereinbaren
von lokalen Variablen genommen, mit der Ausnahme, daß man
dem Variablennamen ein "m_", für Member, voranstellt.
// Datenmitglieder
double m_dDouble; // eine nummerische Variable des Typs double
int m_iInteger; // eine nummerische Varialbe des Typs integer
Definieren eines Funktionsmitglieds
Alle Funktionen im Java müßen Mitglieder einer Klasse
sein. Die Definition einer Methode beginnt mit dem Datentyp, den sie
mit return zurückgibt. Wenn die Methode nichts zurückgibt,
hat sie den Typ void. Der erste Buchstabe einer Methode ist gewöhnlich
ein Großbuchstabe. Den Methodennamen folgen Runde Klammern, in diese
sind, wenn nätig, die Parameter angegeben. Wenn es mehrere Parameter
sind, werden sie durch Komma getrennt.
public class g // Klasse unter g.java abspeichern
{
static void BildschirmAusgabe()
{
System.out.println("Funktion Bildschirmausgabe");
}
public static void main(String args[])
{
BildschirmAusgabe();
}
}
public class g // Klasse unter g.java abspeichern
{
static int m_iInteger = 4;
static int EinsDazuzaehlen(int i)
{
i = i + 1;
return i;
}
public static void main(String args[])
{
m_iInteger = 100;
System.out.println(EinsDazuzaehlen(4) + " " + m_iInteger);
}
}
Seitenindex
Zugriffskontrolle
Schlüsselwort Bedeutung
kein Schlüsselwort Zugriff für alle Methoden des selben Packages
public Zugriff erlaubt für alle Methoden in allen Klassen
private Zugriff nur für Mitglieder derselben Klasse
Diese Schlüsselworte gelten für Daten- und Funktionsmitglieder
Seitenindex
Objektreferenzen
// Eine Referenz ist eine Variable, die die Adresse eines Objekts
// speichert
MeineKlasse MeinObjekt; // erzeugt eine Variable, in der ein Verweiss
// aus ein Objekt der Klasse MeineKlasse speichern
// kann.
MeinObjekt = new MeineKlasse(); // Weist die Referenz auf das neu erzeugte
// Objekt der Variablen MeinObjekt zu.
MeineKlasse MeinObjekt = new MeineKlasse(); // die zwei Statements oben
// in einer Zeile
// Übergibt man eine Variable in Java an eine Funktion, kann deren
// daruch nicht verändert werden. Den Wert einer Variable kann
// dadurch verändert werden, daß man deren Referenz allso
// die "Adresse des Speicherplatzes" übergibt.
// Durch Rekursieven Aufruf einer Klasse kann eine "Linked List" erzeugt
// werden.
Seitenindex
Felder
// Felder werden als Objekt mit dem new Befehl erzeugt.
// Ihre Referenz wird in einer Variablen gespeichert
// speichert
int iFeld[] = new int[20]; // Erzeugt ein integer Feld mit 20 Elementen
// durch die [] hinter dem Variablennamen
// weiß der Compiler daß es eine
// Referenz auf ein Feld ist.
int[] iFeld2 = new int[30]; // Die eckigen Klammern kann man auch
// hinter den Typ schreiben.
Seitenindex