• Java Applikationen
• Java - Applets
• Grundlagen der Javaprogrammierung
• Datentypen
• Primitive Datentypen
• Referenzen
• Strings
• Arrays
• Zweidimensionale Felder (Matrizen)
• Eingabe von Tastatur
• Schleifen
• while - Schleife
• for - Schleife
• Auswahl treffen mit if und switch
• if - Anweisung
• switch - Anweisung
• Klassen
• Elementare Datentypen/Operatoren

Java ist eine rein objektorientierte und plattformunabhängige Programmiersprache. Die Syntax von Java ähnelt der von C++. Man  unterscheidet eigenständige Programme (Applikationen) und Programme für WWW-Seiten (Applets).

1.) Java Applikationen

Grundstruktur einfacher Java Programme:

// Kommentar: Dieser Kommentar erstreckt sich bis zum Zeilenende.
/* Kommentar: Dieser Kommentar kann über mehrere Zeilen gehen.
   Alles was zwischen  /* und */ ist ein Kommentar
*/

import Paketname                                                  // ähnlich dem #include ... in C++

class willkührlicher Name
{
public static void main(String[] args)                  // Hauptmethode
   {
      Vereinbarung von Variablen                           // In diesem Bereich stehen alle Definitionen und
      Anweisungen                                                   // Befehle des Programms
   }
}

class anderer_willkührlicher Name
{
public static void main(String[] args)                  // Hauptmethode
   {
      Vereinbarung von Variablen                           // In diesem Bereich stehen alle Definitionen und
      Anweisungen                                                   // Befehle des Programms
   }
}
...

Im Gegensatz zu C++ sind in Java die Klassen die fundamentalen Einheiten und nicht die Quelltextdateien. Ein Java-Programm besteht fast ausschliesslich aus Klassen. Die Importstatements sind lediglich Abkürzungen für viele verschiedene Klassen. Generell sollte aber jede Klasse in ein eigenes File gespeichert werden.

Über die Importstatements können vordefinierte Klassen, z.B. für die Ein- und Ausgabe, der Erzeugung von graphischen Oberflächen usw, benutzt werden. Die vordefinierten Klassen von Java sind in Paketen organisiert. Mit Paketen lassen sich verwandte Klassen gruppieren. Die Gesamtheit dieser Pakete bildet das API (Application Programming Interface).

Übersicht über die Pakete, die wir in Java benutzen werden.
      java.awt: Dies ist das abstract windowing toolkit. Es enthält Klassen zur Grafikausgabe und
                        zur Erzeugung von graphischen Benutzeroberflächen (GUI).
      java.io: Klassen zur Ein- und Ausgabe.
      java.lang:  Dieses Paket wird automatisch geladen. Es enthält wichtige Dinge, wie z.B die
                          String-Klasse.
      java.util: Enthält einige Datenstrukturen, wie wachsende Arrays oder auch Stapelspeicher
                      sowie andere nützliche Dinge wie Random Number Generator.

Der Quelltext des Java-Programms wird mit einem Text-Editor (z.B. nedit) erstellt. Die Textdatei muß den gleichen Namen wie public class und die Erweiterung .java haben.

Beispiel 1:

//Programm Hallo.java
//Das Programm Hallo gibt das Wort Hallo auf dem Bildschirm aus.

class Hallo
{
 public static void main(String[] args)
 {
  System.out.println("Hallo!");
 }
}

Der Java Compiler (javac) überprüft den Quelltext und erzeugt aus der Hallo.java Datei eine
entsprechenden Hallo.class Datei.

> javac  Hallo.java

Im Gegensatz zu C++ benötigt man zur Ausführung des Proramms einen Interpreter,  den Java Interperter java:

> java  Hallo

Beispiel 2:

/*Diese Quelltextdatei enthält zwei völlig unabhängigen Programme. Das Programm Hallo gibt das Wort Hallo und das Programm Tschuess das Wort Tschuess auf den Bildschirm aus*/

class Hallo
{
 public static void main(String[] args)
 {
  System.out.println("Hallo!");
 }
}

class Tschuess
{
 public static void main(String[] args)
 {
  System.out.println("Tschuess!");
 }
}

> javac HalloTschuess.java

> ls
Hallo.class
Tschuess.class

Der Compiler hat zwei separate class Dateien angelegt, die  unabhängig voneinander ausgeführt werden können.

> java Hallo
Hallo!

> java Tschuess
Tschuess!
 

2.) Java Applets

Der Quelltext des Java-Applets wird in einem Text-Editor erstellt und unter dem gleichen Namen wie public class mit der Erweiterung .java abgespeichert.

Beispiel 3:

//Programm Hallo.java

import java.applet.Applet;
import java.awt.Graphics;

public class Hallo extends Applet
{
 public void paint(Graphics g)
 {
  g.drawString("Hallo", 50, 25);
 }
}

Um das Applet  zu compilieren gibt man im Terminal folgendes Kommando ein:

> javac  Hallo.java

Applets besitzen keine main-methode und können somit nicht durch den Java interpreter gestartet werden. Man braucht dafür ein HTML-File:

<HTML>

<HEAD>
<TITLE>Hallo Applet</TITLE>
</HEAD>

<BODY>
<APPLET CODE="Hallo.class" WIDTH=150 HEIGHT=25>
</APPLET>
</BODY>

</HTML>

Das HTML-file darf einen beliebigen Namen mit der Erweiterung .html tragen.
Der Aufruf erfolgt in einem Appletviewer oder Web-Browser (z.B. netscape).

> appletviewer Hallo.html &

oder alternativ:

> netscape Hallo.html &
 

Grundlagen der Javaprogrammierung

Datentypen:

Java unterscheidet zwei Arten von Datentypen: Primitive Datentypen und Referenzen.

1.)Primitive Datentypen:

In Java  gibt es 8 primitive Datentypen: boolean, char, byte, short, int, long, float und double (siehe Anhang).

Eine Variable besitzt einen bestimmten Datentyp und enthält einen Wert. Jede Variable erhält einen eindeutigen Namen, der ihr zugeordnet wird, wenn die Variable deklariert wird. Die Deklaration einer Variablen ist auch gleichzeitig eine Definition, wobei Speicherplatz für die Variable reserviert wird.

Syntax für Variablendeklaration:  Typename Variablenname;

Beispiel:
int j;

Variablendeklaration mit gleichzeitiger Initialisierung:

Typename Variablenname = Anfangswert;

Beispiel:
int j = 3;

Beispiel 4:

//Programm: primitive Datentypen

public class primitiv
{
 public static void main(String[] args)
 {
   // Deklaration + Initialisierung primitiver Datentypen
   int i = 4;
   double x = 3.14;
   boolean b = true;
   char c = 'A';

   // Ausgabe auf dem Bildschirm
   System.out.println("i = " + i);
   System.out.println("x = " + x);
   System.out.println("b = " + b);
   System.out.println("c = " + c);
  }
}

Output:
i = 4
x = 3.14
b = true
c = A

Der Ausdruck "i = " + i ist folgendermassen zu verstehen:
Bei "i = " handelt es sich um eine Stringkonstante. Das "+"-Zeichen  dient zur Verbindung  zweier Strings miteinander. Da i ein primitiver Datentyp ist, muß es in einen String umgewandelt werden. Dies geschieht automatisch.

Die Operatoren sind bereits aus C++ bekannt (siehe Anhang). In Beispiel 5 wird nochmal die Verwendung des Inkrement-Operators verdeutlicht.

Beispiel 5:

// Programm ABC1

public class ABC1
{
 public static void main(String[] args)
 {
  char c = 'A';

  System.out.print(c);
  ++c;
  System.out.print(c);
  ++c;
  System.out.println(c);
  }
}

Output:
ABC

2.)Referenzen:

Als Refenrenzen werden die Objekte einer Klasse bezeichnet. Objekte sind "Variablen" des Datentyps Klasse und  enthalten sowohl Variablen, die die Eigenschaften des Objekts definieren, als auch  Methoden, die das Verhalten des Objekts beschreiben.

Objekte werden durch die Verwendung des new - Operators erzeugt, der einen Konstruktor zur Initialisierung des Objekts aufruft (siehe Klassen).

Syntax für Variablendeklaration:  Klassenname Referenzvariablenname;
Die deklarierte Variable ist eine Referenz auf ein Objekt der Klasse.
Um ein  Objekt zu erzeugen braucht man den new-Operator.
Syntax für die Erzeugung eines bestimmten Objekts (Instanz): new Klassenname(Startwerte);
Der new-Operator liefert eine Referenz auf ein bestimmtes Objekt der Klasse. Dieser Zeiger kann der Referenzvariablen mit dem Namen Referenzvariablenname zugewiesen werden:

                                        Referenzvariablenname = new Klassenname(Startwerte);

Variablendeklaration mit gleichzeitiger Initialisierung:

                            Klassenname Referenzvariablenname = new Klassenname(Startwerte);

Beispiel:
vektor u;
u = new vektor(2,4);

oder kürzer:
vektor u = new vektor(2,4);

Den Vektor u nennt man auch eine Instanz der Klasse vektor, er stellt einen Vektor mit den Komponenten x = 2 und y = 4 dar. Genau genommen ist u ein Verweis auf ein bestimmtes Objekt der vektor-Klasse. Objekte werden aber üblicherweise mit den Namen ihrer Referenz identifiziert, man spricht also im allgemeinen  einfach vom Objekt u.
 

Strings:

String ist in Java ein echter Datentyp und nicht wie in C++ ein künstliches Array von Zeichen.
Genauer: Strings sind Objekte der Klasse java.lang.String.
Für Strings sind Stringkonstanten definiert, die mit "..." gekennzeichnet werden.
Man kann daher beispielsweise schreiben:          String s="Dies ist eine String-Konstante";
Die wichtigste Rechenoperation mit Strings ist die Addition +. Diese Addition hängt zwei Strings hintereinander. Auch primitive Datentypen können zu Strings hinzuaddiert werden, wobei sie vorher automatisch in einen String umgewandelt werden. Zur Manipulation von Stringobjekten stehen in der Stringklasse zahlreiche Methoden zur Verfügung wie z.B.

length():  Bestimmung der Länge eines Strings.
substring(): Erzeugung von Substrings.
charAt(): Ausgabe von Buchstaben an bestimmten Indexpositionen.
toLowerCase() bzw. toUpperCase(): Umwandlung auf Klein- bzw. Großbuchstaben.
indexOf(): Ausgabe der Indexpositionen bestimmter Buchstaben.

Beispiel 6:

// Programm ABC

public class ABC
{
 public static void main(String[] args)
 {
  // Deklaration des Objekts abc. Es ist eine Instanz der Stringklasse.
  String abc = "ABC";

  System.out.println(abc);

  System.out.println();

  //Bestimmung der Laenge des Strings mit der Methode length()
  System.out.println("Methode length(): ");
  System.out.print("Diese Zeichenkette enthaelt ");
  System.out.print(abc.length());
  System.out.println(" charakters.");

  System.out.println();

  //Ausgabe der Charakter an bestimmten Indexpositonen mit der Methode charAt()
  System.out.println("Methode charAt(): ");
  System.out.println("Der Charakter abc[0] ist " + abc.charAt(0));
  System.out.println("und der Charakter abc[2] ist " + abc.charAt(2));

  System.out.println();

  //Ausgabe eines Substrings mit der Methode substring()
  System.out.println("Methode substring(0,2): ");
  System.out.println(abc.substring(0,2));

  System.out.println();

  //Aenderung von ABC zu abc mit der Methode toLowerCase()
  System.out.println("Methode toLowerCase(): ");
  System.out.println("Vorher: " + abc);
  System.out.println("Nachher: " + abc.toLowerCase());
 }
}

Output:
ABC

Methode length():
Diese Zeichenkette enthaelt 3 charakters.

Methode charAt():
Der Charakter abc[0] ist A
und der Charakter abc[2] ist C

Methode substring(0,2):
AB

Methode toLowerCase():
Vorher: ABC
Nachher: abc

Im nächsten Beispiel wird die Methode indexOF() beschrieben.  Sie liefert die Indexpositionen bestimmter Buchstaben in einem String. Für die Funktion indexOf() gibt es mehrere Varianten, die sich in der Anzahl ihrer Parameter unterscheiden. In diesem Beispiel wird die Methode indexOf() mit ein und zwei Parametern benutzt. Dies wird als Überladen (overloading) einer Methode bezeichnet.

Beispiel 7:

// Programm: Suche Charakters in einem String

public class charsuche
{
 public static void main(String[] args)
 {
  // Deklaration des Objekts Zeichenkette.
  String Zeichenkette = "Hallo";

  System.out.println(Zeichenkette);

  System.out.println();

  //Suche Charakter a in der Zeichenkette mit der Methode indexOf()
  System.out.println("Methode indexOf(): ");
  System.out.print("Der Index des Charakters a ist: ");
  System.out.println(Zeichenkette.indexOf('a'));

  System.out.println();

  //Suche Charakter l in der Zeichenkette mit der Methode indexOf()
  System.out.println("Methode indexOf() mit ein und zwei Parametern: ");
  System.out.print("Der erste Index des Charakters l ist: ");
  int i = Zeichenkette.indexOf('l');
  System.out.println(i);
  System.out.print("Der naechste Index des Charakters l ist: ");
  System.out.println(Zeichenkette.indexOf('l', i + 1));
 }
}

Output:
Hallo

Methode indexOf():
Der Index des Charakters a ist: 1

Methode indexOf() mit ein und zwei Parametern:
Der erste Index des Charakters l ist: 2
Der naechste Index des Charakters l ist: 3

Um Strings, die Ziffern enthalten, in entsprechende Zahlenwerte umzuwandeln benutzt man folgende statische Methoden wie z.B.

int  Integer.parseInt(String)
short  Short.parseShort(String)
long  Long.parseLong(String)
float  Float.valueOf(String).floatValue()
double Double.valueOf(String).doubleValue()

Beispiel 8:

//Programm: Konvertierung String zu Integer

public class konvertierung
{
 public static void main(String[ ] args)
 {
  //Deklaration der Stringklassenobjekte
  String Zeichenkette = "Heute ist der 12. Januar 2001";
  String DatumString = Zeichenkette.substring(14,16);

  //Konvertierung DatumString nach DatumInt
  int DatumInt = Integer.parseInt(DatumString);

  //Berechnung des Datums der nächsten Woche
  int neuesDatumInt = DatumInt + 7;

  //Ausgabe auf den Bildschirm
  System.out.println(Zeichenkette);
  System.out.println("Nächste Woche ist der " + neuesDatumInt + ". Januar 2001");
 }
}

Output:
Heute ist der 12. Januar 2001
Nächste Woche ist der 19. Januar 2001

Arrays:

Arrays sind Datenfelder, in denen sich mehrere Datenelemente befinden, wobei auf die einzelnen Daten über einen Index zugegriffen werden kann. Sämtliche Daten haben zwar denselben Namen, können aber eindeutig vom Programm über eine Nummer angesprochen werden. Bei der Erzeugung eines Array-Objekts gibt man die Anzahl der Daten an, die das Feld speichern soll, sowie den für sämtliche Daten gültigen Datentyp.

Array-Deklaration:                                                      Datentyp[ ]   Feldname

Feldname ist der Name einer Referenzvariablen, die also eine Referenz auf das Feld enthält.
Syntax für die Erzeugung eines Array-Objekts: Feldname = new Datentyp[Anzahl]

Variablendeklaration mit gleichzeitiger Initialisierung:

                                             Datentyp[ ]  Feldname = new Datentyp[Anzahl]

Beispiel :    int[ ]  a = new int[100];
Man hat dann 100 Variablen vom Typ int: a[0], a[1], ..., a[99].
Ein Array kann bei der Deklaration mit Werten bestückt werden, so dass new nicht mehr notwendig ist.
Beispiel :  int[ ]  a = {1,5,3,...}
Die Länge des Feldes erhält man mit Feldname.length.

Beispiel 9:

public static void main(String[] args)
 {
  // Deklaration und Initialisierung eines Arrays auf int-Variablen.
  int[ ] a;
  a = new int[4];

  //Ausgabe der ersten int-Variable
  System.out.println("a[0] = " + a[0]);

  //Erzeugung von 4 int-Variablen
  a[0] = 1;
  for (int i = 1; i < a.length; i++)
     a[i] = 2*i;

  //Ausgabe der Arrays auf dem Bildschirm
  for (int i = 0; i < a.length; i++)
  {
   System.out.print("a[" + i + "] = ");
   System.out.println(a[i]);
  }
 }
}

Output:
a[0] = 0
a[0] = 1
a[1] = 2
a[2] = 4
a[3] = 6

Veranschaulichung:

int[] a;

Beispiel 10:Array von Stringobjekten

class array2
{
 public static void main(String[] args)
 {
   // Deklaration und Initialisierung eines Arrays auf String-Objekte.
   String[] s;
   s = new String[4];

   //Ausgabe des ersten String-Objekts
   System.out.println("s[0] = " + s[0]);

   //Erzeugung von 4 Stringobjekten
   s[0] = new String("ABC");
   for (int i = 1; i < s.length; i++)
       s[i] = new String();
   s[3] = "Hallo";

   //Ausgabe der 4 Stringobjekte auf dem Bildschirm
   for (int i = 0; i < s.length; i++)
   {
     System.out.print("s[" + i + "] = ");
     System.out.println(s[i]);
    }
 }
}

Output:
s[0] = null
s[0] = ABC
s[1] =
s[2] =
s[3] = Hallo

Veranschaulichung:

String[] s;

Zweidimensionale Felder (Matrizen):

Eine Matrix kann man auffassen als einen Array, dessen Elemente wieder Arrays sind.

Matrix-Deklaration:                                                    Datentyp[ ][ ]   Feldname
Syntax für die Erzeugung eines Matrix-Objekts: Feldname = new Datentyp[Anzahl1][Anzahl2]

Variablendeklaration mit gleichzeitiger Initialisierung:

                                             Datentyp[ ][ ]  Feldname = new Datentyp[Anzahl1][Anzahl2]

Beispiel :    int[ ][ ]  matrix = new int[2][2];        // 2x2=Matrix
Man hat dann 4 Variablen vom Typ int: matrix[0][0], matrix[0][1], matrix[1][0], matrix[1][1].
Eine Matrix kann bei der Deklaration mit Werten versehen werden. In diesem Fall ist kein new notwendig.
Beispiel :
/*Matrix: 1 2
                3 4     */
int[ ][ ]  matrix ={{1, 2},{3,4}}

Beispiel 11:

// Programm Matrix: Ein- und Ausgabe der Matrix:

class matrix
{
 public static void main(String[] args)
 {
   int[ ][ ]  Matrix = {{1,2,3},{4,5,6}};

   for (int i = 0; i < Matrix.length; i++)
   {
     for (int j = 0; j < Matrix[i].length; j++)
        System.out.print(Matrix [i][j] + " ");
     System.out.println();
  }
 }
}

Output:
1 2 3
4 5 6
 

Eingabe von Tastatur:

Für die Eingabe von Tastatur muß das Package java.io importiert werden. Dieses Package enthält Klassen, die für die Datenein- bzw. ausgabe verwendet werden können. Die Eingabe von Tastatur wird nun folgendermaßen implementiert:

class Eingabe
{
  public static void main (String[ ] args) throws Exception
   {
     // Eingabe von Tastatur
     InputStreamReader reader = new InputStreamReader(System.in);
     BufferedReader input = new BufferedReader(reader);
     String text = input.readLine();
   }
}

oder etwas kürzer:

class Eingabe
{
public static void main (String[] args) throws Exception
   {
    // Eingabe von Tastatur
    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
    String text = input.readLine();
   }
}

Beispiel 12 liest einen String von der Tastatur ein und gibt diesen wieder auf dem Bildschirm aus.

Beispiel 12:

import java.io.*;

public class eingabe
{
 public static void main (String[ ] args) throws Exception
 {
    // Eingabe Wort
    InputStreamReader reader = new InputStreamReader(System.in);
    BufferedReader input = new BufferedReader(reader);
    System.out.print("Gib ein Wort ein: ");
    String text = input.readLine();
    System.out.println("Die eingegebene Wort lautet: " + text);
 }
}

Output:
Gib ein Wort ein: Hallo
Die eingegebene Wort lautet: Hallo

Achtung:
Will man mit eingelesenen Strings, die Zahlen representieren, Rechenoperationen durchführen, so muß der String zunächst mit geeigneten Methoden in einen elementaren Datentyp (double, int ...) umgewandelt werden.

Beispiel 13:

// Programm zur Berechnung einer Kreisflaeche

import java.io.*;

public class kreisflaeche
{
  public static void main (String[ ] args) throws Exception
   {
    // Eingabe Radius r
    InputStreamReader reader = new InputStreamReader(System.in);
    BufferedReader input = new BufferedReader(reader);
    System.out.print("Gib einen Radius ein: ");
    String text = input.readLine();

    /* Der Multiplikationsoperator * kann nicht auf Objekte angewandt werden.
    Das Stringobjekt text wird mit der Methode double.valueOf(String).doubleValue()
    in eine Variable r vom Typ double umgewandelt.*/
    double r = Double.valueOf(text).doubleValue();
    double flaeche = Math.PI * r * r;
 

    // Ausgabe der berechneten Kreisflaeche auf dem Bildschirm
    System.out.println("Die Flaeche eines Kreises mit dem Radius r = " + r
       + " ist " + flaeche);
   }
}

Output:
Gib einen Radius ein: 5
Die Flaeche eines Kreises mit dem Radius r = 5.0 ist 78.53981633974483
 

Schleifen:

Schleifen dienen zur Wiederholung von Anweisungen. Die Wiederholung wird durch eine Bedingung kontrolliert, die nach jeder Wiederholung überprüft wird. Innerhalb einer Schleife sollte es eine Veränderung derart geben, daß die Bedingung irgendwann einmal unwahr wird, so daß die Schleife abbricht.

1.) while - Schleife:

     Syntax: while (Bedingung)  Anweisung bzw. {Anweisungen}

Die Anweisung wird ausgeführt, solange die Bedingung wahr ist. Die Bedingung wird zuerst geprüft und danach die Anweisung ausgeführt. Wenn die Bedingung von vornherein unwahr ist, wird die Anweisung nicht ausgeführt.

Beispiel 14:

//Programm while-Schleife

public class whileSchleife
{
  public static void main (String[] args)
  {
    int summe = 0;
    int i = 1;

    while (i <= 10)
    {
      summe += i;                                                        // summe = 1 + 2 + ... + 10
      i++;
    }
    System.out.println("Summe = " + summe);
  }
}

Output:
Summe = 55

2.)for - Schleife:

    Syntax: for (Initialisierung; Bedingung; Wertänderung)  Anweisung bzw. {Anweisungen}

Beispiel 15:

//Programm for-Schleife

public class forSchleife
{
  public static void main (String[] args)
  {
    int summe = 0;

    for (int i = 0; i <= 10; i++)
      summe += i;                                                        // summe = 1 + 2 + ... + 10

    System.out.println("Summe = " + summe);
   }
}

Output:
Summe = 55

Die erste Anweisung in der Klammer initialisiert die Laufvariable i (int wird nur gebraucht, wenn i noch keinen Typ zugewiesen bekommen hat). Die Schleife wird solange ausgeführt, wie die zweite Anweisung wahr ist. Falls die Bedingung wahr ist, wird die Anweisung und die Veränderung der Laufvariablen ausgeführt.

Auswahl treffen mit if und switch:

Eine if - Anweisung erlaubt die Auswahl zwischen 2 Möglichkeiten. Durch Verschachtelung kann eine Auswahl zwischen mehreren Möglichkeiten getroffen werden. Dies kann bei größerer Verschachtelungstiefe sehr unübersichtlich werden. Einfacher und übersichtlicher ist dann die Fallunterscheidung mit switch.

1.) if - Anweisung:
 

Syntax:	if (Bedingung)	//Anweisung1 wird nur ausgeführt
	Anweisung1	//wenn die Bedingung erfüllt ist.
	else	//Ansonsten wird Anweisung2 (else-
	Anweisung2	//Zweig) ausgeführt.

Zur Zweifachauswahl gehört auch der bedingte Ausdruck:

Syntax:  Bedingung ? Ausdruck1 : Ausdruck2

Falls die Bedingung wahr ist, ist der Wert des gesamten Ausdrucks der Wert von Ausdruck1, ansonsten der Wert von Ausdruck2. Ein Ausdruck mit dem Bedingungoperator kann lesbarer durch eine if - Anweisung ersetzt werden, wie das folgende Beispiel zeigt.

Beispiel 16:

/*Programm Vergleich. Dieses Programm vergleicht zwei vom Benutzer eingebene Zahlen und gibt die größere von beiden aus.*/

import java.util.Random;

public class Vergleich
{
  public static void main(String[] args)
 {
   Random random = new Random();

   int a = random.nextInt();
   int b = random.nextInt();

   System.out.println("a = " + a);
   System.out.println("b = " + b);

   //Möglichkeit 1
   if (a < b)
   {
    System.out.print("Die groessere der beiden Zahlen ist: ");
    System.out.println(b);
   }
   else
   System.out.println("Die groessere der beiden Zahlen ist: " + a);

   //Möglichkeit 2
   System.out.print("Die groessere der beiden Zahlen ist: ");
   System.out.println(a < b ? b : a);
 }
}

Output:
a = 1072087113
b = 56928871
Die groessere der beiden Zahlen ist: 1072087113
Die groessere der beiden Zahlen ist: 1072087113

Die Klasse Random steht im Paket java.util, und wird mit dem Befehl import java.util.Random hinzugefügt.  Zufallszahlen werden durch die Erzeugung eines Random-Objekts und unter Verwendung seiner Methode  nextInt() generiert.
Die nextInt() Methode generiert eine Zufallszahl vom Typ int im Intervall -2147483648 bis 2147483647.  Bei den Methoden  nextFloat() und nextDouble() wird eine Zufallszahl im Intervall 0 bis 1 erzeugt.

2.) switch - Anweisung:
 

Syntax:	switch (ganzzahliger Ausdruck)
	{   case const1: Anweisungen; break;
	case const2: Anweisungen; break;
	...
	default: Ersatzanweisungen;
	}

Für die Fallunterscheidung wird ein ganzzahliger Ausdruck ausgewertet und der Programmablauf nach dem case fortgesetzt, dessen Konstante mit dem Wert des Ausdrucks übereinstimmt.
Wichtig: Nach Ausführung der entsprechenden Anweisungen wird nicht automatisch aus der
                switch - Anweisung gesprungen. Erst break führt zum Verlassen von switch.

Beispiel 17:

/* Programm Monat - gibt zu jedem Monat die Anzahl der Tage aus.*/

import java.io.*;

public class monat
{
  public static void main (String[] args)throws Exception
  {
    InputStreamReader reader = new InputStreamReader(System.in);
    BufferedReader eingabe = new BufferedReader(reader);
    System.out.print("Gib einen Monat ein: ");
    String Monat = eingabe.readLine();

    int MonatInt = Integer.parseInt(Monat);

    if ((MonatInt > 0) && (MonatInt <= 12))
    {
     switch (MonatInt)
     {
      case 2: System.out.println("Der Monat hat 28 Tage."); break;
      case 4: case 6: case 9: case 11: System.out.println("Der Monat hat 30 Tage."); break;
      default: System.out.println("Der Monat hat 31 Tage."); break;
     }
    }
    else System.out.println("Es wurde kein Monat eingegeben.");
  }
}

Output:
Gib einen Monat ein: 12
Der Monat hat 31 Tage.

Klassen:

Klassen sind die fundamentalen Einheiten in Javaprogrammen. Die Definition einer Klasse wird mit dem Schlüsselwort class und dem Namen der Klasse eingeleitet.

Syntax:
class Klassename
{
  public Klassenname (Parameterliste)                  //Konstruktor
 {
   }

  Datenfelder;

  //Statische Methoden
  Modifier static Rückgabedatentyp   Methodenname(Parameterliste)
 {
  }

   ...

  //Methoden für Instanzen
  Modifier Rückgabedatentyp   Methodenname(Parameterliste)
  {
   }

   ...

public static void main(String[] args)              // Hauptmethode
   {
     Vereinbarung von Variablen und Objekten;
     Methodenaufrufe;
     Sonstige Anweisungen;
   }
}

Konstruktoren dienen zur Initialisierung der mit dem Befehl new erzeugten Objekte.

Methoden:

Methoden entsprechen den Funktionen oder Prozeduren in konventionellen Programmiersprachen.  In Java unterscheidet man statische Methoden und Methoden für Instanzen.
 

Definition

Statische  Methoden: Modifier static Rückgabedatentyp   Methodenname(Parameterliste) {   Anweisungen;   return Wert;             //nur wenn die Funktion einen Rückgabe-  }                                 //datentyp ungleich void hat. Methoden für Objekte: Modifier  Rückgabedatentyp   Methodenname(Parameterliste) {   Anweisungen;   return Wert;              //nur wenn die Funktion einen Rückgabedatentyp ungleich void hat  }

Aufruf

Statische Methode: Methodenname(Parameterliste) Methoden für Instanzen: Objektname.Methodenname(Parameterliste)

Als Modifier betrachten betrachten wir im folgenden nur:

Modifier	Bedeutung
public	Methoden immer zugänglich
private	Methode kann nicht direkt von außen angesprochen werden

Wenn private statt public angegeben wurde, kann die Methode von außen nicht direkt angesprochen werden (siehe Kapselung).

Alleinstehende Funktionen, die nicht Methoden einer Klasse sind, werden nicht unterstützt.

Statische Methoden (static):

Wenn man vor dem Typ einer Methode das Wort static angibt, dann kann diese Methode aufgerufen werden, ohne daß vorher ein Objekt der Klasse erzeugt werden muß. Statische Methoden sind durch das Schlüsselwort static gekennzeichnet.

Anwendungsbeispiele für statische Methoden:

• main-Methode, mit der die Ausführung jeder Java-Applikation beginnt.
• Mathematische Methoden, die mit primitiven Datentypen arbeiten (s. Bsp. 18 und  19 )

// Produkt zweier Zufallszahlen, die die Werte 0,1,...,10 annehmen koennen.

import java.util.Random;

public class produkt
{
 public static void main(String[] args)
 {
   Random random = new Random();

   float x = random.nextFloat();
   float y = random.nextFloat();
   int i = Math.round(10 * x);
   int j = Math.round(10 * y);

   System.out.println("i = " + i);
   System.out.println("j = " + j);
   System.out.println("Das Produkt ist: " + Produkt(i,j));
  }

  static int Produkt(int zahl1,int zahl2)
   {
    return zahl1*zahl2;
   }
}

Output:
i = 2
j = 5
Das Produkt ist: 10

Mathematischen Funktionen sind in der Klasse Math erklärt. Alle diese Funktionen müssen mit vorangestelltem Math. aufgerufen werden. Math.round ist eine statische Methode.

Beispiel 19:

// Lese 3 Zufallszahlen vom Typ Integer ein und gib die groesste Zahl aus.

import java.util.Random;

public class groessteZahl
{
 public static void main(String[] args)
 {
   Random random = new Random();

   int z1 = random.nextInt();
   int z2 = random.nextInt();
   int z3 = random.nextInt();

   System.out.println("z1 = " + z1);
   System.out.println("z2 = " + z2);
   System.out.println("z3 = " + z3);
   groesste_Zahl(z1, z2, z3);
 }

   static void groesste_Zahl(int zahl1,int zahl2, int zahl3)
   {
   if (zahl2 > zahl1) zahl1 = zahl2;
   if (zahl3 > zahl1) zahl1 = zahl3;
   System.out.println("Die groesste Zahl ist: " + zahl1);
   }
}

Output:
z1 = 782963524
z2 = 979697827
z3 = 561274094
Die groesste Zahl ist: 979697827

Methoden für Instanzen:

Methoden von Instanzen beziehen sich (wie der Name schon sagt) immer auf bestimmte Objekte. Beim Aufruf einer Methode für ein Objekt spricht man auch vom Senden einer Botschaft (Message) an das Objekt:

Beispiel 20:

//Programm Vektoren.

public class vektor
{
 private double x, y;

 public vektor (double a, double b)                                     //Konstruktor
 {
  x = a;
  y = b;
 }

 public void print()
 {
  System.out.println("(" + x + ", " + y + ")");
 }

 public void spiegeln(vektor u)
 {
   x = -u.x;
   y = -u.y;
 }

 public static void main(String[] args)
 {
   vektor u = new vektor(2,4);
   System.out.print("Vektor u = ");
   u.print();
   vektor v = new vektor(0,0);
   System.out.print("Vektor v = ");v.print();
   v.spiegeln(u);
   System.out.print("Vektor v = ");v.print();
 }
}

Output:
Vektor u = (2.0, 4.0)
Vektor v = (0.0, 0.0)
Vektor v = (-2.0, -4.0)

Beispiel 22:

//Programm Vektoren.

public class vektor
{
 private double x, y;

 public vektor (double x, double y)                                     //Konstruktor
 {
  this.x = x;
  this.y = y;
 }

  public String toString()
 {
  return new String("(" + x + ", " + y + ")");
 }

 public void spiegeln(vektor u)
 {
   x = -u.x;
   y = -u.y;
 }

 public static void main(String[ ] args)
 {
   vektor u = new vektor(2,4);
   System.out.println("Vektor u = " + u);

   vektor v = new vektor(0,0);
   System.out.println("Vektor v = " + v);
   v.spiegeln(u);
   System.out.println("Vektor v = " + v);
 }
}

Output:
Vektor u = (2.0, 4.0)
Vektor v = (0.0, 0.0)
Vektor v = (-2.0, -4.0)

Innerhalb der Klasse kann man das aktuelle Objekt dieser Klasse mit dem symbolischen Namen this ansprechen, wenn eine Unterscheidung von gleichnamigen lokalen Variablen oder Parametern notwendig ist.
Anstelle der Ausgabemethode print() kann eine bereits in der Stringklasse definerte Methode toString() benutzt werden. Sie liefert eine Zeichenkette in einem neuen Exemplar von  String zurück. Das hat in unserem Beispiel den Vorteil, daß man die Objekte auf die gewohnte Art mit dem Befehl System.out.println() ausgeben kann.