Archiv des LibreOffice- und OpenOffice.org-Wiki

[ÜberSicht] [TitelIndex] [WortIndex] [SeiteFinden

Diese Seite zeigt eine kurze Referenz zum Kern der Programmiersprache Java.

1. Kommentare

/* mehrzeiliger Kommentar */
// einzeiliger Kommentar

2. Konstanten

5     Dezimalkonstante
05    Oktalkonstante (führende Null)
0x5   Hexadezimalkonstante (führendes 0x)
5L    Long-Konstante (angehängtes L)
2.0F  Float-Konstante (angehängtes F)
2.0   Double-Konstante
'a'   Zeichenkonstante
\b    Escape-Sequenz für Backspace (bs)
\t    Escape-Sequenz für Tabulator, horizontaler (tab)
\n    Escape-Sequenz für Zeilenvorschub (newline, line feed)
\f    Escape-Sequenz für Seitenvorschub (form feed)
\r    Escape-Sequenz für Wagenrücklauf (carriage return)
\"    Escape-Sequenz für Anführungszeichen (double quote)
\'    Escape-Sequenz für Apostroph (quote)
\\    Escape-Sequenz für Backslash ( \ )
\012  numerische Zeichenkonstante
"s"   Stringkonstante
true  wahr
false falsch

3. Elementare Datentypen

byte    // 8 Bits, -128 ... +127
short   // 2 Bytes, -32768 ... +32767
int     // 4 Bytes, -2147483648 ... 2147483647
long    // 8 Bytes, -9223372036854775808 ... 9223372036854775807
char    // 2 Bytes, 0 ... 65535
float   // 4 Bytes, 1.40239846E-45 ... 3.40282347E+38
double  // 8 Bytes, 4.94065645841246544E-324 ... 1.79769313486231570E+308
boolean // true, false

Der Wertebereich kann mit den Eigenschaften MIN_VALUE und MAX_VALUE überprüft werden.

4. Operatoren

.     Komponentenzugriff auf Datenstrukturen
[]    Feldindex
+     Pos. Vorzeichen, Addition, Stringverkettung
-     Neg. Vorzeichen, Subtraktion
*     Multiplikation
/     Division
%     Divisionsrest oder Modulo-Operator
++    Inkrementierungsoperator
--    Dekrementierungsoperator
(typ) numerische Typwandlung
!     Logisches NICHT
&     Binäres, logisches UND
|     Binäres, logisches ODER
^     Binäres, logisches Exklusiv ODER
<<    Binäres Linksschieben
>>    Binäres Rechtsverschieben
>>>   Binäres Rechtsverschieben mit Auffüllen von Nullen
&&    Bedingtes UND
||    Bedingtes ODER
?:    Bedingter Ausdruck (Entweder oder)

5. Vergleichsoperatoren

==          gleich
!=          ungleich
>           größer als
>=          größer oder gleich
<           kleiner als
<=          kleiner oder gleich
instanceof  Typvergleich

6. (Zusammengesetzte) Zuweisungen

=     Wertzuweisung
+=    mit Addition
-=    mit Subtraktion
*=    mit Multiplikation
/=    mit Division
%=    mit Divisionsrestbildung
&=    mit binärem UND
|=    mit binärem ODER
^=    mit binäres Exklusiv ODER
<<=   mit binärem Linksschieben
>>=   mit binärem Rechtsverschieben
>>>=  mit binäres Rechtsverschieben mit Auffüllen von Nullen

7. Deklaration

7.1. Variablendeklaration

int i=5;                 // Variablendeklaration mit Initialisierung
int[] i={1, 3, 5};       // Felddeklaration mit Initialisierung

int[] i;
i = new int[] {1, 3, 5}; // Felderzeugung mit new, und Initialisierung

// mehrdimensionales Feld mit Initialisierung
char[][] matrix = { {'a', 'b', 'c'}, {'d', 'e', 'f'} }; 

7.2. Klassendeklaration (Beispiel)

class Point {                  // Deklaration
  int x;                       // Eigenschaften
  int y;
  void move(int dx, int dy) {  // Methode
    this.x += dx;
    this.y += dy;
  }
} 

7.3. Erzeugung einer Klassenvariablen

Point p = new Point(2,3);

7.4. Aufruf einer Methode

p.move(5,7);

7.5. Syntax der Klassendeklaration

[public] [final|abstract] class Klassenname [extends Basisklassenname] [implements Interfacename1, Interfacename2, ...] {
  Klassenkörper;
} 

7.6. Syntax der Methodendeklaration

[public|protected|private] [static] [abstract|final] [native] [synchronized] ergebnistyp Methodenname [] ( Parameterdeklaration ) [throws Ausnahmetypen] {
  Methodenkörper;
} 

8. Programmablaufsteuerung

8.1. Verzweigung

if(Bedingung) {
  Anweisungen;
} else {
  Anweisungen;
} 

8.2. Mehrfachauswahl

switch(Ausdruck) {
  case Konstante1: {Anweisungen; break;}
  case Konstante2: {Anweisungen; break;}
  case Konstante3: {Anweisungen; break;}
  default:         {Anweisungen;}
} 

8.3. Kopfgesteuerte Schleife

while(Wiederholbedingung) {
  Anweisungen;
} 

8.4. Fußgesteuerte Schleife

do {
  Anweisungen;
} while(Wiederholbedingung); 

8.5. Zählschleife

for(Initialisierung; Wiederholbedingung; Modifizierung) {
  Anweisungen;
} 

8.6. Funktionen und Prozeduren

8.6.1. Statische Deklaration innerhalb von Klassen

class Klassenname {
  static int func(short s) {
    Anweisungen;
    return Wert;
  }
  static void proc(short s) {
    Anweisungen;
  }
} 

8.6.2. Aufruf der Funktion

b = Klassenname.func(5);

8.6.3. Aufruf der Prozedur

Klassenname.proc(5);

9. Klassenpaket deklarieren

package Packagename;

10. Externe Klassen importieren

import Importname;

11. Siehe auch


KategorieSoftware


LizenzBedingungen | AnbieterKennzeichnung | DatenschutzErklärung | Stand: 2013-04-28