javac {Optionen} Dateiname
Dabei muß der Dateiname mit dem Suffix .java enden und das Präfix muß gleich dem Klassennamen der (Haupt-)Klasse sein, die in der Datei definiert wird.
Optionen sind zur Zeit allerdings noch nicht erforderlich.
public static void main(String[] arg)
enthalten. Der Aufruf genügt folgender Syntax:
java {Optionen} Klassenname {Argumente}.
Optionen sind zur Zeit allerdings noch nicht erforderlich.
.:/usr/local/lib/jdk-1.0.2
import java.io.*;
public class World {
public static void main(String[] arg) {
try {
System.out.println("Hello world!");
}
catch (Exception e) {}
}
}
Token in Java sind:
'W')
<, ==, ...)
In Java haben die Wortzwischenräume - dazu zählen Leerzeichen, Tabulatoren, Zeilenvorschub- und Seitenvorschubzeichen - keine Bedeutung. Sie werden nicht als Token betrachtet sondern dienen lediglich zur Trennung von Token.
Wortzwischenräume sind zur Trennung von Token untereinander notwendig.
Groß- und Kleinschreibung sind in Java von Bedeutung.
'a', 'Q'
Sonderzeichen können durch eine Escape-Sequenz ausgedrückt werden:
\n: Zeilenvorschub
\t: Tabulator
\': Apostroph
\": Anführungsstriche oben
Zeichenvorschubzeichen sind innerhalb von Zeichenketten-Literalen nicht erlaubt.
Beispiel: int anzahl = 0;
Notwendig sind:
Es macht keinen Sinn bswp. folgende Operation durchzuführen:
3-'d'. Ein Compiler muß überprüfen, ob solche Anweisungen
sinnvoll sind.
Aus diesen Gründen werden unterschiedliche Datentypen durch Java bereitgestellt (siehe Abschnitt 5.6).
int i = 2147483647; // (2 hoch 31) - 1 i = i + 1; // danach hat i den Wert -(2 hoch 31)
siehe zunächst Abschnitt 5.6.
-
*
/
%
Diese Operatoren sind binär. Außerdem gibt es noch die unären Operatoren - und + für die Negation bzw. ihr Gegenteil.
! (unär)
&& (binär)
|| (binär)
Es wird nur solange ausgewertet, bis der boolsche Wert feststeht:
if (bA1 && bA2) ...
Falls bA1 schon false ist, wird bA2 nicht mehr ausgewertet.
>: größer als
>=: größer oder gleich
<: kleiner als
<=: kleiner oder gleich
==: ist gleich
!=: ist ungleich
Beispiele:
short s = 3; int i = s; long l = i = s; float f = 3.12f; double d = f; float f = 3; return f/2 * i; (float) int i = f/2; // Fehler int i = 'a';
Beispiele:
double d = 7.99; long l = (long)d; // l == 7 long orig = 91513...1; long verloren = (long)((float)orig); // == 91513...2
Rechnen mit Buchstaben:
char zahl = (char)('0' + 7); // zahl == '7'
Ein Ausdruck ist eine Verarbeitungsvorschrift, deren Ausführung einen Wert liefert. Ausdrücke entstehen, indem Operanden mit Operatoren verknüpft werden. Arithmetische Ausdrücke liefern Zahlenwerte. Boolsche Ausdrücke liefern Wahrheitswerte.
siehe oben
Eine Anweisung (Statement) ist eine Vorschrift zur Verarbeitung von Daten.
Elementare Anweisungen sind nicht weiter in der Sprache zerlegbare Anweisungen (Befehle).
Anweisungen lassen sich zusammensetzen (zusammengesetzte Anweisungen).
Imperative Programmierung bedeutet sequentielles Abarbeiten von Anweisungen einer Programmiersprache.
Die Anweisung, die nur aus dem Semikolon besteht (tut nichts). Beispiel:
int i = 0;;;;;;;;; // semantisch dasselbe wie int i = 0;
<datentyp> <bezeichner> = <ausdruck> ;Der Typ der Variablen und der Typ des Ausdruck müssen zueinander konform sein.
Beispiel:
boolean richtig; int i = 0; float x = 7.1; float y = 9.0; float wert = x + y;
<variable> = <ausdruck> ;Dabei muß die Variable vorher deklariert worden sein. Des weiteren müssen der Typ der Variablen und der Typ des Ausdruck zueinander konform sein.
Beispiel:
int i = 0; // Deklaration int j = i; // Deklaration i = i + j - 3; // Zuweisung
int i=3; int j=4; int k=5; i = j = k; // alle Variablen haben den Wert 5
i = i <op> <ausdruck>; (op: +, -, *, /, %)
entspricht
i <op>= <ausdruck>
und:
i = i + 1; entspricht: i++; bzw. ++i; Inkrement-Operator
i = i - 1; entspricht: i--; bzw. --i; Dekrement-Operator
Bsp:
i = i + 3; enstspricht: i += 3;
a *= b+1; entspricht: a = a * (b+1);
int i = 3;
System.out.println(++i); // druckt 4
System.out.println(i++); // druckt 4
System.out.println(i); // druckt 5
kommt später
Anweisungen lassen sich durch geschweifte Klammern zu einem Block zusammensetzen.
Beispiel:
{
int anzahl = 3;
{
int i = 5;
anzahl = 3 * i;
anzahl = 3 * anzahl;
}
anzahl = anzahl + anzahl;
System.out.println(anzahl);
}
if ( <boolscher Ausdruck> )
<Anweisung1>
else
<Anweisung2>
Dabei wird zuerst der boolsche Ausdruck ausgewertet. Ist sein Wert true,
wird Anweisung1 ausgeführt; im anderen Fall wird bei Vorliegen
eines else-Teils die Anweisung2 ausgeführt. Die Angabe eines
else-Teils ist optional.
Bei der Verschachtelung von if-Anweisungen gehört der else-Teil immer zur innersten möglichen.
Beispiel:
if (i<j) {
System.out.println("i ist kleiner");
} else if (j<i) {
System.out.println("j ist kleiner");
} else {
System.out.println("i und j sind gleich");
}
if (i>1)
if (i>5)
System.out.println("groesser 5");
else
System.out.println("zwischen 2 und 5");
Label müssen eindeutig sein. Bei Labeln handelt es sich um Literale bzw. Konstanten.
Beispiel:
int i = 0;
...
switch (i) {
case 1: System.out.println("i ist 1");
case 2: System.out.println("i ist 1 oder 2");
break;
case 3: System.out.println("i ist 3");
break;
default: System.out.println("i ist weder 1,2 noch 3");
}
while ( <boolscher Ausdruck> ) <Anweisung>Der boolsche Ausdruck wird ausgewertet, ist er true, wird die Anweisung (die i.a. ein Block ist) so lange ausgeführt, bis der boolsche Ausdruck false wird.
Beispiel:
int zahl = 6;
int fak = 1;
int i = 2;
while (i <= zahl) {
fak = fak * i;
i = i + 1;
}
Beispiel:
boolean gefunden = false;
int radius = 1;
while (!gefunden) {
// teste_einen_kreis
int richtungen = 0;
while ((!gefunden) && (richtungen < 4)) {
// teste_eine_richtung
int anzahl_felder = 0;
while ((!gefunden) && (anzahl_felder < radius)) {
vor();
if (korn_da()) {
gefunden = true;
} else {
anzahl_felder = anzahl_felder + 1;
}
}
if (!gefunden) links_um();
// ende teste_eine_richtung
richtungen = richtungen + 1;
}
// ende teste_einen_kreis
radius = radius + 1;
}
do <Anweisung> while ( <boolscher Ausdruck> ) ;Im Unterschied zur while-Schleife wird die Anweisung einer do-Schleife mindestens einmal ausgeführt.
Es sind semantisch äquivalent:
do <Anweisung> while ( <boolscher Ausdruck> ) ;und
<Anweisung> while ( <boolscher Ausdruck> ) <Anweisung>
![[*]](http://www-swl.OFFIS.Uni-Oldenburg.de/icons/latex2html/foot_motif.gif){kind=icon}
Sie hat die Gestalt:
for (<Initialisierung-Ausdruck> ;
<Boolscher Ausdruck> ;
<Inkrement-Ausdruck>
)
<Anweisung>
was i.a. äquivalent ist zu:
<Initialisierung-Ausdruck> ;
while ( <Boolscher Ausdruck> ) {
<Anweisung>
<Inkrement-Ausdruck> ;
}
Im Initialisierungsausdruck wird i.a. eine Schleifenvariable
deklariert oder einer bereits deklarierten ein Wert zugewiesen.
Im Inkrement-Ausdruck wird die Schleifenvariable i.a.
verändert.
Der Initialisierungsausdruck wird genau einmal beim ersten Betreten
der for-Schleife ausgewertet.
Dann wird der boolsche Asudruck überprüft und falls er true
ist die Anweisung ausgeführt. Anschließend wird jeweils
der Inkrement-Ausdruck ausgewertet.
Beispiel:
int zahl = 6;
int fak = 1;
for (int i = 2; i<zahl; i=i+1) {
fak = fak * i;
}
Beispiel:
boolean gefunden = false;
int radius = 1;
while (!gefunden) {
// teste_einen_kreis
for (int richtungen = 0;
!gefunden && (richtungen < 4);
richtungen = richtungen + 1
) {
// teste_eine_richtung
for (int anzahl_felder = 0;
!gefunden && (anzahl_felder < radius);
anzahl_felder = anzahl_felder + 1
) {
vor();
if (korn_da()) {
gefunden = true;
}
}
if (!gefunden) links_um();
// ende teste_eine_richtung
}
// ende teste_einen_kreis
radius = radius + 1;
}
Fehlt der boolsche Asudruck, wird er als true angenommen.
while (true) {
<anweisung>
}
und
for (;;) {
<anweisung>
}
Die Schleifenabbruchbedingung ist hierbei immer true.
<label> : <anweisung>
Eine Marke (Label) als Argument veranlaßt das Programm zu einem Sprung an das Ende der entsprechenden markierten umgebenden Anweisung.
Der Sprung an beliebige Stellen des Programmes (goto) ist in Java nicht erlaubt.
Beispiel:
int radius = 1;
hauptprogramm:
while (true) {
// teste_einen_kreis
for (int richtungen = 0;
richtungen < 4;
richtungen = richtungen + 1
) {
// teste_eine_richtung
for (int anzahl_felder = 0;
anzahl_felder < radius;
anzahl_felder = anzahl_felder + 1
) {
vor();
if (korn_da()) {
break hauptprogramm; // springt nach Punkt 1
}
}
links_um();
// ende teste_eine_richtung
}
// ende teste_einen_kreis
radius = radius + 1;
}
// Punkt 1: die break-Anweisung springt hierhin
Beispiel:
int x = 0;
while (x<10) {
x = x+1;
if (x<10) continue;
System.out.println("x ist 10");
kommt erst später
kommt erst später
siehe Kapitel 11
Eigentlich gibt es in Java keine Prozeduren und Funktionen. Sie
werden hier Methoden genannt und gehören zu bestimmten
Klassen (siehe auch ![[*]](http://www-swl.OFFIS.Uni-Oldenburg.de/icons/latex2html/cross_ref_motif.gif){kind=icon}
).
import java.io.*;
public class proz1 {
public static void ich_bin_eine_prozedur() {
System.out.println("in der Prozedur");
}
public static void main(String[] args) {
try {
System.out.println("vor der Prozedur");
ich_bin_eine_prozedur();
System.out.println("nach der Prozedur");
} catch (Exception e) {}
}
}
import java.io.*;
public class proz2 {
public static void ich_bin_auch_eine_prozedur() {
System.out.println("in der auch-Prozedur");
}
public static void ich_bin_eine_prozedur() {
System.out.println("in der Prozedur");
System.out.println("vor der auch-Prozedur");
ich_bin_auch_eine_prozedur();
System.out.println("nach der auch-Prozedur");
}
public static void main(String[] args) {
try {
System.out.println("vor der Prozedur");
ich_bin_eine_prozedur();
System.out.println("nach der Prozedur");
ich_bin_auch_eine_prozedur();
} catch (Exception e) {}
}
}
import dibo.*;
public class ret1 {
public static void division() {
Terminal.out.println("Zaehler eingeben: ");
int zaehler = Terminal.readInt();
Terminal.out.println("Nenner eingeben: ");
int nenner = Terminal.readInt();
if (nenner == 0) {
Terminal.out.println("Nenner darf nicht 0 sein");
return;
}
Terminal.out.println("Ergebnis: ");
Terminal.out.println(zaehler/nenner);
}
public static void main(String[] args) {
try {
System.out.println("vor der Prozedur");
division();
System.out.println("nach der Prozedur");
} catch (Exception e) {}
}
}
import dibo.*;
public class bin1 {
public static int fak2() {
int zahl = 2;
int fak = 1;
for (int naechste = 2; naechste <= zahl; naechste = naechste + 1) {
fak = fak * naechste;
}
return fak;
}
public static int fak3() {
int zahl = 3;
int fak = 1;
for (int naechste = 2; naechste <= zahl; naechste = naechste + 1) {
fak = fak * naechste;
}
return fak;
}
public static int fak5() {
int zahl = 5;
int fak = 1;
for (int naechste = 2; naechste <= zahl; naechste = naechste + 1) {
fak = fak * naechste;
}
return fak;
}
public static void main(String[] args) {
try {
Terminal.out.println("5 ueber 3 = ");
Terminal.out.println( fak5() / (fak3() * fak2()) );
} catch (Exception e) {}
}
}
import dibo.*;
public class bin2 {
public static int fak(int zahl) {
int fak = 1;
for (int naechste = 2; naechste <= zahl; naechste = naechste + 1) {
fak = fak * naechste;
}
return fak;
}
public static void main(String[] args) {
try {
Terminal.out.println("n eingeben: ");
int n = Terminal.readInt();
Terminal.out.println("m eingeben: ");
int m = Terminal.readInt();
Terminal.out.println(n + " ueber " + m + " = ");
Terminal.out.println( fak(n) / (fak(m) * fak(n-m)) );
} catch (Exception e) {}
}
}
import dibo.*;
public class bin3 {
public static int fak(int zahl) {
int fak = 1;
for (int naechste = 2; naechste <= zahl; naechste = naechste + 1) {
fak = fak * naechste;
}
return fak;
}
public static void main(String[] args) {
try {
Terminal.out.println("n eingeben: ");
int n = Terminal.readInt();
Terminal.out.println("m eingeben: ");
int m = Terminal.readInt();
if ((0 <= m) && (m <= n)) {
Terminal.out.println(n + " ueber " + m + " = ");
Terminal.out.println( fak(n) / (fak(m) * fak(n-m)) );
} else {
Terminal.out.println("Eingabefehler: Es muss gelten 0 <= m <= n");
}
} catch (Exception e) {}
}
}
import dibo.*;
public class bin4 {
public static int fak(int zahl) {
int fak = 1;
for (int naechste = 2; naechste <= zahl; naechste = naechste + 1) {
fak = fak * naechste;
}
return fak;
}
public static int binominalkoeffizient(int n, int m) {
return fak(n) / (fak(m) * fak(n-m));
}
public static void main(String[] args) {
try {
Terminal.out.println("n eingeben: ");
int n = Terminal.readInt();
Terminal.out.println("m eingeben: ");
int m = Terminal.readInt();
if ((0 <= m) && (m <= n)) {
Terminal.out.println(n + " ueber " + m + " = ");
Terminal.out.println(binominalkoeffizient(n, m));
} else {
Terminal.out.println("Eingabefehler: Es muss gelten 0 <= m <= n");
}
} catch (Exception e) {}
}
}
import dibo.*;
public class guelt {
public static void P(int x) {
int y = 0;
int i = 0;
...
}
public static void Q(int x) {
int y = 0;
int w = 0;
...
}
public static void main(String[] args) {
int i = 0;
...
int j = 0;
...
{
...
int v = i;
...
i = v;
...
P(i);
}
...
j = i;
...
{
...
int w = 0;
int v = w;
...
w = 4;
...
}
...
}
}
public static int fak(int n) {
if (n == 0)
return 1;
else
return n * fak(n-1);
/*
| | |
# | |
### | |
##### | |
####### | |
----------------------------------------------
1 2 3
Gegeben: 3 Pfosten mit n Scheiben
Ziel: Lege alle n Scheiben von 1 nach 3
Restriktion: Immer nur eine Scheibe bewegen
Restriktion: Niemals groessere auf kleinere Scheibe legen
*/
import dibo.*;
public class Hanoi {
public static void main(String[] args) {
char zahl = (char)('0'+7);
Terminal.out.println(zahl);
int hoehe = Terminal.readInt();
verlegeTurm(hoehe, 1, 3, 2);
}
public static void verlegeTurm(int hoehe,
int von,
int nach,
int ueber
) {
if (hoehe > 0) {
verlegeTurm(hoehe-1, von, ueber, nach);
Terminal.out.println(von + "-" + nach);
verlegeTurm(hoehe-1, ueber, nach, von);
}
}
}
/* Ausgabe fuer hoehe=4:
1-2 1-3 2-3 1-2 3-1 3-2 1-2 1-3 2-3 2-1 3-1 2-3 1-2 1-3 2-3
*/
fehlt noch