Java Syntaxsammlung

Java Syntaxsammlung
Nachfolgende Syntaxbeispiele ersetzen keine syntaktisch vollständige Sprachbeschreibung. Meist werden Kodierempfehlungen formuliert.
Bei allen Variablennamen, Klassennamen, Methodennamen gilt : Groß- und Kleinschreibung beachten !

Syntax Beispiel Bemerkung
unäre Operatoren ++ -- int i = 0;
i++; //jetzt steht 1 in i
arithmetische Operatoren
* / % + -
Vergleichsoperatoren
< kleiner als
größer als
>= größer gleich
== identisch
!= ungleich
logische Operatoren
& logisches und
| logisches oder
^ logisches xor
! logisches nicht
Basisdatentypen
Name Länge in byte Werteintervall
//interessant nur % modulo
int i = 12;
i = i % 7; //5 in i
//in logischen Ausdrücken
int i = 8;
int j = -3;
boolean b = (i >= j);
//in b steht jetzt true
if(i

Syntax Beispiel Bemerkung
Implizite Typumwandlung und cast
Folgende Datentypen werden implizit
(automatisch) ineinander umgewandelt:
char ⇾ int
byte ⇾ short
short ⇾ int
int ⇾ long
long ⇾ float
float ⇾ double
Eine Typumwandlung kann man mit cast
erzwingen.
Der cast hat die Syntax:
(neuerdatentyp)
Felder
feld deklarieren
feldelementtyp [] name;
feld instanzieren
name = new feldelementtyp[laenge];
feld deklarieren und instanzieren
feldelementtyp [] name =
new feldelementtyp[laenge];
oder
feldelementtyp[] name = {Werteliste};
feld Index
feldname[index]
char vc = 'z';
float f;
f = vc; //in f steht 122.0
int i = 127;
byte b;
b = (byte)i; //die 127 passt so
//gerade eben in b rein
int[] x;
double[][] matrix;
int[] x;
x = new int[50];
byte[] b = new byte[10];
int[] x = {1,2,7,-3};
int[] x = {1,2,7,-3};
j = x[0]; //in j steht 1
j = x[2]; //in j steht 7
Es wird implizit (automatisch) immer von "wenig
Speicherplatz" nach "Mehr Speicherplatz"
gewandelt..
Beim erzwungenen Typumwandeln mittels cast
können Datenverluste und Verfälschungen
vorkommen:
int i = (int)47.11; // 47 in i
x ist 1-dim Feld von unbekannt vielen int-Werten
matrix ist 2-dim Feld von unbekannt vielen double-
Werten
x ist 1-dim Feld mit 50 int-Werten
b ist 1-dim Feld mit 10 byte-Werten
x ist 1-dim Feld mit 4 int-Werten
Der Feldindex beginnt immer bei 0

Syntax Beispiel Bemerkung
Verzweigungen
if(logischer Ausdruck){
//wenn true
}
if(logischer Ausdruck){
//wenn true
}else{
//wenn false
}
switch(variable) {
case konstante_1:
//anweisungen
break;
...
case konstante_n:
//anweisungen
break;
}
default:
//anweisungen
break;
if(j>0 & i0 | k

Syntax Beispiel Bemerkung
Schleifen
for(Start; Endebedingung; Schritt){
//anweisungen
}
while(logischer Ausdruck){
//anweisungen
}
do{
//anweisungen
}while(logischer Ausdruck);
String
String s;
int i = 4711;
double d = 47.11;
s = "textabc "+i+"/"+d;
System.out.println(s);
textabc 4711/47.11
int i,j=0;
for(i=1; i

Syntax Beispiel Bemerkung
Modifikatoren für Klassen, Klassenvariablen, Klassenmethoden und Konstruktoren
leer nur im eigenen packet sichtbar
Klasse Klassenmethode Klassenvariable Konstruktoren
in allen Klassen des eigenen packet
sichtbar
in allen Klassen des eigenen
packet sichtbar
in allen Klassen des eigenen
packet sichtbar
public in allen packet's sichbar in allen Klassen sichtbar in allen Klassen sichtbar in allen Klassen sichtbar
private
protected
static
nur in geschachtelten Klassen erlaubt,
sonst verboten. Ineinander
geschachtelte Klassendefinitionen
werden aber i.d.R. nicht verwendet
nur in geschachtelten Klassen erlaubt,
sonst verboten. Ineinander
geschachtelte Klassendefinitionen
werden aber i.d.R. nicht verwendet
nur in geschachtelten Klassen erlaubt,
sonst verboten. Ineinander
geschachtelte Klassendefinitionen
werden aber i.d.R. nicht verwendet
final Klasse kann nicht vererben
nur innerhalb der eigenen Klasse
sichtbar
innerhalb der eigenen Klasse sichtbar,
innerhalb des eigenen packet sichtbar,
in allen abgeleiteten Klassen sichtbar
Methode gehört nur zur Klasse, nicht zu
einer Klasseninstanz (mit new gebildet)
Methode ist in abgeleiteter Klasse nicht
überschreibbar
nur innerhalb der eigenen
Klasse sichtbar
innerhalb der eigenen Klasse
sichtbar, innerhalb des eigenen
packet sichtbar, in allen
abgeleiteten Klassen sichtbar
Variable gehört nur zur Klasse,
nicht zu einer Klasseninstanz
(mit new gebildet) verboten
nicht überschreibbar (also eine
Konstante) verboten
abstract Abstrakte Klasse : keine Instanz erlaubt Methode hat keinen { } Block verboten verboten
Klassen
modifikatoren class name{
// Sinnvoller Inhalt einer Klasse:
// 1. alle Klassenvariablen (auch
// Attribute genannt)
// 2. alle Konstruktoren
// 3. alle Methoden
}
public class auto{
private double ps; //Klassenvariable
public auto(){ //Standardkonstruktor
this.ps = 0;
}
public double in_kw(){// eine Methode
return this.ps * 0.735499;
}}
nur innerhalb der eigenen
Klasse sichtbar
innerhalb der eigenen Klasse
sichtbar, innerhalb des eigenen
packet sichtbar, in allen
abgeleiteten Klassen sichtbar
Als Modifikatoren sind leer, public und final in
allen Kombinationen erlaubt.

Syntax Beispiel Bemerkung
Klassenvariablen (auch Attribute genannt)
modifikatoren typ name; class beispiel{
private int a;
public short s;
protected char p;
Konstruktoren
modifikatoren
klassenname(parameterliste){
}
}
final int d = 12;
static long l;
class beispiel{
}
//Standardkonstruktor
//mit leerer Parameterliste
public beispiel(){
//anweisungen
}
//noch ein Konstruktor
public beispiel(int i, double x){
//anweisungen, dabei stehen
//die Variablen i und x zur
//Verfügung
}
Kombinierbarkeit der Modifikatoren
final mit static,public,private,protected
static mit final,public,private,protected
Klassenvariablen werden innerhalb der Klasse mit
this.variablenname aufgerufen
Klassenvariablen (auch Klassenattribute) können
auch Felder und Klasseninstanzen sein.
Ein Konstruktor darf niemals einen Rückgabetyp
haben.
Ein Konstruktor muss immer den Namen der
Klasse haben.
Konstruktoren innerhalb einer Klasse unterscheiden
sich durch ihre unterschiedliche
parameterliste.
Eine parameterliste ist entweder leer (kein
Parameter) oder ist
typ1 variablenname1, typ2 variablenname2, ...

Syntax Beispiel Bemerkung
Methoden
modifikatoren rückgabetyp methodenname (parameterliste){
}
class beispiel{
}
//...Klassenvariablen und Konstruktoren
//Methoden der Klasse
public int getintegerwert(){
// anweisungen
return k; //k ist int
}
private void macheetwas(int k, float x, boolean b){
//die Variablen k, x, b stehen zur Verfügung
//anweisungen
}
Vererben
modifikatoren class subklassenname extends superklassenname{
//...
}
public class kind extends eltern{
//anweisungen wie in class
}
Methoden müssen einen Rückgabetyp haben.
Wenn kein Wert mit return zurückgegeben
werden soll, muß als rückgabetyp void
gesetzt werden.
Methoden dürfen auch mehrere return
Anweisungen haben
Sichtbarkeit von Elementen der Elternklasse
public überall
protected Elternklasse und
Kindklasse
private Elternklasse

Syntax Beispiel Bemerkung
Vererben, Zugriff auf super-Klasse
//Zugriff auf Standardkonstruktor der super Klasse
super();
//Zugriff auf Konstruktor der super Klasse mit Parametern
super(werteliste);
//Zugriff auf Klassenvariable der super (Eltern)klasse
super.variable_aus_eltern;
//Zugriff auf Methode der super (Eltern)klasse
super.methode_aus_eltern(parameterliste);
abstract
abstract methoden
abstract sichtbarkeitsmodifikator rückgabetyp methodenname(parameterliste);
abstract public void elternmethode1(int var1, double var2);
abstract protected boolean elternmethode2();
abstract Klassen
abstract sichtbarkeitsmodifikator class Klassenname{
//Klassendefinition
}
abstract class Dim3Koerper {
//Konstruktoren DUERFEN NICHT abstract sein
public Dim3Koerper() {
}
//Abstrakte Methoden
protected abstract double volumen();
//protected double abstract Achtung: Diese Reihenfolge der
Es gelten hier die Sichtbarkeitsregeln aus
Vererben
super(4711, "noch ein String!");
1. Als sichtbarkeitsmodifikatoren
sind leer, public, protected erlaubt;
2. private ist verboten!
3. static und final sind verboten !
4. Es gibt keinen Anweisungsblock { }
sondern statt dessen ein Semikolon ;
1. eine Klasse ist abstract, wenn
mindestens eine Methode der Klasse
abstract ist
2. eine abstract Klasse kann nicht
instanziert werden , d.h. kein Objekt
erzeugen
3. Beim Vererben muss eine abgeleitete
Subklasse alle abstract Methoden der
super Klasse überschreiben (Inhalt
definieren) oder sie ist selber wieder
abstract

Syntax Beispiel Bemerkung
}
interface
interface definieren
//modifikatoren GEHT NICHT!
abstract protected double oberflaeche();//das geht
// abstrakte Methoden MIT Parametern sind erlaubt
abstract protected double testmitparametern(int i, double b);
modifikator interface Interfacename
{
modifikatoren Typ Variable=Wert;
abstract modifikator Typ
methodenname();
}
interface wird von anderen Interfaces ableiten
modifikator interface Interfacename
extends SuperInterfaceliste
{
// Anweisungen für Interface
}
class wird um interfaces erweitert
modifikator class klassenname
implements Interfaceliste
{
// Anweisungen für Klasse
}
interface vektoraddition {
public Vektor plus(Vektor v);
public Vektor minus(Vektor v);
}
4. Als sichtbarkeitsmod sind erlaubt leer und
public.
public class Vektor implements vektoraddition, vektormultiplikation
{
//...
}

Syntax Beispiel Bemerkung
try catch
try{
//anweisungen, bei denen etwas
//falsch laufen kann
}
catch(exceptiontyp variable){
//anweisungen, falls Fehler
// exceptiontyp vorliegt
}
int j = 0;
try{
i = i/j;
}
catch(ArithmeticException e){
System.out.println("Fehler");
}
try{
//anweisungen zum Öffnen, Schreiben, Lesen und Schliessen einer Datei
}
catch(FileNotFoundException e){
//etwas Sinnvolles tun
}
catch(IOException e){
//etwas Sinnvolles tun
}
Datei I/O FileReader / FileWriter
Einem try-Block können mehrere
catch-Blöcke mit unterschiedlichen Exceptions
folgen.
Einem try-Block muß mindestens ein catch-
Block folgen.
In den try-Block kommen die Anweisungen, die
zum Programmabbruch führen können, in die
catch-Blöcke kommen die Anweisungen, die
dann ausgeführt werden.
Dateizugriffe müssen in einem try-catch
Konstrukt eingebettet sein.
FileWriter fw = new FileWriter(new File("testdatei2.txt")); Eine Datei mit dem angegebenen Namen wird in
jedem Fall neu angelegt.
Eine bestehende Datei mit dem gleichen Namen
wird überschrieben
FileWriter fw = new FileWriter(new File("testdatei2.txt"), true); Eine Datei mit dem angegebenen Namen wird ineu
angelegt, falls sie noch nicht existiert.
An eine schon bestehende Datei mit dem gleichen
Namen wird Text angehängt.
//Eine Textzeile / einen String in eine Datei schreiben
String zeile1 = "Das ist die eine Zeile in der Datei";
fw.write(zeile1+"\n");
Schreiben eines Strings in eine (vorher geöffnete
Datei).
Soll ein Zeilenvorschub nach dem String
ausgeführt werden, muß hier ein “\n“ an den String
angehängt werden.(Bei Windows "\n\r")

Syntax Beispiel Bemerkung
//Es wird eine Zeichenkette aus einer Datei gelesen
try{
File f = new File("testdatei2.txt");//Objekt File erzeugen
FileReader fr = new FileReader(f); //FileReader für File öffnet Datei
puffer = new char[(int)f.length()]; //char[] Feld für Dateiinhalt
int anzahlgelesen = fr.read(puffer);//Zeichenkette in puffer
}
catch(FileNotFoundException e){}//etwas Sinnvolles tun
catch(IOException e){} //etwas Sinnvolles tun
//Eine (vorher geöffnete) Datei schliessen
fr.close();
Datei I/O Bytestreams / Binärdaten
Binärdaten schreiben
double d = 234.56E+124; //zwei Basisdatentypen
long l = 23456711; //als Beispiel
try{
File v = new File("testdateibinaer1"); //Dateizugriff
einrichten
FileOutputStream fos = new FileOutputStream(v); //Datei öffnen
DataOutputStream dos = new DataOutputStream(fos);//DataStream öffnen
dos.writeDouble(d); //einen double-Wert schreiben (8byte)
dos.writeLong(l); //einen long-Wert schreiben (8 byte)
dos.close(); //die Ressourcen freigeben
fos.close();
}
catch(FileNotFoundException e){//etwas Sinnvolles tun}
catch(IOException e){//etwas Sinnvolles tun}
FileReader öffnet eine existierende Datei. Gibts die
Datei nicht, wird eine Exception
FileNotFoundException ausgelöst.
Jede geöffnete Datei muß (nach Gebrauch) wieder
geschlossen werden.
Klasse DataOutputStream stellt Methoden zur
Binärdatenausgabe für alle Basisdatentypen zur
Verfügung

Syntax Beispiel Bemerkung
Binärdaten lesen
try{
File v = new File("testdateibinaer1"); //Dateizugriff einrichten
FileInputStream fis = new FileInputStream(v); //Datei öffnen
DataInputStream dis = new DataInputStream(fis); //DataStream öffnen
double d_input = dis.readDouble(); // mit Methoden für jeden Basisdatentyp
long l_input = dis.readLong(); // aus DataInputStream binäre Daten lesen
dis.close(); //die Ressourcen freigeben
fis.close();
}
catch(FileNotFoundException e){//etwas Sinnvolles tun}
catch(IOException e){//etwas Sinnvolles tun}
Konsolen I/O
von der Konsole (Tastatur) lesen
BufferedReader tastatur = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Bitte Text eingeben : ");
String zeile = "";
try {
zeile = tastatur.readLine();
} catch (IOException e) {
// was tun
}
auf den Bildschirm schreiben
System.out.println("Folgendes wurde eingetippt : " + zeile);