Java

abstract double     int        strictfp **
boolean  else       interface  super
break    extends    long       switch
byte     final      native     synchronized
case     finally    new        this
catch    float      package    throw
char     for        private    throws
class    goto *     protected  transient 
const *  if         public     try
continue implements return     void
default  import     short      volatile
do       instanceof static     while

* z.Zt unbenutzt, ** neu in Java 2

     ( )  { }  [ ]  ;  ,  .
     =  - + * / %
     < > ! ? & | ~ 

public class PrimitivTypen { 
  // lexikalische Typen sind int und double 
  // andere direkte Wertzuweisungen müssen   
  // "gecastet" werden z.B.: 
  byte b = (byte)37; 

  short s = (short)37; 
  int i = 37; 
  long l = 37L; 

  float f = 0.37F; 
  double d = 0.37; 
  
  char c = 'K'; 
  boolean b = true; 
}

postfix operators    [] . (params) expr++ expr--
unary operators      ++expr --expr +expr -expr ~ !
creation or cast     new (type)expr
multiplicative       * / %
additive             + -
shift                << >> >>>
relational           < > <= >= instanceof
equality             == !=
bitwise AND          &
bitwise exclusive OR ^
bitwise inclusive OR |
logical AND          &&
logical OR           ||
conditional          ? :
assignment           = += -= *= /= %= &= ^= |= <<=
                     >>= >>>=

public class Operatoren { 

 public void numericalops() { 
  int n = 43; 

  n += 7; // ist eine Abkuerzung von n = n + 7; 
  // dies funktioniert auch mit -, /, >>, etc. 

  n = n * 2; // verdoppelt n 
  n = n / 2; // teilt n ganzzahlig durch 2 
  n = n % 2; // Rest der ganzzahligen Division 

  float f = n / (float)2; // liefert das float- 
                          // Divisionsergebnis 
 } 

 public void logicalops() { 
  boolean bool = true && false; // bool ist false 
  bool = true || false; // bool ist true 
  bool = true == false; // bool ist false 
  bool = false != true; // bool ist true 

  bool = 4 >= 3; // bool ist true 
  bool = 4 <> 4; // bool ist false  
 } 

 public void difficultops() { 
  // definiert ein int-Array mit 8 Eintraegen
  int array[] = new int[8]; 

  if (array[0]++ < 0); 
  // ist gleichbedeutend mit 
  if (array[0] < 0); 
  array[0] = array[0] + 1; 

  if (--array[1] == 2); 
  // ist gleichbedeutend mit 
  array[1] = array[1] - 1; 
  if (array[1] == 2); 

  boolean bool = true; 
  bool = !bool; 
  // ! nimmt eine logische Negierung vor 
  // bool ist jetzt gleich false 

  int conditional = bool == true ? 3 : -2; 
  // conditional ist jetzt -2  
 } 

 public void bitwiseops() { 
  int i = 3; 

  i = i << 1; // i ist jetzt 6 

  i = i & 7; // i ist jetzt 6 

  i = i | 3; // i ist jetzt 7 
 } 
}

Statement         Keyword

decision making   if-else, switch-case
loop              for, while, do-while 

miscellaneous     break, continue, label:, return 

public class Kontrollstrukturen { 
 
  public void decision() { 

    int variable = 2; 
                      
    if (variable > 1 && variable == 2) { 
       variable = variable - 1; 
    } 
    else { 
       variable = variable + 1; 
    } 
                      
    switch (variable) { 
    case 0: 
    case 1: 
            // variable ist 0 oder 1 
            break; 
    case 2: 
            variable = variable * 2; 
            break; 
    default: 
            // variable ist nicht 0, 1 oder 2 
    } 
  } 
                     
  public void loop() { 
         // dreimal die selbe Schleife 
                      
    for (int index = 0; index < 4; index = index + 1) { 
         // tue irgendwas 4 mal 
    } 
                      
    int index = 0; 
    while (index < 4) { 
          index = index + 1; 
    } 
                      
    index = 0; 
    do { 
         index = index + 1; 
    } while (index < 3); 
  } 
                     
  public void miscellaneous() { 
    int i = 0; 
                     
    while (1 > 0) { 
      i = i + 2; 
      if (i > 5) break; // verlaesst die while-Schleife 
      continue; // faengt sofort wieder am  
                // Schleifen-Kopf an 
    } 
                      
    return; // beendet die Methode sofort 
  } 
}