Motivation

Auf dieser Seite lernen Sie wie man die wichtigsten Teile der Sprache Java nennt. Zum Beispiel die Teile einer Zuweisung:

Schlüsselwörter

Java Schlüsselwörter sind:

Die Schlüsselworte in Kategorien gruppiert ergeben:

The Schlüsselworte const und goto sind reserviert auch wenn sie im Moment nicht benutzt werden.

true und false sind technisch gesehen boolsche Literale. (Java 7 Spez. §3.10.3). Das Gleiche gilt für das null Literal (Java 7 Spez. §3.10.7).

Namen (Identifier)

Siehe Java Spezifikation: Identifier

Regeln für Namen in Java:

1. Gültige Namen dürfen nur aus Buchstaben, Ziffern, und den Zeichen "_" und "$" bestehen. Sie dürfen beliebig lang sein.
2. Das erste Zeichen muss ein Buchstabe, "_" oder  "$" Zeichen sein.
3. Leerzeichen sind nicht erlaubt
4. Schlüsselworte der Sprache Java dürfen nicht verwendet werden. (Boolsche Literale und das null Literal dürfen auch nicht verwendet werden)
5. Groß- und Kleinschreibung von Buchstaben wird unterschieden

Literale

Literale dienen zum Beschreiben konkreter Werte in der Sprache Java.

Die Syntax wurde mit Hilfe von regulären Ausdrücken beschrieben.

Zahlen

• Ganzzahlen
  • Dezimalzahlen mit den Ziffern 0 bis 9 und Vorzeichen
    • Beispiele: 1, -19, 45678
  • Hexadezimalen mit den Ziffern 0 bis 9 und als Ziffer interpretierte Zeichen a bis f und einer Präfix 0x
    • Beispiele: 0x1, 0xffff, 0xcafebabe
  • Oktalzahlen mit den Ziffern 0 bis 7 und einer vorgestellten 0
    • Beispiel 012 (=1*8¹+2*8⁰=10₁₀ ,  077 (=7*8¹+7*8⁰=63₁₀)
• Gleitkommazahlen,
  • dargestellt im vertrauten Dezimalsystem
    • Nachkommateil durch Punkt abgetrennt
      • Beispiel: 5.4, 6. (stellt Gleitkommazahl 6.0 dar)
  • Zehnerpotenzen zur Basis Zehn werden mit dem Buchstaben e oder E bezeichnet
    • Beispiel: 4E-2 stellt 4*10^-2= 0.04 da.

Ab JDK 7: Gruppierung in Zahlenliteralen

Seit JDK 7 sind durch die Integration des Projekts "Coin" (JSR 334) die Gruppierung von Zifferngruppen in Zahlenliteralen durch den Tiefstrich '_' möglich.

Der JSR Spezifikation entnommene Beispiele der neuen Syntax:

1234_5678
1_2_3_4__5_6_7_8L
0b0001_0010_0100_1000
3.141_592_653_589_793d
0x1.ffff_ffff_ffff_fP1_023 // Double.MAX_VALUE

nicht erlaubt sind:

_1234
0x_1234
1234_
0x1.0_p_-1022

Warnung: Java 7,8,9 werden noch nicht überall eingesetzt:

• Bei Verwendung von javac Javaübersetzern von JDK 5 oder 6 wird diese Syntax nicht akzeptiert
• Bei Verwendung des Javaübersetzers mit Optionen zur Verwendung alter Syntaxstandards wie javac -source 1.6 in JDK 7,8,9 wird die neue Syntax auch nicht akzeptiert werden!

Zeichen und Zeichenketten

• Zeichen: Ein einzelnes Zeichen (char) wird in einfachen Hochkommas geschrieben
  • Beispiele: 'a', '2', '!', ' '
• Zeichenketten: in Doppelhochkamma eingeschlossene Folgen von Zeichen
  • Beispiele: "Das ist eine Zeichenkette", 
  • Tipp: Zeichenketten dürfen nicht über den Zeilenrand hinwegreichen!

Zeichenketten ohne Namen nennt man Literale.

Kommentare

Kommentare erlauben das Dokumentieren eines Programmes. Sie werden vom Übersetzer ignoriert.

Java benutzt das Kommentarkonzept auch zur Generierung von Dokumentation. Dokumentationskommentare sind eine Sonderform der Kommentare und werden im Abschnitt zur Dokumentation vorgestellt.

Zeilenkommentare, Zeilenendkommentare

Zeilenkommentare beginnen nach dem doppelten Schrägstrich //. Der Javaübersetzer wird alle Zeichen hinter diesem Kommentarzeichen bis zum Ende der Zeile ignorieren.

Beispiel:

int a = 17; // Dies ist ein Zeilenendkommentar
// Dieser Kommentar umfasst eine ganze Zeile
int b = 18;

Mehrzeilige Kommentare

Java erlaubt es eine ganze Reihe von Zeilen als Kommentar zu kennzeichnen. Mehrzeilige Kommentare werden mit den Zeichen "/*" (Schrägstrich Stern) eingeleitet und mit der Zeichenkombination "*/" (Stern Schrägstrich) beendet. Hiermit kann man ganze Bereiche als Kommentar markieren.

Beispiel:

/* Hier beginnt ein Kommentar
diese Zeile gehört zum Kommentar
int i=1; diese Zeile wird nicht als Befehl sondern als Kommentar verarbeitet
der Kommentar endet in der nächsten Zeile
*/

Die Typen die ein Entwickler in Java vewendet sind entweder primitive Datentypen oder komplexe Datentypen. Die beiden Kategorien unterscheiden sich in den folgenden Eigenschaften:

Im nachfolgenden Diagramm wird die Klassifikation der wichtigsten Typen gezeigt:

Die nächsten beiden Abschnitte behandeln die hier gezeigten Typen. Der dritte Abschnitt beschäftigt sich mit den Risiken von Zuweisungen zwischen Datentypen mit unterschiedlichen Wertebereichen.

Ausdrücke

Ausdrücke in Java sind alles was einen Rückgabewert liefert:

• Konstanten
• Variablen
• Methoden
• Operatoren

Operatoren

Java verfügt über

• unäre (einstellige, monadische) Operatoren
• binäre (zweistellige, dyadische) Operatoren
• einen dreistelligen (ternären, tryadischen) Operator (den Bedingungsoperator "_ ? _ : _")

Unäre Operatoren haben einen einzigen Operanden. Beispiele sind: Vorzeichenoperator: -a Postinkrement: a++ Negation: !a

Binäre Operatoren haben zwei Operanden. Beispiele sind: Addition:  a + b logischer Vergleich: a ==  b

Arithmetische Operatoren

Die arithmetischen Operatoren können auf die folgenden Typen angewendet werden

• byte
• short
• int
• long
• float
• double

Die Division von Ganzzahlen ergibt immer ganzzahlige Ergebnisse!

Java arbeitet ohne eine Erkennung des Überlaufs der Wertebereiche. Der Entwickler muss selbst die entsprechenden Vorsichtsmaßnahmen ergreifen.

Weiterhin gibt es einstellige (unäre) arithmetische Operatoren

Die folgen drei Anweisungen bewirken das gleiche:

a = a + 1;
a++;
++a;

Bei Inkrementen mit gleichzeitiger Zuweisung ergeben jedoch unterschiedliche Werte für den zugewiesenen Wert

Beispiel

package s1.block2.skript;
public class PrePostFixTest {
    public static void main(String[] args) {
        int x = 10;
        int y = 100;
        System.out.println("x = " + x + "; y = " + y);
        x++;
        System.out.println("x++ results in " + x);
        ++x;
        System.out.println("++x results in " + x);
        System.out.println("Set x to 0 ");
        x=0;
        System.out.println("x = " + x + "; y = " + y);
        y=x++;
        System.out.println("y=x++ (Postfix)");
        System.out.println("x = " + x + "; y = " + y);
        y=++x;
        System.out.println("y=++x (Prefix)");
        System.out.println("x = " + x + "; y = " + y);
}

.
.
.
.
.
x = 10; y = 100
.
x++ results in 11
.
++x results in 12
Set x to 0
. 
x = 0; y = 100
.
y=x++ (Postfix)
x = 1; y = 0
.
y=++x (Prefix)
x = 2; y = 2
.

Arithmetik der Ganzzahlen

• Alle Operationen auf Ganzzahlen ergeben wieder Ganzzahlen. Dies wird nicht unbedingt von der Division erwartet!
• Versuche durch 0 (Null) zu dividieren lösen eine ArithmeticException Ausnahme aus.

Arithmetik der Fließkommazahlen

Bei der Arithmetik mit Fließkommazahlen werden im Gegensatz zu den Ganzzahlen Überläufe erkannt. Die Fließkommazahlen besitzen eine Reihe Konstanten:

Vergleichsoperatoren

Gleichheit bzw. Ungleichheit bezieht sich auf den Wert der Variablen x und y

Logische Operatoren

Die logischen Operatoren wirken auf den Typ Boolean der nur den Wert wahr oder falsch kennt.

Bedingungsoperator

Der dreistellige (ternäre) Bedingungsoperator (Konditionaloperator) erlaubt eine Zuweisung von dem Ergebnis einer Bedingung abhängig zu machen. Er hat die Form:

<ausdruck1> ? <ausdruck2> : <ausdruck3>

ausdruck1 muss einen boolschen Wert ergeben. Wird ausdruck1 wahr, so wird ausdruck2 der entsprechenden Variable zugewiesen. Wird ausdruck1 unwahr, so wird der ausdruck3 zugewiesen

Hiermit kann man Zuweisungen wie die Folgende formulieren

int maximum;
int x = 1;
int y =2 ;
maximum = (x > y) ? x : y ;

Das Ergebnis ist 2, da y (=2) größer als x (=1) ist.

Bedingt auswertende logische && und || Operatoren

Die bedingt auswertenden Operatoren werten Terme nur soweit aus bis das Endergebnis fest steht. Dies macht sie sehr effizient.

Im Beispiel:

boolean a = ((1<3) || (4>5));

wird der Term (4>5) nicht mehr ausgewertet. Da (1<3) wahr ist, steht das Endergebnis schon fest.

Die bedingt auswertenden logischen Operatoren wendet man neben Ihrem Geschwindigkeitsvorteil auch gerne an um potentielle Fehler und Ausnahmen zu vermeiden.

Ein Beispiel hierfür ist:

if ((a>0) && (Math.sqrt(a)>2))

Die Wurzel wird nur ausgewertet wenn a größer als Null ist.

Vorsicht: Durch die bedingte Auswertung können unterschiedliche Ergebnisse enstehen wenn in einem Ausdruck gleichzeitig ein Wert verändert wird!

Beispiel:

public static void t1() {
   int a = 3;
   int b = 5;
   if ((a>1) || (a<b++)){
      System.out.println ("Hallo");
   }
   System.out.println("b= " + b);
}

public static void t2() {
   int a = 3;
   int b = 5;
   if ((a>1) | (a<b++)){
      System.out.println ("Hallo");
   }
   System.out.println("b= " + b);
}

Hallo
b= 5

Hallo

b= 6

Das Postinkrement (b++) in der linkten bedingten oder Bedingung wird nicht ausgeführt, da der Ausdruck (a>1) schon wahr geworden ist.

Bitoperatoren

Mit Bitoperatoren werden alle Bits einer Variablen einzeln manipuliert.

Beispiel

package s1.block2.skript;
public class BitOperator {
    public static void main(String[] args) {
        int a = 7;
        int b = 6;
        int result;

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

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

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

Ergebnis

a = 7; b = 6 result = 6
a = 7; b = 6 result = 7
a = 7; b = 6 result = 1

Erklärung

Bitschiebeoperatoren 

java -jar IntShiftApplet.jar

Beispiel

package s1.block2.skript;
public class ShiftingBits {
    public static void main(String[] args) {
        int x = 4;
        int result;
        int shift = 1;

        result = x << shift;
        System.out.println("x = " + x + "; shift = " + shift + " result = " + result);

        result = x >> shift;
        System.out.println("x = " + x + "; shift = " + shift + " result = " + result);

        result = result >> shift;
        System.out.println("x = " + x + "; shift = " + shift + " result = " + result);

        result = result >> shift;
        System.out.println("x = " + x + "; shift = " + shift + " result = " + result);

        result = result >> shift;
        System.out.println("x = " + x + "; shift = " + shift + " result = " + result);
    }
}

Ergebnis

Die interne Darstellung der verwendeten Werte:

Zuweisungs- und Verbundoperatoren

Das Gleichzeichen = dient in Java als Zuweisungsoperator. Die Anweisung

x = y + z;

ist nicht als mathematische Gleichung zuverstehen, sondern als Zuweisung des Ausdrucks auf der echten Seite (y+z) auf die Variable x auf der linken Seite.

Zuweisungen wie:

x = y = 8;

sind auch möglich. Sie haben die gleiche Bedeutung wie

y = 8;
x = y;

Für die meisten binären Operatoren gibt es Verbundoperatoren mit denen man einer Variable etwas zuweisen kann und gleichzeitig den alten Wert verwenden kann:

Auswertungsreihenfolge

Für Ausdrücke mit mehreren Operatoren gelten die folgenden Regeln in Bezug auf die Reihenfolge der Auswertung:

1. Teilausdrücke in runden Klammern werden wie in der Mathematik als erstes ausgewertet
2. Ausdrücke mit unären Operatoren werden anschließend ausgewertet
3. Zuletzt werden Teilausdrücke mit mehrstelligen Operatoren ausgewertet

Unäre Operatoren haben alle die gleiche Priorität

Ausführungsreihenfolge von Operatoren

Die Ausführungsreihenfolge von Operatoren bestimmt wie ein Term aufgelöst wir.

Tipp: Es ist guter Programmstil Terme übersichtlich zu gestalten. Verwenden Sie im Zweifelsfall Klammern!

 Auswertung von Operatoren mit gleicher Priorität

Es kann vorkommen, dass ein Ausdruck mehrere Operatoren der gleichen Priorität besitzt. In diesen Fällen wird die Auswertereihenreihenfolge durch die Assoziativität der Operatoren bestimmt.

Ist ein Operator linksassoziativ, wird zuerst der linke Operand ausgewertet. Das Beispiel zeigt den Plus- und Minusoperator. Beide haben die gleiche Priorität. Hier wird zuerst der Operand a+b ausgewertet.

Einige Operatoren in Java sind rechtsassoziativ. Ein Beispiel hierfür ist der Zuweisungsoperator

Bewertungsreihenfolge der Operanden eines Operators

Diese Regel ist insbesondere wichtig, da Methoden und diverse Operatoren Nebeneffekte haben können. Das bedeutet, dass diese Operatoren den Wert von Variablen während der Auswertung des Gesamtausdrucks verändern. Beispiele sind die Inkrement- und Dekrementoperatoren.

j = i-- -i;

ist ein zulässiger Ausdruck in Java.  Der Wert der j zugewiesen wird ist immer 1;

Die Auswertung dieser Zuweisung geschieht in den folgenden Schritten:

1. Auswertung des Subtrahenden (und Zwischenspeicherung)
2. Dekrement von i
3. Auswertung des Minuend und Berechnung der Differenz
4. Zuweisung der Differenz auf j

Ein Beispielprogramm zum Testen:

package s1.block2.skript;
public class PrePostInkrement {
    public static void main(String[] args) {
        int i = 4;
        int j;
        
        j=i-- -i;
        System.out.println("i: " +i+", j= "+j);
    } 
}

Ausgabe:

i: 3, j= 1

Die Auswertung des Ausdrucks und der Zuweisung j= i-- -i; findet wie folgt statt:

Regeln für den Ergebnistyp von arithmetischen Ausdrücken (Widening Conversions)

Java kann alle arithmetischen Operationen auch ausführen wenn die Zahlentypen im Ausdruck unterschiedlich sind. Das Ergebnis der Berechnung hängt von den Typen des Ausdrucks ab. Es gilt in der folgenden Reihenfolge:

1. Ist einer der Typen ein double, so wird das Ergebnis zum Typ double konvertiert.
2. Falls nicht, wird das Ergebnis zu einem float Typen konvertiert wenn ein Typ ein float Typ ist.
3. Falls nicht, wird das Ergebnis zu einem long Typen konvertiert wenn ein Typ ein long Typ ist.
4. Falls nicht, werden beide Operanden zuerst zu einem int Typen konvertiert.

• Wie groß sind die Wertebereiche der einzelnen Typen?
• Was geschieht wenn man zwei Ganzzahlen (int) dividiert und das Ergebnis ist keine ganze Zahl?
• Was geschieht wenn Sie einen Überlauf in einem Wertebereich einer Variablen provozieren?

Beispiellösung

2.4.2 Übung: Erlaubte Variablennamen

maxvalue
maxValue
max_value
max value
end
End
10%ofSum
sum10
_10PercentOfSum

2.4.3 Übung: Literale

Warum übersetzt das folgende Programm nicht?

package block2;
public class Literale {
    public static void main(String[] args) {
        long i1 = 4000000000;
        long i2 = 4000000000L;
        System.out.println(i1);
        System.out.println(i2);
    }
}

2.4.4 Übung: Ausdrücke

Gegeben seien folgende Variablendeklarationen in Java:

long a = 3;
int b = 4;
short c = 5;
byte d = 6;

Welchen Wert liefern die folgenden Ausdrücke und von welchem Typ sind sie?

d / b * a
c + b * (d + 1)
d / (c - 1) * b / 2
d % b
-c % b

2.4.5 Übung: Zuweisungen

long a = 3;
int b = 4;
short c = 5;
byte d = 6;

a = b + 3 * (d + 1);
b = c * c;
c = b / 3;
d = (byte)a + b;
d = (byte) ( a + b);

2.4.6 Übung: Ausdrücke

Schreiben Sie einen Java-Ausdruck, der eine ganze Zahl x auf das nächstliegende Vielfache von 100 rundet.

Beispiel:

• der Wert 149 soll auf 100 abgerundet werden
• der Wert 150 auf 200 aufgerundet werden.

2.4.7 Übung: Zeitrechnung

2.4.8 Übung: Polynomberechnung

y = a * x3  + b * x2  + c * x + d

2.4.9 Übung: Abstand zwischen Punkten

Schreiben Sie ein Java-Programm, das die x- und y-Koordinaten zweier Punkte einliest und den Abstand zwischen ihnen berechnet und ausgibt.

Tipp: Math.sqrt() berechnet eine Wurzel

2.4.10 Übung: Berechnung von ∏ (Pi) 

Die Kreiszahl ∏ kann durch folgende Näherungsformel berechnet werden:

             i  
 ∏    n  (-1)          1     1     1     1 
--- = ∑ ------- = 1 - --- + --- - --- + --- - ... 
 4   i=0 2*i+1         3     5     7     9

2.4.11 Übung: Analoge Uhr

Implementieren sie notwendigen Berechnungen zum Anzeigen von Sekunden-, Minuten, Stundenzeigern einer analogen Uhr.

Vorbereitungen

1. Erzeugen Sie in einem Verzeichnis die beiden Quelldateien Uhr.java und Zeiger.java. Der Quellcode der beiden Dateien ist weiter unten aufgeführt.
2. Übersetzen Sie die beiden Dateien in diesem Verzeichnis mit dem Befehl javac Uhr.java Zeiger.java
3. Führen Sie das Programm aus: java Uhr
4. Beobachten Sie den blauen Sekundenzeiger. Er wächst in jeder Sekunde um ein Pixel nach rechts unten

Aufgabe

Implementieren Sie die korrekte Position der Spitze der drei Zeiger abhängig von der aktuellen Zeit in der Klasse Zeiger.java

Die korrekte Spitze wird durch eine x und y Koordinate beschrieben. Der Ursprung des Koordinatensystems liegt in der Mitte der Uhr. Postive X-Koordinaten reichen nach rechts. Positive Y-Koordinaten reichen nach unten. Die Richtung der Y-Koordinaten ist typisch für für Java GUIs in Swing oder AWT.

Hinweis: Implementieren Sie zuerst den Sekundenzeiger. Er erlaubt ihnen binnen 60 Sekunden die visuelle Kontrolle Ihrer Programmierung. Die Programmierung der Minutenzeiger und Stundenzeiger sind dann sehr einfach, da sie auf der gleichen mathematischen Formel basieren.

Empfohlendes Vorgehen:

1. Erstellen Sie die mathematische Formel für die aktuelle Spitze des Sekundezeigers abhängig von der Sekunde zwischen 0 und 59. Sie benötigen hierzu die Sinus- und Cosinusfunktion sowie die Konstante PI
2. Finden sie in der Klasse Zeiger.java die Methoden sekundeX und sekundeY
3. Ersetzen Sie in der Trivialimplementierung die Zuweisung xs=s; bzw ys=s; durch die korrekte Implementierung der beiden mathematischen Ausdrücke
4. Sichern Sie die Datei Zeiger.java
5. Übersetzen Sie die Datei Zeiger.java
6. Testen Sie das Ergebnis mit dem Kommando: java Uhr
7. Wiederholen Sie Schritt 3-6 bis Sie das gewünschte Ergebnis haben.
8. Implementieren Sie den Minuten und Stundenzeiger sinngemäß.

Beispiele der Ausgangssituation und der korrekten Implementierung: 

Ausgangssituation	Ziel der Übung

Tipps

• maxRadius: Diese Konstante der Klasse Zeiger gibt die maximale (vernünftige) Zeigergröße vor.
  • Nutzen Sie diesen Wert für einen großen regulären Sekundenzeiger
  • Skalieren Sie die Minuten- und Stundenzeiger relativ zu dieser Größe (z. Bsp. maxRadius*4/5 )
• die Mathematikbibliothek wurde statisch importiert. Sie können direkt die benötigen trigonometrischen Operation und Konstanten benutzen:
  • sin()
  • cos()
  • PI
  • Beispiel double z = cos(PI)+sin(PI);
• Beachten Sie die Eingabe- und Ausgabeparameter der trigonometrischen Funktionen! Die Berechnungen erfolgen mit Fließkommazahlen. Das Ergebnis muss aber eine ganzzahlige Pixelposition sein.
• Ganzzahloperation runden immer ab. Erwägen Sie die Benutzung einer Fließkommahilfsvariable
• Benutzen nur double als Fließkommatyp. Die Operationen der Mathematikbibliothek beruhen auf dem Typ double. Sie vermeiden so unnötige Konvertierungen zu float Typen.

Klasse Uhr

/*
 * Zeichnen einer analogen Uhr in einem JFrame
 */
import java.awt.*;
import java.awt.event.*;

import java.util.Calendar;
import javax.swing.*;

/**
*
* @author sschneid
*/
public class Uhr extends JPanel {

   static int sekunde = 0;
   static int minute = 0;
   static int stunde = 0;
   static String tzString; // aktuelle Zeitzone
   static int initialHeight;
   static float zoom = 1;

   /**
   * Hauptprogramm der Anwendung. Es werden keine Eingabeparameter benötigt
   * @param args dieser Parameter wird nicht ausgewertet
   */
   public static void main(String[] args) {
      JFrame hf; // Das Fenster der Anwendung
      hf = new JFrame("Uhr");
      // Beenden der Anwendung bei Schliesen des Fenster
      hf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      Uhr dieUhr = new Uhr();
      // Aufbau des Contentpanes
      Container myPane = hf.getContentPane();
      myPane.add(dieUhr, BorderLayout.CENTER);

      // Erzeuge einen Menüeintrag zum Beenden des Programms
      JMenuBar jmb = new JMenuBar();
      JMenu jm = new JMenu("Datei");
      JMenuItem exitItem = new JMenuItem("Beenden");
      exitItem.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            System.exit(0);
         }
      });
      jm.add(exitItem);
      jmb.add(jm);
      hf.setJMenuBar(jmb);

      hf.pack();
      // Das JFrame sichtbar machen
      // Gewünschte Größe setzen
      // 1. Parameter: horizontale Größe in Pixel
      // 2. Parameter: vertikale Größe in Pixel
      hf.setSize((int)(2 * Zeiger.maxRadius*zoom + 80),
         (int)(2 * Zeiger.maxRadius*zoom + 80));
      hf.setVisible(true);
      hf.setAlwaysOnTop(true);
      // Initialgröße merken. Entspricht Zoomfaktor 1
      dieUhr.initialHeight = dieUhr.getHeight();
      // Update von Panel in zyklischen Intervallen
      try {
         while (true) {
            Thread.sleep(500); // Schlafe x Millisekunden
            // Hole Systemzeit und belege statische Variablen
            Calendar call = Calendar.getInstance();
            tzString = call.getTimeZone().getDisplayName();
            sekunde = call.get(Calendar.SECOND);
            minute = call.get(Calendar.MINUTE);
            stunde = call.get(Calendar.HOUR);
            dieUhr.repaint();
        }
      } catch (InterruptedException e) {
      System.out.println(
         "Die Anwendung wird wegen einer Ausnahme beendet");
      }
   }
   /**
   * Überladene Paintmethode. Sie führt alle Zeichenoperationen im Panel aus
   * @param g vom Laufzeitsystem übergebenes Graphikobjekt.
   */
   @Override
   public void paint(Graphics g) {
      super.paint(g);
      zoom = (float)getHeight()/(float)initialHeight;
      int maxRadius = Zeiger.maxRadius;
      int xCenter = (int)(maxRadius*zoom) + 40;
      int yCenter = (int)(maxRadius*zoom) + 20;
      float fontSize = g.getFont().getSize2D();

      int charCenterOffSet = (int)(fontSize/2);
      String timeString = stunde + ":" + minute + ":" + sekunde
            + " " + tzString;
      // Zeichne Uhrenhintergrung und Koordinatensystem
      g.setFont(g.getFont().deriveFont(fontSize));
      g.setColor(Color.WHITE); // Farbe
      g.fillArc((int)(xCenter - maxRadius*zoom),
         (int)(yCenter - maxRadius*zoom),
         (int)(maxRadius*zoom*2),
         (int)(maxRadius*zoom*2), 0, 360);
      g.setColor(Color.BLACK); // Farbe
      g.fillArc((int)(xCenter - 3*zoom), (int)(yCenter - 3*zoom),
         (int)(10*zoom), (int)(10*zoom), 0, 360);

      g.drawLine(xCenter, yCenter, (int)(xCenter + 40*zoom), yCenter);
      g.drawLine(xCenter, yCenter, xCenter, (int)(yCenter + 40*zoom));
      g.drawString("X", (int)(xCenter + 45*zoom),
         yCenter + +charCenterOffSet);
      g.drawString("Y", xCenter - charCenterOffSet,
         (int)(yCenter + 55*zoom));
      g.drawString("12",xCenter - charCenterOffSet,
         (int)(yCenter - maxRadius*zoom));
      g.drawString("3", (int)(xCenter + maxRadius*zoom),
         yCenter + charCenterOffSet);
      g.drawString("6", xCenter - charCenterOffSet,
         (int)(yCenter + 2*charCenterOffSet+maxRadius*zoom));
      g.drawString("9", (int)(xCenter - maxRadius*zoom - charCenterOffSet),
         yCenter + charCenterOffSet);
      // Zeichne aktuelle Zeit zum Debuggen
      g.drawString(timeString, 0,
         (int)(yCenter + maxRadius*zoom));

      // Zeichne Stundenzeiger
      g.setColor(Color.BLACK);
      g.drawLine(xCenter, yCenter,
         (int)(xCenter + Zeiger.stundeX(stunde)*zoom),
         (int)(yCenter + Zeiger.stundeY(stunde)*zoom));
      g.drawString("h["
         + Zeiger.stundeX(stunde)
         + "," + Zeiger.stundeY(stunde) + "]",
         0, (int)(yCenter + maxRadius*zoom - (3*fontSize)));
      // Zeichne Minutenzeiger
         g.setColor(Color.RED);
         g.drawLine(xCenter, yCenter,
            (int)(xCenter + Zeiger.minuteX(minute)*zoom),
            (int)(yCenter + Zeiger.minuteY(minute)*zoom));
         g.drawString("m["
            + Zeiger.minuteX(minute) + ","
            + Zeiger.minuteY(minute) + "]", 0,
            (int)(yCenter + maxRadius*zoom - (2*fontSize)));
            // Zeichne Sekundenzeiger
         g.setColor(Color.BLUE);
         g.drawLine(xCenter, yCenter,
            (int)(xCenter + Zeiger.sekundeX(sekunde)*zoom),
            (int)(yCenter + Zeiger.sekundeY(sekunde)*zoom-fontSize));
         g.drawString("s["
            + Zeiger.sekundeX(sekunde) + ","
            + Zeiger.sekundeY(sekunde) + "]", 0,
            (int)(yCenter + maxRadius*zoom - fontSize));
   }
}

Klasse Zeiger

Implementieren sie

import static java.lang.Math.*;

/**
*
* @author sschneid
*/
public class Zeiger {
   public static final int maxRadius = 100; // Beeinflusst GUI-Größe !

   /**
   * @param s Sekunden der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return aktuelle X Koordinate der Zeigerspitze des Sekundenzeigers
   * auf dem Bildschirm
   */
   public static int sekundeX(int s) {
      int xs;
      /* Implementierung Beginn */
      xs = s; // Proformazuweisung. Sie ist zu ersetzen
      /* Implementierung Ende */
      return xs;
   }

   /**
   * @param s Sekunden der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return aktuelle Y Koordinate der Zeigerspitze des Sekundenzeigers
   * auf dem Bildschirm
   */
   public static int sekundeY(int s) {
      int ys;
      /* Implementierung Beginn */
      ys = s; // Proformazuweisung. Sie ist zu ersetzen
      /* Implementierung Ende */
   return ys;
   }

   /**
   * @param m Minuten der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return aktuelle X Koordinate der Zeigerspitze des Minutenzeigers
   * auf dem Bildschirm
   */
   public static int minuteX(int m) {
      int xm;
      /* Implementierung Beginn */
      xm = m; // Proformazuweisung. Sie ist zu ersetzen
      /* Implementierung Ende */
     return xm;
   }

   /**
   * @param m Minuten der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return aktuelle Y Koordinate der Zeigerspitze des Minutenzeigers
   * auf dem Bildschirm
   */
   public static int minuteY(int m) {
      int ym;
      /* Implementierung Beginn */
      ym = m; // Proformazuweisung. Sie ist zu ersetzen
      /* Implementierung Ende */
      return ym;
   }

   /**
   * @param h Stunden der aktuellen Zeit. Ein Wert zwischen 0 und 12
   * @return aktuelle X Koordinate der Zeigerspitze des Stundenzeigers
   * auf dem Bildschirm
   */
   public static int stundeX(int h) {
      int xh;
      /* Implementierung Beginn */
      xh = h; // Proformazuweisung. Sie ist zu ersetzen
      /* Implementierung Ende */
      return xh;
   }

   /**
   * @param h Stunden der aktuellen Zeit. Ein Wert zwischen 0 und 12
   * @return aktuelle Y Koordinate der Zeigerspitze des Stundenzeigers
   * auf dem Bildschirm
   */
   public static int stundeY(int h) {
      int yh;
      /* Implementierung Beginn */
      yh = h; // Proformazuweisung. Sie ist zu ersetzen
      /* Implementierung Ende */
     return yh;
  }
}

Hilfestellung

Hier nicht weiterlesen, wenn Sie einfache trigonometrische Aufgaben lösen können!

max-Zeit ist bei Sekunden 60, bei Minuten 60, bei Stunden 12

Die X-Koordinate eines Zeigers berechnet sich wie folgt

x-Koordinate: Sinus(aktuelle-Zeit/max-Zeit*2*PI)*zeiger-länge-in-pixel

Die Y-Koordinate eines Zeigers berechnet sich wie folgt

Y-Koordinate: -Cosinus(aktuelle-Zeit/max-Zeit*2*PI)*zeiger-länge-in-pixel

Beachten Sie, dass in Java das Kommutativgesetz nicht vollständig gilt. Der Typ und die Auswertereihenfolge spielen auch eine Rolle!

2.4.12 Gruppenübung

Je eine Gruppe bearbeitet die folgenden Typen:

• short
• char
• int
• long
• float
• double

Jede Gruppe trägt die folgenden Aspekte eines Typs in 5 Minuten vor

• Schlüsselwort des Typ
• Anzahl der verwendeten Bits
• Wertebreich 
  • Grenzen mit Konstanten dazu
  • Echte Obermengen oder Untermengen der anderen Typen nennen
  • Beispiel für die Benutzung dieses Types. Das Beispiel sollte nicht optimal für die anderen Typen sein!
• Syntax der Literale um Werte zuzuweisen
• Programmierbeispiele
  • Syntax der Literale benutzen und vorstellen
  • Typische Operation und Zuweisung
  • mehrere interessante Operationen und Zuweisungen die zu Sonderfällen bzw. Extremfällen führen

Zeitvorgaben

• Selbst lesen: 5 Minuten
• Teamdiskussion: 10 Minuten
• Beispiel Programmieren: 20 Minuten
• Zusammenfassung, Abstimmung Vortrag: 5 Minuten

 2.4.13 Airline

Vorbereitung

• Legen Sie ein neues Paker Block2 an
• Nutzen Sie die neue Klasse Flughafen
• Kopieren Sie die Klasse Flugzeug aus dem Block1 in den Block2

Aufgabe:

• Legen Sie in der Klasse Flugzeug die folgenden Attribute als öffentliche (public) Attribute an. Wählen Sie einen passenden Typen
  • passagiere
  • besatzung
  • treibstoff
  • leergewicht
  • maxGewicht
• Legen Sie zwei statische Variablen an in der Form
  • static final int durchschnittsGewicht= 75;
  • static final double kerosinGweicht= 0.796; // kg/dm3
• Kopieren der Methoden (siehe unten) in die Klasse Flugzeug
  • gewicht()
  • toString()
  • drucken()
• Implementieren der Methode gewicht()
  • Deklarieren Sie eine Variable
  • berechnen Sie das aktuelle Gesamtgewicht
  • geben Sie diese Variable zurück. Ersetzen Sie die 0 in return durch Ihre Variable
• Erweitern Sie die Klasse Flughafen
  • Nutzen Sie das Objekt auf das lh1 zeigt.
  • Belegen Sie alle Attribute mit vernünftigen Werten
  • Rufen Sie die Methode drucken() für lh1 auf.
  • Kontrollieren Sie die Werte
• Testen Sie das Programm in der Klasse Flugzeug
• In der Klasse Flugzeug
  • Entnehmen Sie dem Treibstofflager des Flughafen 2000 Liter Treibstoff und füllen Sie Ihn in das Flugzeug lh1

Klasse Flugzeug

Im block2 anlegen!

package Airline.block2;

/**
*
* @author stsch
*/
public class Flugzeug {
String kennzeichen;

/**
*
* @return aktuelles Gewicht;
*/
public double gewicht() {
// Berechnen Sie das aktuelle Gewicht:
// 1. Anlegen einer Variablen
// 2. Berechnen des Gewichts
// 3. Variable in return zurückgeben
return 0;
}

public String toString() {return kennzeichen;}

public void drucken() {
System.out.println("Objekt: " + this);
System.out.println("kennzeichen: " + kennzeichen);
System.out.println("passagiere: " + passagiere);
System.out.println("Besatzung: " + besatzung);
System.out.println("Treibstoff: " + treibstoff);
System.out.println("Leergewicht: " + leergewicht);
System.out.println("maxGewicht: " + maxGewicht);
System.out.println("aktuelles Gewicht: " + gewicht());
}
}

Klasse Flughafen

package Airline.block2;

package Airline.block2;

/**
*
* @author stsch
*/
public class Flughafen {
String name;
Flugzeug gate1;
Flugzeug gate2;
Flugzeug gate3;
Flugzeug gate4;
Flugzeug gate5;
Flugzeug gate6;
double treibstoffLager;

public static void main(String[] args) {
Flughafen pad = new Flughafen();

pad.name = "Paderborn";
pad.treibstoffLager = 1000000;
// Boeing 747, https://de.wikipedia.org/wiki/Boeing_747#747-400
Flugzeug lh1 = new Flugzeug();
lh1.kennzeichen ="D-ABTL";

pad.gate1 = lh1;

System.out.println("*** Unser Flughafen ***");
System.out.println("Flughafen " + pad.name);
System.out.println("Am Gate 1: " + pad.gate1);
System.out.println("Am Gate 2: " + pad.gate2);
System.out.println("Am Gate 3: " + pad.gate3);
System.out.println("Treibstoff: " + pad.treibstoffLager);
System.out.println("***********************");

pad.gate1=null;
pad.gate2=lh1;

System.out.println("*** Unser Flughafen ***");
System.out.println("Flughafen " + pad.name);
System.out.println("Am Gate 1: " + pad.gate1);
System.out.println("Am Gate 2: " + pad.gate2);
System.out.println("Am Gate 3: " + pad.gate3);
System.out.println("Treibstoff: " + pad.treibstoffLager);
System.out.println("***********************");

}
}

2.5.1 Zuweisungen und Typen 

class ArithmeticTest {
  public static void main (String args[]) {
    short x = 6;
    int y = 4;
    float a = 12.5f;
    float b = 7f;
    System.out.println("x is " + x + ", y is " + y);
    System.out.println("x + y = " + (x + y));
    System.out.println("x - y = " + (x - y));
    /* ??? */
    System.out.println("x % y = " + (x % y));
    System.out.println("a is " + a + ", b is " + b);
    /* ??? */
  }
}

2.5.2 Erlaubte Variablennamen

siehe Spezifikation Java 7 (Identifier)

Lösung durch Testen mit javac

public class VariableNames {   
   int maxvalue;
   int maxValue;
   int max_value;
   //int max value;
   int end;
   int End;
   //int 10%ofSum;
   int sum10;
   int _10PercentOfSum;
  public static void main(String[] args) {
  }
}

Erklärung

• maxvalue: korrekter Name
• maxValue: korrekter Name
• max_value: korrekter Name
• max value: Leerstelle im Namen ist nicht erlaubt
• end: korrekter Name
• End: korrekter Name
• 10%ofSum: Ziffer als erstes Zeichen ist nicht erlaubt
• sum10: korrekter Name
• _10PercentOfSum: korrekter Name

2.5.3 Literale

Das Programm übersetzt nicht weil

• der Wert 4000000000 ein "Integer"-Literal ist
• der Wert 4000000000 den Wertebereich einer Ganzzahl vom Typ "Integer" übersteigt
• Die Zuweisung auf eine Variable vom Typ "Long" spielt zu diesem Zeitpunkt noch keine Rolle

2.5.4 Ausdrücke

public class Expressions {
    
    public static void main(String[] args) {
      long a = 3;
      int b = 4;
      short c = 5;
      byte d = 6;
      
      int  result1;
      long result2;

      result2 = d / b * a;
      System.out.println("d / b * a = " + result2 );

      result1 = c + b * (d + 1);
      System.out.println("c + b * (d + 1) = " + result1 );

      result1 = d / (c - 1) * b / 2;
      System.out.println("d / (c - 1) * b / 2 = " + result1 );

      result1 = d % b;
      System.out.println("d % b = " + result1 );

      result1 = -c % b;
      System.out.println("-c % b = " + result1 );
    }

}

Ergebnis

d / b * a = 3
c + b * (d + 1) = 33
d / (c - 1) * b / 2 = 2
d % b = 2
-c % b = -1

2.5.5 Zuweisungen

public class AllowedAssigments {

    public static void main(String[] args) {
        long a = 3;
        int b = 4;
        short c = 5;
        byte d = 6;

        a = b + 3 * (d + 1);
        b = c * c;
        c = (byte)(b / 3);
        d = (byte)(((byte)a + b));
        d = (byte) ( a + b);
    }

}

2.5.6 Ausdrücke

public class Runden {

    public static void main(String[] args) {
        int a, result;
        
        a =149;
        result = (a +50)/100*100;
        System.out.println("Eingabe = " + a + " Ergebnis = " + result);

        a =150;
        result = (a +50)/100*100;
        System.out.println("Eingabe = " + a + " Ergebnis = " + result);
    }
}

Ergebnis

Eingabe = 149 Ergebnis = 100
Eingabe = 150 Ergebnis = 200

2.5.7 Zeitrechnung

public class timeCalculation {

    public static void main(String[] args) {
        int a,h,m,s;

        a = 0;
        h = a/3600;
        m = (a-h*3600)/60;
        s = a - h*3600 - m*60;
        System.out.println("Sekunden = " + a + " = " + h + ":" + m + ":" +s);

        a = 59;
        h = a/3600;
        m = (a-h*3600)/60;
        s = a - h*3600 - m*60;
        System.out.println("Sekunden = " + a + " = " + h + ":" + m + ":" +s);

        a = 60;
        h = a/3600;
        m = (a-h*3600)/60;
        s = a - h*3600 - m*60;
        System.out.println("Sekunden = " + a + " = " + h + ":" + m + ":" +s);

        a = 100;
        h = a/3600;
        m = (a-h*3600)/60;
        s = a - h*3600 - m*60;
        System.out.println("Sekunden = " + a + " = " + h + ":" + m + ":" +s);

        a = 3600;
        h = a/3600;
        m = (a-h*3600)/60;
        s = a - h*3600 - m*60;
        System.out.println("Sekunden = " + a + " = " + h + ":" + m + ":" +s);

        a = 4000;
        h = a/3600;
        m = (a-h*3600)/60;
        s = a - h*3600 - m*60;
        System.out.println("Sekunden = " + a + " = " + h + ":" + m + ":" +s);
    }

}

Ergebnis

Sekunden = 0 = 0:0:0
Sekunden = 59 = 0:0:59
Sekunden = 60 = 0:1:0
Sekunden = 100 = 0:1:40
Sekunden = 3600 = 1:0:0
Sekunden = 4000 = 1:6:40

2.5.8 Polynomberechnung

public class Polynom {
    public static void main(String[] args) {
        double a, b, c, d, x, y;

        a =  1.2;
        b = -2.3;
        c =  4.5;
        d = -6.7;

        x = 8.9;

        y = a*x*x*x+b*x*x+c*x+d;
        System.out.print("Ergebnis = "+ y);
        System.out.println("\n oder...");

        y = a*Math.pow(x,3)+b*Math.pow(x,2)+c*x+d;
        System.out.print("Ergebnis = "+ y);
    }
}

Ergebnis

Ergebnis = 697.1298
 oder...
Ergebnis = 697.1297999999999

2.5.9 Abstand zwischen Punkten

public class Main {
    public static void main(String[] args) {
       double x1,x2, y1, y2, x, y, d;

       x1 = 1; y1 = 1;
       x2 = 4; y2 = 5;

       x = x1-x2;
       y = y1-y2;
       d = Math.sqrt(x*x+y*y);
       System.out.println("distance = " + d);
    }
}

Ergebnis

distance = 5.0

2.5.10 Berechnung von ∏ (Pi)

Hilfe; Java Spezifikation: Division

public class PiCalculation {

    public static void main(String[] args) {
        double pi;

        pi = (1.0 - 1.0/3.0 + 1.0/5.0 - 1.0/7.0 + 1.0/9.0 - 1.0/11.0 + 1.0/13.0)*4;
        System.out.println("Pi = "+ pi);
        System.out.println("\n oder ...");

        pi=1;
        for (int i=1;i<=10000;i++) {
            pi = pi + Math.pow(-1,i)/(2*i+1);
        }
        pi=pi*4;
        System.out.println("Pi = "+ pi);

    }

Ergebnis

Pi = 3.2837384837384844

 oder ...
Pi = 3.1416926435905346

2.5.11 Analoge Uhr

import static java.lang.Math.*;
/**
*
* @author stsch
*/
public class Zeiger {
   public static final int maxRadius = 100; // Beeinflusst GUI-Größe !
   /**
   * @param s Sekunden der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return aktuelle X Koordinate der Zeigerspitze des Sekundenzeigers
   * auf dem Bildschirm
   */
   public static int sekundeX(int s) {
      int xs;
      /* Implementierung Beginn */
      double sx = sin(s*2*PI/60)*maxRadius;
      xs = (int)sx;
      /* Implementierung Ende */
      return xs;
   }
   /**
   * @param s Sekunden der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return aktuelle Y Koordinate der Zeigerspitze des Sekundenzeigers
   * auf dem Bildschirm
   */
   public static int sekundeY(int s) {
      int ys;
      /* Implementierung Beginn */
      double sy = -cos(s*2*PI/60)*maxRadius;
      ys = (int)sy;
      /* Implementierung Ende */
      return ys;
   }
   /**
   * @param m Minuten der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return aktuelle X Koordinate der Zeigerspitze des Minutenzeigers
   * auf dem Bildschirm
   */
   public static int minuteX(int m) {
      int xm;
      /* Implementierung Beginn */
      double mx = sin(m*2*PI/60)*maxRadius*0.75;
      xm = (int)mx;
     /* Implementierung Ende */
     return xm;
   }
   /**
   * @param m Minuten der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return aktuelle Y Koordinate der Zeigerspitze des Minutenzeigers
   * auf dem Bildschirm
   */
   public static int minuteY(int m) {
      int ym;
      /* Implementierung Beginn */
      double my = -cos(m*2*PI/60)*maxRadius*0.75;
     ym = (int) my;
     /* Implementierung Ende */
     return ym;
   }
   /**
   * @param h Stunden der aktuellen Zeit. Ein Wert zwischen 0 und 12
   * @return aktuelle X Koordinate der Zeigerspitze des Stundenzeigers
   * auf dem Bildschirm
   */
   public static int stundeX(int h) {
      int xh;
      /* Implementierung Beginn */
      double hx = sin(h*2*PI/12)*maxRadius*0.5;
      xh = (int)hx;
     /* Implementierung Ende */
     return xh;
   }
   /**
   * @param h Stunden der aktuellen Zeit. Ein Wert zwischen 0 und 12
   * @return aktuelle Y Koordinate der Zeigerspitze des Stundenzeigers
   * auf dem Bildschirm
   */
   public static int stundeY(int h) {
      int yh;
      /* Implementierung Beginn */
      double hy = -cos(h*2*PI/12)*maxRadius*0.5;
      yh = (int)hy;
      /* Implementierung Ende */
      return yh;
   }
}

 2.5.13 Airlines

Klasse Flughafen

package Airline.Block2;
/**
 *
 * @author stsch
 */
public class Flughafen {
    String name;
    Flugzeug gate1;
    Flugzeug gate2;
    Flugzeug gate3;
    Flugzeug gate4;
    Flugzeug gate5;
    Flugzeug gate6;
    double treibstoffLager;

    public static void main(String[] args) {
       Flughafen pad = new Flughafen();

        pad.name = "Paderborn";
        pad.treibstoffLager = 1000000;
        // Boeing 747, https://de.wikipedia.org/wiki/Boeing_747#747-400
        Flugzeug lh1 = new Flugzeug();
        lh1.kennzeichen ="D-ABTL";

        pad.gate1 = lh1;

        System.out.println("*** Unser Flughafen ***");
        System.out.println("Flughafen " + pad.name);
        System.out.println("Am Gate 1: " + pad.gate1);
        System.out.println("Am Gate 2: " + pad.gate2);
        System.out.println("Am Gate 3: " + pad.gate3);
        System.out.println("Treibstoff: " + pad.treibstoffLager);
        System.out.println("***********************");

        pad.gate1=null;
        pad.gate2=lh1;

        System.out.println("*** Unser Flughafen ***");
        System.out.println("Flughafen " + pad.name);
        System.out.println("Am Gate 1: " + pad.gate1);
        System.out.println("Am Gate 2: " + pad.gate2);
        System.out.println("Am Gate 3: " + pad.gate3);
        System.out.println("Treibstoff: " + pad.treibstoffLager);
        System.out.println("***********************");

lh1.leergewicht = 184567;
        lh1.maxGewicht = 412770;
        lh1.passagiere = 200;
        lh1.besatzung = 10;

        lh1.drucken();   
    } 
}

Klasse Flugzeug

package Airline.Block2;
/*
*
 * @author stsch
 */
public class Flugzeug {
    String kennzeichen;
    static final int durchschnittsGewicht= 75;
    static final double kerosinGweicht= 0.796; // kg/dm3
    public int passagiere;
    public int besatzung;
    public double treibstoff;
    public double leergewicht;
    public double maxGewicht;

    /**
     * 
     * @return aktuelles Gewicht; 
     */
    public double gewicht() {
        // Berechnen Sie das aktuelle Gewicht:
        // 1. Anlegen einer Variablen
        // 2. Berechnen des Gewichts
        // 3. Variable in return zurückgeben
        double meinGewicht = leergewicht + passagiere*durchschnittsgewicht+
                besatzung*durchschnittsgewicht+treibstoff*gewichtKerosin;
        return meinGewicht;
    }

    public String toString() {return kennzeichen;}

    public void drucken() {
        System.out.println("Objekt: " + this);
        System.out.println("kennzeichen: " + kennzeichen);
        System.out.println("passagiere: " + passagiere);
        System.out.println("Besatzung: " + besatzung);
        System.out.println("Treibstoff: " + treibstoff);
        System.out.println("Leergewicht: " + leergewicht);
        System.out.println("maxGewicht: " + maxGewicht);
        System.out.println("aktuelles Gewicht: " + gewicht());
    }
}

Ein graphisch animierter Webcast der die genauen Vorgänge des folgenden Beispielprogramms erläutert:

public class Mitarbeiter {
...
   public static void main (String[] args) {
      int a;
      long b;
      String eingabe;
      eingabe = args[0];
      a = 15;
      a++;
      b = 2*a;
      System.out.println("Ausgabe :" + eingabe + b);
   }
}

Das folgende Video dauert 8 Minuten.

Wichtige Aspekte:

• genaue Lebensdauer von Variablen
• genaues Vorgehen bei einem Cast
• Verwalten von temporären Datenstrukturen

int a = 0;
int b = 6;
a = b*5/4;
a = b/4*5;
a = b*(5/4);

 Was ist die beste Implementierung wenn man weiß das b groß ist? Z.Bsp. b= 2³⁰? Welche Operation ist heikel?

2.7.2 Sichere Zuweisungen

Welche der folgenden Zuweisungen sind sicher b.z.w unsicher?

Eine Zuweisung sei unsicher wenn bei der Zuweisung abhängig von der gewählten Variablenbelegung Datenverluster auftreten können.

Analysieren Sie die sechs Zuweisungen auf potentielle Datenverluste. Die Werte von a_short, b_int, c_long wurden absichtlich am oberen Ende des jeweiligen Wertebereichs gewählt um den Präzisionsverlust zu provozieren.

Hinweis: Vergleichen Sie die Wertebereiche der Ausgangs und Zielvariablen.

Ignorieren Sie die Auswertelogik. Das Programm ist ausführbar. Es wird die Belegungen der einzelnen Variablen auf der Konsole drucken. Es wird bei jedem Fall von Präzisionsverlust einen Text "(Fehler)" hinter die Ausgabe anfügen.

public class UebungTypkonversion {

public static void main(String[] args) {
// Alle Werte sind der drittgrößte Wert des jeweiligen Wertebereichs
short a_short = Short.MAX_VALUE-2; // short = 16 bit
int b_int = Integer.MAX_VALUE-2; // int = 32 bit
long c_long = Long.MAX_VALUE-2; // long = 64 bit

// cast auf float: Welche Zuweisungen können zu Präzisionsverlusten führen?
float c_float = a_short;
float d_float = b_int;
float e_float = c_long;

// cast auf double:Welche Zuweisungen können zu Präzisionsverlusten führen?
double f_double = a_short;
double g_double = b_int;
double h_double = c_long;

// Auswertelogik und Kontrolle
System.out.println("a_short=" + a_short);
System.out.println("a_int=" + b_int);
System.out.println("a_long=" + c_long);
System.out.print("short auf float= " + c_float + " ");

// Sind die Werte nach der Rückkonvertierung noch gleich?
if (a_short == (short)c_float) {System.out.println("(OK)");}
else {System.out.println("(Fehler)");}
System.out.print("int auf float= " + d_float);
if (b_int == (int)d_float) {System.out.println("(OK)");}
else {System.out.println("(Fehler)");}
System.out.print("long auf float= " + e_float);
if (c_long == (long)e_float) {System.out.println("(OK)");}
else { System.out.println("(Fehler)");}

System.out.print("short auf double= " + f_double + " ");
if (a_short == (short)f_double) {System.out.println("(OK)");}
else {System.out.println("(Fehler)");}
System.out.print("int auf double= " + g_double);
if (b_int == (int)g_double) {System.out.println("(OK)");}
else {System.out.println("(Fehler)");}
System.out.print("long auf double= " + h_double);
if (c_long == (long)e_float) {System.out.println("(OK)");}
else { System.out.println("(Fehler)");}

}
}

2.8.1 Ganzzahlarithmetik

Bei Ganzzahldivisionen werden alle Ergebnisse abgerundet.

Option a.) ist hier die optimale Lösung da der Rundungsfehler relativ gesehen am kleinsten ist wenn man zuerst multipliziert um dann eine möglichst große Zahl zu teilen.

Option c.) ist schlecht, da da 5/4 schon innerhalb der Klammer auf 1 abgerundet wird.

Option b.) ist ebenfalls schlecht da 6/4 ebenfalls auf 1 abgerundet wird

int a = 0;
int b = 6;
a = b*5/4;
a = b/4*5;
a = b*(5/4);

.
.
a=7
a=5
a=6 

Die Variable b ist sehr groß b= 2³⁰:

• Option b.) ist vorteilhaft.
• Hier wird die Multiplikation zum Risiko. Der maximale 32 Bit Ganzzahlwert (2³¹-1) kann bei Option a.) und b.) überschritten werden. Der Überlauf wird vom Laufzeitsystem nicht gemeldet und das Ergebnis ist falsch da negativ. Ein Überlauf des Wertebereichs durch die Mutiplkation ist wahrscheinlich schlimmer als ein Rundungsfehler durch eine frühe Division.

2.8.2 Sichere Zuweisungen

Konsolenausgaben:

a_short=32765
a_int=2147483645
a_long=9223372036854775805
short auf float= 32765.0 (OK)
int auf float= 2.14748365E9(Fehler)
long auf float= 9.223372E18(Fehler)
short auf double= 32765.0 (OK)
int auf double= 2.147483645E9(OK)
long auf double= 9.223372036854776E18(Fehler)

Die Mantisse des Typ float ist nicht groß genug um extrem große (oder kleine) Werte des Typs int und long präzise zu verwalten.

Die Mantisse des Typ double ist nicht groß genug, um extrem große (oder kleine) Werte des Typs long präzise zu verwalten.

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zu Typen, Operationen und Zuweisungen zu beantworten.

Interessante Fragen aus den Übungen:

• Frage zur Ganzzahlarithmetik beantworten
• Fragen aus den Übungen beantworten:
  • 2.4.2 Erlaubte Variablenamen
  • 2.4.3 Übung Literale
  • 2.4.4 Ausdrücke
  • 2.4.5 Zuweisungen
  • 2.4.6 Java-Ganzzahlarithmetik zum Runden benutzen

Feedback

Zur Umfrage