Kostenlose E-Books

• Gallileo Computing <openbook>
  • Java 7 - Mehr als eine Insel
  • Java ist auch eine Insel

Im Diagramm links wird das typische Vorgehensmodell gezeigt welches von einer Problemstellung zur einer ausführbaren Anwendung führt. Lösungsidee: Der erste Schritt zur Lösung der in der Vorlesung vorgestellten Probleme basiert auf einer Idee zur Lösung des Problems Algorithmus: Im nächsten Schritt wird die Lösungsidee zu einem Algorithmus verfeinert und ausgearbeitet Programm: Ein wesentlicher Teil der Vorlesung wird aus der Umsetzung eines Algorithmus in ein ausführbares Java-Programm bestehen Üblicherweise treten in jeder Phase Fehler auf, die ein Zurückgehen und Verbessern der Ergebnisse einer früheren Phase erfordern.

Algorithmus

• Vorgehensbeschreibung, Handlungsanweisung
• Alltagsbeispiele:
Kochrezept, Bastelanleitung, Partitur
• Mathematische Beispiele:
  • 
Euklids ggT-Bestimmung, geometrische Konstruktionen
• Name abgeleitet von Muhammed al-Chwarizmis Buch „Über das Rechnen mit indischen Ziffern“ (um 825)
• Erster Computeralgorithmus:
1843 von Ada Lovelace für Charles Babbages Analytical Engine (Maschine wurde nicht vollendet)

Anforderungen an einen gültigen Algorithmus

• Er verlangt gültige Eingaben und liefert definierte Ausgaben, durch die seine Korrektheit überprüft werden kann
• Er umfasst endlich viele Einzelschritte und besteht aus hinreichend elementaren Anweisungen
• Er ist in realistischer Zeit ausführbar
• Er terminiert garantiert: d.h. ist nach endlich vielen Schritten fertig abgearbeitet, liefert ein Ergebnis und „hält an“

 Im Javaumfeld muss man zwei grundlegende Konzepte unterscheiden:

• Die Programmiersprache Java: Mit ihr werden die zu programmierenden Algorithmen beschrieben
• Das Laufzeitsystem Java zu dem man auch die Entwicklungswerkzeuge (JDK) zählt.
  • Mit Hilfe der Entwicklungswerkzeuge werden die (menschlich) lesbaren Java-Quellcodeprogramme in ein maschinenlesbares Format übersetzt und auf diverse Fehler geprüft
  • Das Laufzeitsystem kann dann diese übersetzten Programme ausführen.

Java ist:

• eine der vier großen Sundainseln der Republik Indonesien
• im amerikanischen benutztes Synonym für: (guten) Kaffee
  • alles was ein Softwareentwickler braucht ist ausreichend Kaffee
• eine Programmiersprache und das damit verbundene Laufzeitsystem

Java in der Softwareentwicklung

• Markenzeichen (Trademark) der Firma Oracle (ehemals Sun Microsystems)
  • nur von Oracle zertifizierte und/oder lizensierte Produkte dürfen das Warenzeichen führen
• Programmiersprache
  • C/C++ ähnliche Syntax
  • 1995 veröffentlicht
  • konservative Weiterentwicklung der Sprache um Fragmentierung zu vermeiden
• standardisierter Bytecode
  • wird aus Javaquellcode generiert
  • plattform- und betriebssystemunabhängig
• Virtuelle Maschine (VM: Laufzeitumgebung)
  • führt (neutralen) Bytecode aus
  • verfügbar von unterschiedlichen Anbietern für viele Betriebsysteme
• Laufzeitbibliotheken (Java API)
  • standardisiert
    • optionale, sowie verpflichtende Komponenten
  • reichhaltiger Funktionsvorrat der alle wesentlichen Funktionen eines Betriebssystem portabel für die Anwendung zur Verfügung stellt
    • Graphik
    • Netzwerkommunikation
    • Mathematik
    • Verschlüsselung
    • Dateizugriff
    • Datenbankzugriff
    • etc.
• Java "Editionen" (Editions)
  • Funktionalitätsbündel für unterschiedliche Anwendungszwecke
  • gleiche Sprache, unterschiedliche VM, unterschiedlicher Bibliotheksumfang
  • z.Zt. existierende Editionen
    • SE: Standard Edition (Gegenstand des Kurses!)
      • Desktopanwendungen, fundament für Serveranwendungen, zunehmend auch Smartphones
    • EE: "Enterprise Edition"
      • Middleware für Java-Applikationsserver
      • Fokus: Mehrbenutzeranwendungen, Webfrontends, komplexe betriebswirtschaftliche Anwendungen
    • ME: "Micro Edition"
      • Mobile Endgeräte: Mobiltelefone, PDAs, Smartphone
      • Fokus: Animation auf Mobiltelefonen, Nutzung der Mobiltelefoninfrastruktur
      • unterschideliche "Profile und Konfigurationen" für unterschiedliche Geräteklassen
      • wird nicht mehr wirklich verwendet...
    • JavaCard
      • Javalaufzeitumgebung für intelligente EC und Kreditkarten mit Chip
    • weitere Varianten
      • JavaFX : Laufzeitumgebung für multimediale Benutzeroberflächen
        • Ist Seit Java 7.0 update 6 Teil der Javalaufzeitumgebung von Oracle
      • Randbemerkung: JavaScript: Netscape führte im Frühjahr 1996 die Browserscriptsprache JavaScript ein. Netscape war zum damaligen Zeitpunkt ein sehr früher Kooperationspartner von Sun Microsystems, der als einer der ersten Partner eine Portierung von Java im Browser auslieferte. Sun Microsystems gewährte Netscape zum damaligen Zeitpunkt das Recht das Markenzeichen "Javascript" zu verwenden. Die Marke gehört noch heute Oracle (als Nachfolger von Sun Microsystems)
        • Interessant: JavaScript hat technologisch gesehen nichts mit der Programmiersprache Java gemein.

Referenz: Wikipedia

Bei den neuen Eigenschaften werden nur Eigenschaften genannt, die einen Bezug zur Vorlesung haben!

 Java Standard Edition (SE) in seiner Distribution von Oracle kann in zwei Varianten benutzt werden:

• JRE: Java Runtime Environment
• JDK: Java Development Kit (JDK Oracle Download Seite)

Das JDK ist eine echte Obermenge des JRE und enhält die folgenden Komponenten die man zur Entwicklung und Ausführung von Java Programmen im Rahmen des Kurses benötigt:

Dies ergibt die folgenden Zusammenhänge zwischen den verschiedenen Dateien die bei der Entwicklung beteiligt sind:

Referenzen

JDK 8.0 Dokumentation 

Zur Verwaltung der Objekte(Daten) in einem Programm dienen Datenbehälter die Variable oder Konstante genannt werden. 

pi = 3.14;

x = 0;
x = 1;
x = x +1;

Variablen müssen in Java immer deklariert sein bevor man sie benutzen kann. Dies erfolgt mit einer Deklaration in der folgenden Syntax:

Typ der Variablen: bestimmt den Wertebereich und Operationen auf einer Variablen. Er ist fest für die Lebensdauer einer Variablen.

Variablennamen: Ein beliebiger Bezeichner zum Benennen der Variable. Der Variablenname muß innerhalb eines gegebenen Kontexts eindeutig sein. Man kann einen Namen nicht zweimal in einem bestimmten Kontext verwenden.

Beispiele:

int x;
float y,z;

Variablen erhalten mit Zuweisungen eine neue Belegung. Hierfür können Konstanten, Variablen oder Audrücke benutzt werden deren Ergebnis auf eine Variable zugewiesen wird.

Die Syntax einer Zuweisung ist in Java immer:

Das Gleichzeichen "=" ist in Java ein Operator. Es hat hier eine andere Bedeutung als in der Mathematik. Es handelt sich nicht um eine mathematische Gleichung! Eine Zuweisung wird immer mit einem Semikolon beendet Es ist optional möglich eine Variable in einem Schritt zu deklarieren und ihr gleichzeitig einen Wert zuzuweisen.

Beispiele:

int x = 1;
float y = 3.2* 4.1;

Die Bedeutung in Java ist:

Java führt immer zuerst die Berechnung des Ausdrucks auf der rechten Seite aus. Erst dann weist Java das Ergebnis der Variablen zu.

Der Ausdruck selbst muss nicht unbedingt eine komplexe Berechnung sein. Er kann auch eine Variable oder Konstante sein.

Tipps zum Verstehen einer Zuweisung

• Identifizieren sie die 4 Bestandteile einer Zuweisung
  1. Zuweisungsoperator =
  2. Semikolon
  3. Variable (links vom Zuweisungsoperator)
  4. Term (rechts vom Zuweisungsoperator, links vom Semikolon
• Lesen Sie eine eine Zuweisung immer von rechts nach links. Zuerst wird der Term auf der rechten Seite berechnet. Dann wird das Ergebnis der linken Seite zugewiesen

Ein Beispiel sei ein einfaches Programm welches die Eingaben in den Variablen x und y nutzt um durch fortgesetzte Addition zu Multiplizieren.

Beispiele

Zuweisung einer Konstanten auf eine Variable. Um genau zu sein: Es wird ein Literal zugewiesen.

pi = 3.14;

Zuweisung einer Variablen auf eine andere Variable:

d = pi;

Zuweisung eines mathematischen Ausdrucks(Term) auf eine Variable. Der Term wird vor der Zuweisung berechnet.

d = 2*pi*r;

Zuweisung eines Terms der die Variable selbst enthält. Der Term wird vor der Zuweisung mit dem alten Wert der Variablen berechnet. Erst nach der Berechnung wird der neue Wert zugewiesen.

d = 2* d;

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

• Übersetzen Sie die Datei HelloWorld.java mit Hilfe des Kommandos javac in eine Bytecode-Datei mit dem Namen HelloWorld.class.
• Führen Sie das Programm mit dem Kommando java aus.

1.7.2 Eine einfache grafische Oberfläche

1.7.3 Swing Rechner

Diese Übung ist eine Gruppenübung. Sie ist wahrscheinlich zu schwer für das Selbststudium.

1. Quellcode erzeugen

Erzeugen Sie eine Datei mit dem Namen SwingRechner.java und dem folgendem Inhalt:

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JPanel;

public class SwingRechner  extends javax.swing.JFrame {
    private javax.swing.ButtonGroup buttonGroup1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JTextField jTextField2;
    private javax.swing.JTextField jTextFieldOut;
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JButton jButton3;

    private void initComponents() {
        jTextField1 = new javax.swing.JTextField();
        jTextField2 = new javax.swing.JTextField();
        jTextFieldOut = new javax.swing.JTextField();

        jButton1 = new javax.swing.JButton();
        jButton2 = new javax.swing.JButton();
        jButton3 = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Swing Rechner");
        jTextField1.setText("0");
        jTextField1.setColumns(6);
        jTextField2.setText("0");
        jTextField2.setColumns(6);
        jTextFieldOut.setText("0");
        jTextFieldOut.setEditable(false);

        jButton1.setText("XXXX");
        jButton2.setText("YYYY");
        jButton3.setText("ZZZZ");

        JPanel radioPanel = new JPanel(new GridLayout(1, 0));
        radioPanel.add(jButton1);
        radioPanel.add(jButton2);
        radioPanel.add(jButton3);

        jButton1.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton1)
                        jTextFieldOut.setText(
                                executeOperation1(jTextField1.getText(),
                                jTextField2.getText()));
                    }
                }
          );
          jButton2.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton2)
                        jTextFieldOut.setText(
                                executeOperation2(jTextField1.getText(),
                                jTextField2.getText()));
                    }
                }
          );
          jButton3.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton3)
                        jTextFieldOut.setText(
                                executeOperation3(jTextField1.getText(),
                                jTextField2.getText()));
                    }
                }
          );

        this.setBounds(300, 300, 200, 30);
        setMinimumSize(new Dimension(200,30));
        getContentPane().add(jTextField1, BorderLayout.WEST);
        getContentPane().add(jTextField2, BorderLayout.EAST);
        getContentPane().add(radioPanel, BorderLayout.NORTH);
        getContentPane().add(jTextFieldOut, BorderLayout.SOUTH);
        pack();
   }
    public SwingRechner() {
        initComponents();
    }

    public static void main(String[] args) {

        SwingRechner f1 = new SwingRechner();
        f1.setVisible(true);

    }

    public String executeOperation1(String s1,String s2) {
        int op1= Integer.parseInt(s1);
        int op2= Integer.parseInt(s2);
        // Add Application logic here:
        int resultInt = 0;
        return (Integer.toString(resultInt)) ;
    }
    public String executeOperation2(String s1,String s2) {
        int op1= Integer.parseInt(s1);
        int op2= Integer.parseInt(s2);
        // Add Application logic here:
        int resultInt = 1;
        return (Integer.toString(resultInt)) ;
    }
    public String executeOperation3(String s1,String s2) {
        int op1= Integer.parseInt(s1);
        int op2= Integer.parseInt(s2);
        int resultInt = 2;
        return (Integer.toString(resultInt)) ;
    }
}

2. Erzeugen Sie die Javabytecodedatei SwingRechner.class

javac SwingRechner.java

3. Führen sie das Programm aus

 java SwingRechner

Das erscheinende Programmfenster sollte so aussehen

Programmvorlage	Gelöste Aufgabe

4. Programmanpassung

Passen Sie das Programm an um einen Rechner für drei Grundrechenarten zu erhalten. Ersetzen sie in SwingRechner.java die folgenden Texte

• XXXX durch ein Symbol einer Rechenart
• YYYY durch eine Symbol einer Rechenart
• ZZZZ durch ein Symbol einer Rechenart

Implementieren Sie die drei entsprechenden Grundrechenarten in den Methoden executeOperation1(), executeOperation2(), executeOperation3().

Ändern Sie hierfür die drei Zuweisungen sinngemäss und ersetzen sie die Zuweisungen von 0, 1, 2 durch den passenden mathematischen Term mit op1 und op2.

...
        int resultInt = 0;
...
        int resultInt = 1;
...
        int resultInt = 2;
...

Das Programm soll anschliesend die Operationen passend zu den Buttonbeschriftungen ausführen

5. Speichern, Übersetzen und Ausführen des Programms

1.7.4 Übersetzen und Ausführen eines Programms mit Konsoleneingaben

Erzeugen Sie eine Datei mit dem entsprechenden Namen. Setzen Sie den unten aufgeführten Quellcode ein. Übersetzen Sie ihn. Führen Sie ihn aus.

import java.util.Scanner;
public class GGT {
    public static void main(String[] args) {
        Scanner eingabe = new Scanner(System.in);
        System.out.print("Geben Sie die erste Zahl ein: ");
        int zahl1 = eingabe.nextInt();
        System.out.print("Geben Sie die zweite Zahl ein: ");
        int zahl2 = eingabe.nextInt();
        int ergebnis = ggT(zahl1, zahl2);
        System.out.println("Ergebnis: " + ergebnis);
    }
    /**
     * Euklidscher Algorithmus als Java-Methode
     */
    public static int ggT(int x, int y) {
        while (x != y) {
            System.out.println("Zwischenbelegung, x= " + x + ", y=" + y);
            if (x > y) {
                x = x - y;
            } else {
                y = y - x;
            }
        }
        return x;
    }
}

 1.7.8 Airline in Block 1

Warnung: Alle verwendeten Namen in Java sind sensitiv auf Klein- und Großschreibung! Dies bedeutet, dass für Java ein Name der wie in der deutschen Sprache mit einem Großbuchstaben beginnt, etwas anderes ist als ein Name mit der mit einem Kleinbuchstaben beginnt.

Legen Sie ein Projekt "javakurs1" für die erste Vorlesung an.

Benutzen Sie in Netbeans den Menüpunkt File->New Project

Sie erhalten dann einen modalen Dialog. Wählen Sie "Java Application" dann den Button "next".

Der Name des Projekts ist prinzipiell frei wählbar und hat keinen weiteren Einfluß für die Vorlesung (Sie müssen dieses Projekt nur wieder finden und sie sollten hier keine Klassen benutzen die noch in der Vorlesung kommen werden).

• Tragen Sie nur im ersten Feld "Project Name" den Wert "javakurs1" ein.
• Entfernen Sie in der Checkbox "Create Main Class" den Haken.
• Clicken Sie auf "Finish"

 Empfehlung: Ändern Sie in diesem keines der anderen Felder und einen wirklich guten Grund

2. Anlegen eines Pakets "Airline"

Pakete dienen zum Trennen und Gruppieren von Klassen in Java.

Bewegen Sie die Maus über das Projektsymbol (Kaffeetasse) mit dem Namen "javakurs1" und lassen Sie sich mit einem rechte Mausklick mit Halten das folgende Auswahlmenü anzeigen.

Wählen Sie hier "New"->"Java Package" aus:

Es erscheint der folgende modale Dialog:

 Tragen Sie bei "Package Name" den Wert "Airline" ein un beenden Sie den Dialog mit dem "Finish" Button.

3. Erzeugen eines Unterpakets "Block1" im Paket "Airline"

In jeder Vorlesungsstunde(Block) wird in der Regel ein neues Paket verwenden.

Diese Aufgabe müssen Sie in jeder Vorlesungsstunde sinngemäß wiederholen.

In der linken Spalte kann man das Projekt "javakurs1" sehen. Diese Projekt hat eine Unterkategorie "Source packages". Hier sollte es jetzt einen Eintrag für ein Paket mit dem Namen "Airline" geben.

Man kann Unterpakte erzeugen, in dem man die Maus auf das Symbol von "Airline" bewegt. Führen Sie auf diesem Symbol einen Rechtsklick aus und halten Sie ihn.

Wählen Sie hier, wie zuvor "New"->"Java Package" aus

Es erscheint ein modaler Dialog. Tragen Sie hier im Feld "Package Name" den Wert "Airline.Block1" ein.

Beenden Sie den Dialog mit "Finish"

Wichtig: Hier wird einer Unterpaket zum Paket Airline angelegt. Der Punkt zwischen "Airline" und "Block1" trennt die beiden Namen. Er ist notwendig. Hier darf kein anderes Zeichen (z.Bsp. Leerzeichen stehen).

 4. Anlegen der Klasse Flugzeug im Paket Airline.Block1

Gehen Sie link im Editor mit der Maus zum Paket "Airline.Block". Führen Sie einen Rechstklick aus und halten Sie ihn.

Es erscheint ein modaler Dialog.

Tragen Sie im Feld "Class Name" Flugzeug ein.

Ändern Sie die anderen Felder nicht.

Beenden Sie den Dialog mit dem Button "Finish"

Sie haben jetzt eine leer Klasse Flugzeug im Paket Airline.Block1 angelegt.

Diese Klassen können Sie nun editieren. Der Editor sieht wie folgt aus:

5. Erweitern der Klasse Flugzeug

Geben Sie Flugzeugen die Eigenschaft ein Kennzeichen zu haben. Kennzeichen sollen beliebige Zeichenketten sein. Zeichenketten sind in Java Klassen mit dem Namen String.

public class Flugzeug {
   String kennzeichen;
}

Sichern Sie diese Datei. Sie finden schon raus wie das geht :-)

Wenn die Syntax der Klasse korrekt ist, werden am rechten Rand keine roten Symbole erscheinen.

Hinweis: Sie können Javacode der Vorlesung mit Copy-und-Paste direkt in Eclipse oder Netbeans einfügen. Unter Windows kommt es vor, dass die Zeilenumbrüche von html verloren gehen. Nutzen Sie in diesem Fall die Windows Anwendungen Notepad oder Wordpad als "Zwischenlandeplatz".

6. Anlegen der Klasse Flughafen

Nutzen Sie Ihre neuen Kenntnisse und Erzeugen Sie eine Klasse Flughafen im Paket Airline.Block1.

7. Erweitern der Klasse Flughafen

Flughäfen sollen die folgenden Eigenschaften haben

• einen Namen name der mit Zeichenketten verwaltet wird
• Sechs Flugsteige gate1 bis gate6 an denen Flugzeuge andocken können
• ein Treibstofflage treibstofflager in dem mit einer großen Fließkommazahl (double) der gelagerte Treibstoff verwaltet

Dies geschieht wenn Sie die Klasse Flugzeug mit dem fett gedruckten Text erweitern:

public class Flughafen {
     String name; 
     Flugzeug gate1; 
     Flugzeug gate2; 
     Flugzeug gate3; 
     Flugzeug gate4; 
     Flugzeug gate5; 
     Flugzeug gate6; 
     double treibstoffLager;
}

Es sollten nach Ihren Anpasssungen, links kein Fehler aufleuchten!

8. Schreiben eines Hauptprogramms in der Klasse Flughafen

Fügen Sie eine leer Methode mit dem Namen main() ein. Die Syntax muss exakt so aussehen wie im fett gedruckten Text

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) { 
   }
}

Nach dem Sichern der Datei Flughafen hat sich die Ikone in der linken Spalte verändert. Sie enthält jetzt eine grünes Dreieck.

Das grüne Dreick hat die Bedeutung der bekannten Starttaste. Diese Klasse kann man als Hauptprogramm ausführen!

Diese Klasse können Sie ausführen indem Sie die Maus über das Symbol der Klasse bewegen

Unten auf dem Bildschirm taucht eine Konsole auf. Es werden zunächst alle geänderten Klassen übersetzt und dann die gewünschte Klasse gestartet. Da die main() Methode der Klasse Flugzeug aber nichts macht, gibt es auch eine Ausgaben.

 Fügen Sie den folgenden Code innerhalb der geschweiften Klammern ein, die die Methode main() begrenzen.

public static void main(String[] args) {
   Flughafen pad = new Flughafen();
   pad.name="Paderborn";
   pad.treibstoffLager = 1000000;

   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("***********************");

}

Sichern Sie die Datei und starten Sie die Klasse Flughafen erneut an.

Sie sollten die folgende Konsolenausgabe sehen:

Was ist hier passiert?

Flughafen pad = new Flughafen();

pad.name="Paderborn";

pad.treibstoffLager = 1000000;

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("***********************");

9. Erzeugen eines Flugzeugs und Anlegen am Gate1 

Implementieren Sie die folgenden Befehle am Ende der main() Methode.

• Legen Sie eine Zeigervariable vom Typ Flugzeug mit dem Namen lh1 and und Erzeugen Sie ein Flugzeugobjekt
• Geben Sie dem Flugzeug das Kennzeichen D-ABTL
• "Docken" Sie das Flugzeug am Gate 1 des Flughafens pad an.
• Geben Sie den Namen des Flugzeugs an Gate aus
• Wiederholen Sie all Druckbefehlee des vorhergenden Schritts.

Hierzu muss die folgende Codesequenz in der main() Methode vor der letzten geschwiften Klammer eingefügt werden:

        // 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("Flughafen " + pad.name);
        System.out.println("Am Gate 1: " + pad.gate1.kennzeichen);
  
        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("***********************");

Sichern Sie die Datei. Übersetzen Sie Datei und führen Sie sie wieder aus.

Die Ausgabe auf der Konsole ist:

*** Unser Flughafen ***
Flughafen Paderborn
Am Gate 1: null
Am Gate 2: null
Am Gate 3: null
Treibstoff: 1000000.0
***********************
Flughafen Paderborn
Am Gate 1: D-ABTL
*** Unser Flughafen ***
Flughafen Paderborn
Am Gate 1: AirlineSolution.Block1.Flugzeug@677327b6
Am Gate 2: null
Am Gate 3: null
Treibstoff: 1000000.0
***********************

10. Anlegen eines zweiten Flugzeugs

Fügen Sie in der main() Methode nach dem Anlegen des ersten Flugzeugs die folgenden Befehle ein:

• Legen Sie eine Variable lh2 für ein zweites Flugzeug und erzeugen Sie ein Flugzeugobjekt wie beim ersten Flugzeug
• Das Kennzeichen des Flugzeugs soll D-AIMA sein
• Legen Sie das Flugzeug an Gate 2 des Flughafens pad 

Fügen Sie hinter den Befehl der das erste Flugzeug an Gate 1 ausgibt einen gleichartigen Befehl für Gate 2

Die main() Methode sieht jetzt wie folgt aus. Die neuen Befehle sind fett gedruckt:

    public static void main(String[] args) {
        Flughafen pad = new Flughafen();
        pad.name="Paderborn";
        pad.treibstoffLager = 1000000;
        
        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("***********************");
        
        // Boeing 747, https://de.wikipedia.org/wiki/Boeing_747#747-400
        Flugzeug lh1 = new Flugzeug();
        lh1.kennzeichen ="D-ABTL";
        
        pad.gate1 = lh1;
        
        // Airbus A380 https://de.wikipedia.org/wiki/Airbus_A380#A380-800
        Flugzeug lh2 = new Flugzeug();
        lh2.kennzeichen = "D-AIMA";
        
        pad.gate2 = lh2;
        
        System.out.println("Flughafen " + pad.name);
        System.out.println("Am Gate 1: " + pad.gate1.kennzeichen);
        System.out.println("Am Gate 2: " + pad.gate2.kennzeichen); 
        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("***********************");
           
    }    

Sichern Sie die Datei, übersetzen Sie sie, führen Sie die main() Methode der Klasse Flughafen aus.

*** Unser Flughafen ***
Flughafen Paderborn
Am Gate 1: null
Am Gate 2: null
Am Gate 3: null
Treibstoff: 1000000.0
***********************
Flughafen Paderborn
Am Gate 1: D-ABTL
Am Gate 2: D-AIMA
*** Unser Flughafen ***
Flughafen Paderborn
Am Gate 1: AirlineSolution.Block1.Flugzeug@677327b6
Am Gate 2: AirlineSolution.Block1.Flugzeug@14ae5a5
Am Gate 3: null
Treibstoff: 1000000.0
***********************

1.8.3 Swing Rechner

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JPanel;

public class SwingRechner  extends javax.swing.JFrame {
    private javax.swing.ButtonGroup buttonGroup1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JTextField jTextField2;
    private javax.swing.JTextField jTextFieldOut;
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JButton jButton3;


    private void initComponents() {
        jTextField1 = new javax.swing.JTextField();
        jTextField2 = new javax.swing.JTextField();
        jTextFieldOut = new javax.swing.JTextField();

        jButton1 = new javax.swing.JButton();
        jButton2 = new javax.swing.JButton();
        jButton3 = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Swing Rechner");
        jTextField1.setText("0");
        jTextField1.setColumns(6);
        jTextField2.setText("0");
        jTextField2.setColumns(6);
        jTextFieldOut.setText("0");
        jTextFieldOut.setEditable(false);

        jButton1.setText("+");
        jButton2.setText("-");
        jButton3.setText("*");

        JPanel radioPanel = new JPanel(new GridLayout(1, 0));
        radioPanel.add(jButton1);
        radioPanel.add(jButton2);
        radioPanel.add(jButton3);

        jButton1.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton1)
                        jTextFieldOut.setText(
                                executeOperation1(jTextField1.getText(),
                                jTextField2.getText()));
                    }
                }
          );
          jButton2.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton2)
                        jTextFieldOut.setText(
                                executeOperation2(jTextField1.getText(),
                                jTextField2.getText()));
                    }
                }
          );
          jButton3.addActionListener(new ActionListener()
                {
                public void actionPerformed(ActionEvent e) {
                    if(e.getSource() == jButton3)
                        jTextFieldOut.setText(
                                executeOperation3(jTextField1.getText(),
                                jTextField2.getText()));
                    }
                }
          );

        this.setBounds(300, 300, 200, 30);
        setMinimumSize(new Dimension(200,30));
        getContentPane().add(jTextField1, BorderLayout.WEST);
        getContentPane().add(jTextField2, BorderLayout.EAST);
        getContentPane().add(radioPanel, BorderLayout.NORTH);
        getContentPane().add(jTextFieldOut, BorderLayout.SOUTH);
        pack();
   }
    public SwingRechner() {
        initComponents();
    }

    public static void main(String[] args) {

        SwingRechner f1 = new SwingRechner();
        f1.setVisible(true);

    }

    public String executeOperation1(String s1,String s2) {
        int op1= Integer.parseInt(s1);
        int op2= Integer.parseInt(s2);
        // Add Application logic here:
        int resultInt = op1+op2;
        return (Integer.toString(resultInt)) ;
    }
    public String executeOperation2(String s1,String s2) {
        int op1= Integer.parseInt(s1);
        int op2= Integer.parseInt(s2);
        // Add Application logic here:
        int resultInt = op1-op2;
        return (Integer.toString(resultInt)) ;
    }
    public String executeOperation3(String s1,String s2) {
        int op1= Integer.parseInt(s1);
        int op2= Integer.parseInt(s2);
        int resultInt = op1*op2;
        return (Integer.toString(resultInt)) ;
    }
}

Beispiel

1.7.8 Airline Block1

Klasse Flugzeug

package AirlineSolution.Block1;

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

}

Klasse Flughafen

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package AirlineSolution.Block1;

/**
*
* @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;

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("***********************");

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

pad.gate1 = lh1;

// Airbus A380 https://de.wikipedia.org/wiki/Airbus_A380#A380-800
Flugzeug lh2 = new Flugzeug();
lh2.kennzeichen = "D-AIMA";

pad.gate2 = lh2;

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

// Hänge Flugzeug um. mover bewegt Flugzeug
// von Gate 1 nach Gate 3

Flugzeug mover = pad.gate1;
pad.gate1=null;

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.kennzeichen);
System.out.println("Am Gate 3: " + pad.gate3);
System.out.println("Treibstoff: " + pad.treibstoffLager);
System.out.println("***********************");

pad.gate3= mover;
mover=null;

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.kennzeichen);
System.out.println("Am Gate 3: " + pad.gate3.kennzeichen);
System.out.println("Treibstoff: " + pad.treibstoffLager);
System.out.println("***********************");

}
}

1.10.2 Zuweisungen

• Welche vier Syntaxkomponenten enhält eine Anweisung?
• In welcher Reihenfolge stehen die vier Syntaxkomponenten
• Welche der folgenden Anweisungen sind erlaubt?

a  = 4;
a  = a;
a  = b
18 = c;
c = 18 + a;
d = 18 - c;
a,b = 18;

1.10.3 Zuweisungsbeispiel

Welche Belegung haben die Variablen x,y und z wenn alle Zuweisungen ausgeführt?

Notieren Sie zur Hilfe alle Zwischenzustände

1.11.1 Javakommandos des JDK

• Mit welchem Befehl übersetzt man ein Javaquellprogramm in eine Javabinärdatei? javac
  • Welche Datei ensteht beim Übersetzen einer Datei mit dem Namen Fahrzeug.java die eine Klasse Fahrzeug enhält? Fahrzeug.class
• Mit welchem Befehl kann man Javabinärdateien ausführen? java
• Eine Datei Test.java enthält eine Klasse Test. Mit welcher Befehlsequenz übersetzen Sie die Javaquelldatei Test.java und führen die Klasse Test dann aus?
  • javac Test.java
  • java Test
• Nennen Sie mindestens drei Javabefehle die nur das JDK enthält nicht aber das JRE
  • javac
  • javadoc
  • javap
• Welcher Typ von Dateien wird vom Befehl javadoc erzeugt?
  • javadoc erzeugt Dokumentationsdateien im html Format. Die Dateiendung ist daher .html

1.11.2 Zuweisungen

• Welche vier Syntaxkomponenten enhält eine Anweisung?
  1. Variable
  2. Zuweisungsoperator =
  3. Term
  4. Semikolon
• In welcher Reihenfolge stehen die vier Syntaxkomponenten?
  • siehe vorherige Antwort
• Welche der folgenden Anweisungen sind erlaubt?

a  = 4;     // korrekt
a  = a;     // korrekt
a  = b      // falsch. Das Semikolon fehlt
18 = c;     // falsch. 18 ist kein gültiger Bezeichner. c = 18; wäre erlaubt (und sinnvoll)
c = 18 + a; // korrekt
d = 18 - c; // korrekt
a,b = 18;   // falsch. Man kann nur einer Variablen gleichzeitig einen Wert zuweisen

1.11.3 Zuweisungsbeispiel

Welche Belegung haben die Variablen x,y und z wenn alle Zuweisungen ausgeführt?

Hinweis: Es wurden nur geänderte Werte eingetragen. Ist ein Feld leer, so gilt der früherer Wert weiter oben

Lernzielkontrolle

Sie sind in der Lage die Fragen zur Einführung zu beantworten.

Feedback

Zur Umfrage

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

Durch Verzweigungen können im Ablauffluß des Programmes verschiedene Fälle geprüft werden und man kann abhängig davon unterschiedliche Anweisungen ausführen.

Befehlsblöcke

Java erlaubt das Zusammenfassen von Javabefehlen durch Blöcke. Blöcke werden geschweiften Klammern beschrieben.

Für Blöcke gilt

• Im Block deklarierte Variablen sind nur innerhalb des Blocks, nach der Deklaration benutzbar
• Befehle innerhalb eines Blocks müssen mit Semikolon getrennt werden
• Auch der letzte Befehl in einem Block muss mit Semikolon abgeschlossen werden
• Blöcke können geschachtelt werden

Beispiel

{
   int i = 1;
   i++;
   int j = i*2;
}

Tipp: Systematisches Einrücken und Klammern die genau übereinander stehen helfen sehr bei der Lesbarkeit

Einfachverzweigung (if, if else)

Eine Einfachverzweigung wird in Java mit dem Schlüsselwort if eingeleitet. Anschließend folgt eine Bedingung in runden Klammern. Ist die Bedingung erfüllt, wird die folgende Anweisung bzw. der Anweisungsblock in geschweiften Klammern ausgeführt. Hierdurch ergibt sich die folgende Syntax:

if (Bedingung) Anweisung;

oder

if (Bedingung) {Anweisung(en);}

Ist die Bedingung nicht erfüllt wird die Anweisung ausgelassen und der normale Ausführungsfluß wird wieder aufgenommen. Ein Beispiel hierfür ist:

int x = 8;
if (x > 5) System.out.println("Wert  x = " + x + " ist größer als 5");
   System.out.println ("Wert  x = " + x);

Hier ergeben sich die Ausgaben:

Wert x = 8 ist größer als 5
Wert x = 8

da die bedingte Anweisung sowie die letzte Anweisung durchlaufen wird.

UML Darstellung in Aktivitätsdiagrammen

if Bedingung ohne else Klausel kann man die geschweiften Klammer bei einer einzelnen Anweisung weglassen.

Entweder-oder Kontrollfluss mit dem Schlüsselwort else

Es gibt auch die Möglichkeit eines entweder-oder Kontrollflusses mit Hilfe des Schlüsselworts else:

if (Bedingung) {Anweisung(en);}
     else {Anweisung(en);};

Hier wird der eine oder der andere Block von Anweisungen ausgeführt.

Ein Beispiel:

int x = 8;
int y = 0;
if (x > 5) {
      System.out.println("Wert x = " + x + " ist größer als 5"); 
      y = x; 
   } 
   else { 
      System.out.println("Wert x = " + x + " ist kleiner oder gleich 5"); 
      y = -x; 
   } 
System.out.println ("Wert x = " + x );

UML Darstellung in Aktivitätsdiagrammen

if Anweisungen lassen sich schachteln um komplexe Bedingungen prüfen zu können. Anbei ein Beispiel:

int a = 5; int b = 10; int maximum =0; if (a > b) // Äussere if Bedingung if (a > 0) { maximum = a;} // Innere if Bedingung else { maximum = 0; } //innere else Bedingung System.out.println ("Wert maximum = " + maximum ");

Im oben gezeigten Beispiel gibt es eine else Bedingung von der es nicht offensichtlich ist zu welchem if Block sie gehört.

Tipp: Der Quellcode wird bei geschachtelten if Bedingungen schnell unübersichtlich und fehleranfällig.

Verwenden Sie besser die im Folgenden vorgestellte switch Bedingung um komplexe Abfragen zu implementieren.

Mehrfachverzweigung (switch-case)

Eine Alternative zu if-else Anweisungen ist die switch-case Anweisung. Sie erlaubt eine sehr viel übersichtlichere Programmierung wenn es bei einem ganzzahligen Ausdruck mehr als zwei Alternativen gibt.

Im einfachen Fall sieht eine switch-case Anwendung wie folgt aus:

int wochentag; ... switch (wochentag) { case 7: System.out.println("Sonntag"); break; case 6: System.out.println("Samstag"); break; case 5: case 4: case 3: case 2: case 1: System.out.println("Wochentag"); break; default: System.out.println("Fehler"); }

int wochentag;
...
switch (wochentag) {
   case 7:
      System.out.println("Sonntag");
      break;
   case 6:
      System.out.println("Samstag");
      break;
   case 5: case 4: case 3: case 2: case 1:
      System.out.println("Wochentag");
      break;
   default:
      System.out.println("Kein gültiger Wochentag!");
}

Besonderheiten der switch-case Anweisung

• Der zu prüfende Ausdruck muss bestimmten Typen genügen: 
  • byte, short, int, char, enum, String. (Die Unterstützung von String ist neu seit JDK 7, siehe JSR 334, Projekt Coin)
• Die einzelnen Fälle (cases) werden nicht mit geschweiften Klammern geklammert
• Das Schlüsselwort break dient zum Rücksprung aus einem Fall. Der nächste Fall wird mit abgearbeitet wenn es weggelassen wird!
• Es können mehrere Fälle mit Doppelpunkt aufgeführt werden. Der darauf folgende Block wird dann für alle Fälle abgearbeitet.
• Das Schlüsselwort default erlaubt einen Ausführungsblock anzugeben, der ausgeführt wird wenn kein anderer Fall zum Zuge kam
• Der Wert in einem Fall (case) muss eine Konstante sein.

Allgemeine Form:

...
switch (Ausdruck) {
   case konstante1:
      Anweisung(en);
      break;
...
   case konstante2: case konstante3: ... case konstanteN:
      Anweisung(en);
      break;
   default:
      Anweisung(en);
      break;
}

Beispiel mit unterschiedlichen Break-Anweisungen

int wochentag; ... switch (wochentag) { case 7: System.out.println("Sonntag"); break; case 6: System.out.println("Samstag"); case 5: case 4: case 3: case 2: case 1: System.out.println("Wochentag"); break; default: System.out.println("Fehler"); }

Schleifen erlauben die Wiederholungen von Einzelanweisung. Schleifen bestehen typischerweise aus den folgenden Komponenten

• einen Schleifenrumpf mit den auszuführenden Anweisungen
• einem Kopf oder Fuß mit einer Ausführungsbedingung
• oft einer Laufvariablen mit der die Durchläufe kontrolliert werden

Die while Schleife 

Die while Schleife überprüft vor dem Schleifeneintritt ob die Ausführungsbedingung (noch) erfüllt ist. Sie enthält die Schleifenbedingung im Kopf der Schleife.

while ( Bedingung) { Anweisung ; } 

while ( Bedingung) Anweisung; 

int i = 1;
int summe= 0;
while (i<=5) {
   summe = summe + i;
   i++;
}

Die do-while-Schleife

Die do-while-Schleife überprüft nach dem ersten Schleifendurchlauf ob die Ausführungsbedingung erfüllt ist. Sie enthält die Schleifenbedingung im Fuß der Schleife. Die Syntax der do-while Schleife ist die folgende: do { Anweisung ; } while ( Bedingung ); oder do Anweisung; while ( Bedingung ); Beispiel: Beende Schleife wenn Wert durch 3 ohne Rest teilt int i = 9; int j = 0; // Zählt Schleifendurchläufe do { j++; i--; } while (i%3 != 0); Die Schleife wird dreimal durchlaufen.

Regel:

• Die while Schleife ist eine abweisende Schleife: Sie wird nicht notwendigerweise durchlaufen.
• Die do-while ist eine nicht abweisende Schleife: Sie wird mindestens einmal durchlaufen.

Diese Unterscheidung ist in verschiedenen Bereichen wichtig

• Variablen werden bei einer abweisenden Schleife eventuell nicht belegt
• Es wird manchmal in der Qualitätssicherung gefordert, dass alle Zeilen eines Programmes duchlaufen werden. Bei abweisenden Schleifen muss man unter Umständen bei der Implementierung der Testabdeckung mehr investieren.

Die for-Schleife

Die for-Schleife überprüft die Schleifenbedingung vor dem Eintritt in die Schleife.

Ihre Syntax ist die anspruchsvollste der drei Schleifenarten:

for (Initialiserung; Bedingung; Veränderung) {Anweisung ;}

oder

for (Initialiserung; Bedingung; Veränderung) Anweisung;

Der Kopf der for-Schleife besteht aus den folgenden drei Teilen:

• Initialisierungsteil: Laufvariable und Startwert werden festgelegt.
• Bedingungsteil: Wird der Wert der Bedingung unwahr (false) wird die Schleife verlassen oder nicht betreten. Ansonsten wird sie weiter fortgesetzt.
• Veränderungsteil: Nach jedem Durchlauf der Schleife wird die Laufvariable entsprechen verändert (Typischerweise inkrementiert oder dekrementiert).

Beispiel einer einfachen for-Schleife

Im folgenden Beispiel wird die for-Schleife "b mal" durchlaufen. Durch das Aufaddieren der Variablen a wird eine Multiplikation von positiven Zahlen ausgeführt.

Ist b gleich Null oder negativ wird die Schleife nicht durchlaufen.

Geschachtelte Schleifen

Oft ist es notwendig Schleifen zu schachteln. Dies kommt oft bei mehrdimensionalen Datenstrukturen vor bei denen jedes Feld bearbeitet werden muss. Bei jedem Durchlauf der äusseren Schleife wird die innere aufgerufen, die ihre eigenen Durchläufe komplett bei jedem Durchlauf der äusseren Schleife durchführt. Anbei ein Beispiel einer naiven Multiplikation die auf Inkrementieren beruht:

class MultiplizierenNaiv {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int result = 0;
        for (int i = 1; i <= a; i++) {
            System.out.println("Äussere Schleife i = " + i);
            for (int j = 1; j <= b; j++) {
                System.out.println("Innere Schleife j = " + j);
                result++;
            }
        }
        System.out.println(a +"*"+b+" = "+result);
    }
}

Geschachtelte Schleifen sind sehr mächtig und sie haben ein viel größeres Potential Rechnerleistung zu binden. Die Aufwände bei zwei geschachtelten Schleifen können quadratisch steigen im Vergleich zum linearen Aufwand einer einfachen Schleife. Generell gilt, dass eine teure Anweisung in einer Schleife n-mal statt einmal durchlaufen werden kann. Es ist daher wichtig auf die folgenden Dinge zu achten:

• Lassen Sie alle Anweisungen die man vor oder nach der Schleife ausführen kann aus dem Schleifenblock draussen
• Definieren und Initialisieren Sie Variablen wenn möglich ausserhalb der Schleife und verwenden Sie die Variablen wieder. Die Variable muss sonst jedes mal neu angelegt und wieder gelöscht werden.
• Verzichten Sie auf unnötige Schleifendurchläufe
• Seien Sie vorsichtig bei mehrfach geschachtelten Schleifen. Die Anzahl der Durchläufe kann theoretisch sehr schnell, sehr groß werden. Eine dreifach geschachtelte Schleife mit jeweils 1000 Durchläufen wird eine Milliarde mal ausgeführt!

Sprunganweisungen und Schleifenabbrüche mit continue und break Schlüsselwörtern

Java verfügt über zwei Möglichkeiten Schleifen in der Mitte von Ausführungsblöcken zu verlassen. Diese Programmiertechnik sollte man normalerweise vermeiden.

In manchen Fällen ist sie jedoch nützlich. Schleifenabbrüche werden durch die beiden folgenden Schlüsselwörter gesteuert:

break: die weitere Abarbeitung im Schleifenblock/rumpf wird abgebrochen. Das Programm verlässt die Schleife und nimmt die Abarbeitung hinter der Schleife wieder auf. die Abbruchkriterien der Schleife werden hier nicht mehr beachtet. continue: die Abarbeitung des aktuellen Schleifendurchlaufs wird beendet. Die Schleife wird jedoch nicht verlassen. Die nächste Iteration wird geplant ausgeführt Die break Anweisung ist schon vom switch Befehl her bekannt. Mit ihr kann man auch eine if Bedingung beenden. Beispiel einer continue Anweisung: ... for (int i=0; i<= 100; i++) { if (i%2 == 0) continue; System.out.println("Die Zahl " + i + " ist ungerade"); } Bei geraden Zahlen wird die Druckanweisung nach der if Anweisung nicht mehr ausgeführt. Die Schleifen werden jedoch alle durchlaufen.

Beispiel einer break-Anweisung: ... for (int i=1; i<= 100; i++) { if (i== 32) break;    System.out.println("Die Zahl " + i + " wurde bearbeitet"); } Die Zahlen von 1 bis 31 werden ausgedruckt. Anschließend wird die Schleife abgebrochen. Die break und continue Anweisungen beziehen sich immer auf die nächst äussere Schleife. Mit Hilfe von Labels (Marken) kann man auch über mehrere geschachtelte Schleifen nach aussen springen.

Verlassen von Blöcken mit Hilfe von Sprungzielen (Label)

Java erlaubt das Benennen von Blöcken mit Hilfe von "Labeln" (Marken). Mit ihnen kann man mit einer break-Anweisung beliebig viele Blöcke auf einmal verlassen.

Das folgende Beispiel zeigt wie man zum Label "Label1" springt um beide Schleifen auf einmal zu verlassen:

class MultiplizierenNaivLabel {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int result = 0;
        Label1: for (int i = 1; i <= a; i++) {
            System.out.println("Äussere Schleife i = " + i);
            for (int j = 1; j <= b; j++) {
                System.out.println("Innere Schleife j = " + j);
                if ((i == 3) && (j == 3)) break Label1;
                result++;
            }
        }
        System.out.println(a +"*"+b+" = "+result);
        System.out.println("Dieses Ergebnis ist falsch...");
    }  
}

Endlosenschleifen

while ( true) { /* Anweisung(en) */ }
...
for ( ; ; ) { /* Anweisung(en) */ }
...
int i=10;
while (i>5) i++;
...
int i=0;
while ( i!=99) {i++; i++;}

Felder (Arrays), Einführung

Die folgende Kurzüberblick von Feldern ist notwendig um die Übungen zu den Kontrollstrukturen zu lösen. Felder werden später noch einmal aufgegriffen und genauer behandelt.

Felder sind Datenbehälter mit einer oder mehreren Dimensionen um eine Anzahl primitive Datentypen gleichen Typs aufzunehmen.

Man kann auf die einzelnen Feldelemente wahlfrei, also direkt mit Hilfe eines Index zugreifen. Java benutzt rechteckige Klammern [] um auf einzelne Elemente eines Feldes zuzugreifen.

Initialisieren und Deklarieren von Feldern

Felder sind im Gegensatz zu Variablen mit primitiven Datentyp Objekte. Dies bedeutet, dass die die Variable nur aus einer Referenz besteht. Das Feld selbst muss dynamisch angelegt werden. Hierfür gibt es eine Reihe von Gründen.

• Der Übersetzer kann nicht wissen wie groß ein Feld werden kann
• Man kann mit einer Feldvariablen dynamisch neue Felder verwalten
• Felder können sehr groß sein. Es ist oft klüger das Feld erst anzulegen wenn man es benötigt und die Größe kennt.

Die Deklaration von Feldern geschieht wie folgt:

int[] x;  // Anlegen einer Referenz, es ist noch keine Größe vorgeben, 
                    // es können noch keine Feldelemente benutzt werden<
double[] y; // Anlegen einer Referenz, es ist noch keine Größe vorgeben, 
                    //es können noch keine Feldelemente benutzt werden

Um das eigentliche Feld anzulegen muss der new Operator verwendet werden wie für reguläre Objekte auch um den Speicher zu allozieren. Dies geschieht wie folgt:

int [] x;
x = new int[4];
double[] y;
y = new double[200];

Jetzt zeigt x auf 4 Datenbehälter für Ganzzahlen. Der Zugriff auf die vier Elemente erfolgt über einen Index im Bereich von 0 (erster Wert) bis 3.

Zugriff auf Felder

Das Feld kann nun wie folgt belegt und bearbeitet werden:

int [] x = new int[4];

x[0] = 99;
x[1] = 88;
x[2] = x[0]+x[1];
x[3] = x[0]*x[1];

Bestimmen der Länge eines Feldes

...geschieht mit dem Attribut .length. Hier ein Beispiel:

int[] x;
int groesse;
...
groesse=x.length;

Erweiterte for Schleife (enhanced for-loop)

Seit Java 5 ist es möglich mit der for Schleife Felder komfortabler abzuarbeiten. Man kann mit einer Laufvariable alle Elemente des gegeben Feldes abarbeiten. Wie zum Beispiel:

int [] xxx = { 11, 22, 33, 44, 55};
for ( int position : xxx)  // für Element auf Position position in xxx[]
  System.out.println("Wert: " + position);

Wird das folgende Ergebnis liefern:

Wert: 11 
Wert: 22
Wert: 33
Wert: 44
Wert: 55

 Die Oracle Java Dokumentation erklärt die Einsatzmöglichkeiten und Grenzen der "enhanced for-loop".

    int i = 1, j = 1;
    do {
      i = i + j;
      j++;
    } while (i < 200);

    int i = 1, j = 20;
    while (i + j < i) {
      i = i + 2;
      j--;
    }

    int i = 1, j = 20;
    while (i + j > i) {
      i = i + 2;
      j--;
    }

    int i = 100, j = 27;
    while (i != j) {
      i = i / 2;
      j = j / 3;
    }

3.3.2 Übung: Ziffern einer Zahl

Hilfestellung:

Einlesen von Zahlenwerten beim Starten von der Kommandozeile als Option wie zum Beispiel:

$ java Main 17 19

erfolgt durch Einlesen von Zeichenketten und Umwandlung in Zahlen. Anbei ein Rahmenprogramm welches das Problem löst:

public class Main {
    public static void main(String[] args) {
    int firstArg=0;
    int stellen=0;
    if (args.length > 0) {
        try {
            firstArg = Integer.parseInt(args[0]);
        } catch (NumberFormatException e) {
            System.err.println("Argument muss Ganzzahl sein");
            System.exit(1);
            }
        System.out.println("Die Zahl firstArg = " + firstArg + " wurde eingelesen");
        // Implementierung gehört hierher
        System.out.println(" Die Zahl " + firstArg + " hat " + stellen + " Stellen!");
    }
}

Eine andere Möglichkeit besteht darin, dass man das Programm startet und bei Bedarf eine Eingabe von der Konsole anfordert.

Achten Sie hier auf die fettgedruckte Importanweisung der Klasse Scanner. Sie ist notwendig um die Klasse zu benutzen:

import java.util.Scanner;
public class Eingabe {
    public static void main(String[] args) {
        Scanner eingabe = new Scanner(System.in);
        System.out.print("Geben Sie die erste Zahl ein: ");
        int zahl1 = eingabe.nextInt();
        System.out.print("Geben Sie die zweite Zahl ein: ");
        int zahl2 = eingabe.nextInt();
        System.out.println("Ergebnis: " + zahl1);
        System.out.println("Ergebnis: " + zahl2);
    }
}

Das Programm Eingabe kann man auf der Konsole wie folgt bedienen:

$ java Eingabe
Geben Sie die erste Zahl ein: 34
Geben Sie die zweite Zahl ein: 56
Ergebnis: 34
Ergebnis: 56 

Am einfachsten ist es die Eingaben in der ersten Zeile des Programmes hart zu belegen...

3.3.3 Übung: Quersumme

Schreiben Sie ein Java-Programm, das die Quersumme einer positiven ganzen Zahl berechnet und ausgibt.

Beispiel: Zahl 4711 --> Quersumme 13.

3.3.4 Übung: Zahlenstatistik

Tipp: Die Wertebereiche für die Zahlen sind Ihnen freigestellt. Der Durchschnittswert sollte korrekt sein

Hilfestellung:

Einlesen eines Feldes (Arrays) von der Kommandozeile

package s1.block3;
public class Zahlenstatistik {
    public static void main(String[] args) {
        int feld[];
        if (args.length > 0) {
            feld = new int[args.length];
            try {
                for (int i=0;i<args.length;i++) {
                    feld[i] = Integer.parseInt(args[i]);
                    // Einlesen der Kommandozeilenargumente und umwandeln in Ganzzahlen
                    }
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
                }
        // Ab hier steht das Feld mit allen Werten zur Verfügung
    }
}

3.3.5 Übung: Primfaktorzerlegung

• Die Zahl 100 besteht aus den Primfaktoren 2, 2, 5, 5;
• die Zahl 252 aus den Primfaktoren 2, 2 , 3, 3, 7.

Option: Optimieren sie Ihr Programm auf die kürzeste Laufzeit. Verwenden Sie hierzu den Nanotimer von JDK 6.0 wie folgt:

package s1.block3;
public class Primzahlzerlegung {
    public static void main(String[] args) {
        int firstArg = 0;
        int p=0;
        long time;
        time= System.nanoTime();
        if (args.length > 0) {
            try {
                p = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
                }
            System.out.println("Eingelesene Zahl: " + p);
        }
    // Die Eingabe der Kommandozeile liegt als Variable p vor.
    // Implementierung ...
    time= System.nanoTime() - time;
    System.out.println("Zeit in m: "+ time);
    }
}

Überlegungen:

• Welche Zeit wird hier gemessen?
• Was hat ausser dem Algorithmus noch Einfluss auf die Ausführungsgeschwindigkeit?
• Sind Ihre Messungen wiederholbar?
• Welche Risiken hat eine Optimierung des Algorithmus?
• Wie wichtig ist die Schnelligkeit eines Programms?

3.3.6 Übung: Codevereinfachung

// Annahme: j >= 0
    i = 0;
    while (i != j) i++;

  while (a < b) {
      c = a;
      a = b;
      b = c;
    }

3.3.7 Übung: Wochentagberechnung

Lesen Sie ein Datum in Form dreier Zahlen für den Tag, den Monat und das Jahr sowie eine weitere Zahl zwischen 0 und 6 ein, die den Wochentag (Sonntag bis Samstag) des 1. Januars dieses Jahres darstellt. Berechnen Sie den Wochentag des eingelesenen Datums und geben Sie diesen aus. Sie können davon ausgehen, dass die Eingaben korrekt sind. Berücksichtigen Sie auch Schaltjahre.

3.3.8 Übung: Überlaufprüfung

Lesen Sie zwei 32 Bit Ganzahlen (int) a und b ein und prüfen Sie, ob bei ihrer Addition ein Überlauf stattfindet, also eine Summe entstehen würde, die größer als 2³¹ - 1 oder kleiner als  -2³¹   ist.

3.3.9 Übung: Schnitt zweier Linien

Lesen Sie die Endpunkte zweier horizontaler oder vertikaler Linien in Form ihrer x- und y-Koordinaten ein und prüfen Sie, ob sich die beiden Linien schneiden. Die beiden Linien befinden sich in einem zweidimensionalen kartesischen System:

Hinweis: Wenn es einen Schnittpunkt gibt ist er (c,b)

3.3.10 Übung: Codevereinfachung

a)  

    if (b == 0)
      a = 2 * c;
    else
      if (c != 0)
        a = a * b + 2 * c;
      else
        a = a * b;

b)  

    if (x < 0 && y < 0)
      a = x * y;
    else
      if (x < 0)
        a = x * (-y);
      else
        if (y > 0)
          a = (-x) * (-y);
        else
          a = x * (-y);

3.3.11 Übung: Dreiecksbestimmung

Schreiben Sie ein Java-Programm, das die Seitenlängen eines Dreiecks einliest und prüft, ob es ein

• gleichseitiges
• gleichschenkeliges
• rechtwinkeliges
• sonstiges gültiges
• ungültiges Dreieck ist.

Ein Dreieck ist ungültig, wenn die Summe zweier Seitenlängen kleiner oder gleich der dritten Seitenlänge ist. Beachten Sie, dass ein Dreieck sowohl rechtwinkelig als auch gleichschenkelig sein kann!

3.3.12 Übung: Sortieren

Schreiben Sie ein Java-Programm, das 3 Zahlen a, b und c einliest und sie in sortierter Reihenfolge wieder ausgibt. Im Rahmenprogramm muss die letzte Zeile durch einen Sortieralgorithmus und Ausgaben ersetzt werden.

public class Sortieren {
   public static void main(String[] args) {
       int a = 0;
       int b = 0;
       int c = 0;

      if (args.length > 2 ) {
         try {
            a = Integer.parseInt(args[0]);
            b = Integer.parseInt(args[1]);
            c = Integer.parseInt(args[2]);
         } catch (NumberFormatException e) {
            System.err.println("Argument muss Ganzzahl sein");
            System.exit(1);
         }
      }
      System.out.println("Eingelesene Werte: " + a + ", " + b + ", " + c);

      System.out.println("Anstatt dieser Zeile muss ein Sortieralgorithmus implementiert werden...";
   }
}

3.3.13 Übung: Plausibilitätsprüfung

Lesen Sie ein Datum in Form dreier Zahlen für den Tag, den Monat und das Jahr ein. Prüfen Sie, ob es sich um ein gültiges Datum handelt. Berücksichtigen Sie auch Schaltjahre.

Hinweis: Gregorianischer Kalender: Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist. Jahre, die durch 100, aber nicht durch 400 teilbar sind, sind keine Schaltjahre.
Vorsicht: In der Musterlösung werden Felder verwendet. Die sind noch nicht vorgestellt worden, sie machen es aber deutlich leichter...

3.3.14 Übung: Textverschlüsselung

Schon im alten Rom verschlüsselte man Nachrichten. Ein einfaches Verschlüsselungsverfahren ist von Julius Cäsar überliefert. Es verschiebt jeden Buchstaben der Nachricht um einen fixen Wert n. Ist n gleich 2, so wird 'A' auf 'C', 'B' auf 'D' und 'Z' auf 'B' verschoben. Ziffern und Sonderzeichen werden nicht verschoben. Schreiben Sie ein Programm, das eine Zahl n und einen beliebigen Text liest und ihn nach obigem Verfahren verschlüsselt wieder ausgibt.

3.3.15 Übung: Verzweigungen

Schreiben Sie ein Java-Programm, das drei Werte x, y und z einliest und prüft, ob

• x, y und z nicht lauter gleiche Werte enthalten,
• x, y und z lauter verschiedene Werte enthalten,
• mindestens zwei Werte gleich sind.

3.3.16 Übung: Häufigkeit von Zeichen

Schreiben Sie ein Programm, das einen Text liest und die Häufigkeit der darinvorkommenden Zeichen berechnet. Geben Sie die Zeichenhäufigkeit als Histogramm aus. Beispiel:

a ****
b **
c ********
...

 Hinweis: Dieses Programm setzt Kenntnisse von Feldern vorraus die erst später behandelt werden

3.3.17 Übung: Weckzeiten implementieren

Implementieren Sie zwei logische Tests für die Kontrolle der Weckzeit einer Uhr.

Diese Aufgabe baut auf der Übung zur Implementierung einer analogen Uhr auf.

Sie benötigen 3 Klassen für diese Aufgabe die alle im gleichen Verzeichnis stehen müssen:

• Klasse Zeiger (Lösung von 2.4.11) oder Ihre eigene Implementierung. Diese Klasse muss nicht modifiziert werden.
• Klasse WeckerUhr (weiter unten). Die Klasse muss nicht modifiziert werden. Die Klasse enthält die main() Methode. Es muss immer diese Klasse (java WeckerUhr) zum Starten der Anwendung verwendet werden!
• Klasse Weckzeit: Diese Klasse muss in der Übung modifiziert werden. Die Vorlage der Klasse ist bereits übersetzbasr und ausführbar.

Es reicht die Klasse WeckerUhr zu übersetzen. Die beiden anderen Klassen werden automatisch rekursiv mitübersetzt.

Nach dem Starten der Anwendung mit java WeckerUhr erscheint das folgende Fenster:

Erste Aufgabe: Kontrolle der Wertebereiche

Die Klasse Weckzeit enthält eine Methode korrekteWeckzeit(int h, int m, int s). Diese Methode prüft die Eingaben des GUI auf korrekte Wertebereiche. Das Ergebnis wird in einer boolschen Variablen result gespeichert. Die Vorlage liefert bei allen Eingaben false. Belegen Sie die Variable so, dass vernünftige Werte akzeptiert werden.

Fragen:

• Was sind vernünftige Werte für Stunde (h), Minute(m), Sekunde(s)?
• Welche logische Verknüpfung muss man nutzen wenn alle Werte im korrekten Bereich sein sollen?

Der Erfolg Ihrer Implementierung können Sie daran erkennen, dass die Eingaben des GUI nach dem klicken des OK Knopfs in das Anzeigenfeld übernommen worden sind.

Zweite Aufgabe: Bestimmen der richtigen Zeitpunkte zum Wecken

Das Lösen der ersten Teilaufgabe ist eine Voraussetzung für den zweiten Teil (Ihr Wecker funktioniert sonst nur Mittags und um Mitternacht...)

Das Hauptprogramm der Klasse WeckerUhr ruft in der aktuellen Implementierung viermal pro Sekunde die Methode klingeln() auf um zu kontrollieren ob der Wecker klingeln soll. Ändern Sie die Referenzimplementierung derart, dass nur nach der eingebenen Weckzeit für eine bestimmte Periode geklingelt wird.

Die zu modifizierende Referenzimplementierung:

result = (aktS%10 == 0);

lässt den Wecker bei allen Sekundenwerten die durch 10 teilbar sind für eine Sekunde klingeln. 

Die Variablen aktH, aktM, aktS enthalten die aktuelle Zeit. Die Variablen wzh, wzm, wzs enthalten die Weckzeit.

Fragen:

• Wie lange soll der Wecker klingeln?
• (Zur Verfeinerung) Wie kann man gewährleisten, dass der Wecker auch um 11:59:50 für 15 Sekunden klingelt?

Klasse Weckzeit

package s1.block3;
public class Weckzeit {
    int wzh = 0; // Weckzeit in Stunden
    int wzm = 0; // Weckzeit in Minuten
    int wzs = 0; // Weckzeit in Sekunden
    public void setzeWeckzeit(int hh, int mm, int ss) {
        if (korrekteWeckzeit(hh,mm,ss)) {
            wzh = hh;
            wzm = mm;
            wzs = ss;
        }
    }
    public boolean korrekteWeckzeit(int h, int m, int s) {
        boolean result;
        // benutzen die Variablen h,m,s um eine gültige Zeit zu bestimmen
        result = false;
        return result;
    }
    public boolean klingeln(int aktH, int aktM, int aktS) {
        boolean result;
        // benutzen die Variablen der aktuellen Zeit aktH (Stunde),
        // aktM (Minute), aktS (Sekunde) und die Weckzeit wzmh, wzm, wzs
        // um zu bestimmern ob der Wecker klingeln soll
        // Verbessern Sie diese Zuweisung
        // In der aktuellen Implementieren klingelt der Wecker
        // alle 10 Sekunden für 1 Sekunde
        result = (aktS%10 == 0);
    return result;
    }
}

Klasse WeckerUhr

package s1.block3;
/*
 * 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 WeckerUhr extends JPanel {

int sekunde = 0;
int minute = 0;
int stunde = 0;
boolean klingeln = false;
String tzString; // aktuelle Zeitzone
int initialHeight;
float zoom = 1;
boolean an = false;
JFrame hf; // Das Fenster der Anwendung
Container myPane;
JTextField h,m,s;
JButton eingabe;
Weckzeit wz;
int klingelRadius = 0;
/**
* Konstruktor der Klasse. Er initialisiert die Grafik
*/
public WeckerUhr() {
wz = new Weckzeit();
hf = new JFrame("Uhr");
h = new JTextField(2);
m = new JTextField(2);
s = new JTextField(2);
eingabe = new JButton("OK");
eingabe.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
int stunde, minute, sekunde;
try {
stunde = Integer.parseInt(h.getText());
minute = Integer.parseInt(m.getText());
sekunde = Integer.parseInt(s.getText());
}
catch (NumberFormatException ex) {
// Es wurde keine korrekte Zahl eingegeben
stunde = -100;
minute = -100;
sekunde= -100;
}
wz.setzeWeckzeit(stunde,minute,sekunde);
}
});
// Beenden der Anwendung bei Schließen des Fenster
hf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Aufbau des Contentpanes
myPane = hf.getContentPane();
myPane.add(this, BorderLayout.CENTER);
JPanel wzPanel = new JPanel(new GridLayout(1,0));
wzPanel.add(new JLabel("hh:mm:ss"));
wzPanel.add(h);
wzPanel.add(m);
wzPanel.add(s);
wzPanel.add(eingabe);
myPane.add(wzPanel,BorderLayout.SOUTH);
// 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() {
@Override
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(2 * Zeiger.maxRadius + 80,
2 * Zeiger.maxRadius + 130);
hf.setVisible(true);
hf.setAlwaysOnTop(true);
initialHeight = getHeight();
}
/**
* Hauptprogramm der Anwendung. Es werden keine Eingabeparameter benötigt
* @param args dieser Parameter wird nicht ausgewertet
*/
public static void main(String[] args) {
WeckerUhr dieUhr = new WeckerUhr();
dieUhr.tickTack();

}
/**
* Diese Methode verwaltet den Zeitgeber-thread. Dieser Thread belegt
* die statischen Variablen der Uhrzeit neu
*/
public void tickTack() {
try {
boolean blinken = false;
while (true) {
Thread.sleep(250); // 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);
klingeln = wz.klingeln(stunde,minute,sekunde);
if (blinken){
klingelRadius=100;
}
else {
klingelRadius=30;
}
blinken = !blinken;
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;
   String klingelString;
   klingelString = wz.wzh +":"+wz.wzm + ":" +wz.wzs +" klingeln";
   if (klingeln) {
      g.setColor(Color.red);
      g.fillOval(xCenter-((int)(zoom*klingelRadius/2)),
         yCenter-((int)(zoom*klingelRadius/2)),
         (int)(klingelRadius*zoom),
         (int)(klingelRadius*zoom));
   }
   // Zeichne Uhrenhintergrung und Koordinatensystem
   g.setFont(g.getFont().deriveFont(fontSize));
   g.setColor(Color.BLACK); // Farbe
   g.drawArc(xCenter - 5, yCenter - 5, 10, 10, 0, 360);
   g.drawLine(xCenter, yCenter, xCenter + 40, yCenter);
   g.drawLine(xCenter, yCenter, xCenter, yCenter + 40);
   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 Weckzeit zum Debuggen
   g.drawString(klingelString, 0, (int)(yCenter + maxRadius*zoom + 25));
   // 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));
   }
}

3.4.1 Schleifenterminierung

    int i = 1, j = 1;
    do {
      i = i + j;
      j++;
    } while (i < 200);

    int i = 1, j = 20;
    while (i + j < i) {
      i = i + 2;
      j--;
    }

    int i = 1, j = 20;
    while (i + j > i) {
      i = i + 2;
      j--;
    }

    int i = 100, j = 27;
    while (i != j) {
      i = i / 2;
      j = j / 3;
    }

3.4.2 Ziffern einer Zahl

public class Main {
    public static void main(String[] args) {
    int firstArg = 0;
    int stellen = 0;
    int a;
    if (args.length > 0) {
        try {
            firstArg = Integer.parseInt(args[0]);
        } catch (NumberFormatException e) {
            System.err.println("Argument muss Ganzzahl sein");
            System.exit(1);
            }
        System.out.println("Die Zahl firstArg = " + firstArg + " wurde eingelesen");
        a = firstArg;
        while (a !=0) {
                  stellen++;
                  a/=10;
                 }
        }
        System.out.println(" Die Zahl " + firstArg + " hat " + stellen + " Stellen!");
    }
}

3.4.3 Quersumme

package s1.block3;
public class Quersumme {

    public static void main(String[] args) {
        int firstArg = 0;
        int querSumme = 0;
        int a;
        if (args.length > 0) {
            try {
                firstArg = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
                }
            System.out.println("Die Zahl " + firstArg + " wurde eingelesen");
            a = firstArg;
            while (a !=0) {
                querSumme+= a%10;
                a/=10;
            }
        System.out.println("Die Zahl " + firstArg + " hat die Quersumme " + querSumme + "!");
        }
    }
}

3.4.4 Zahlenstatistik

package s1.block3;
public class Zahlenstatistik {
    public static void main(String[] args) {
        int feld[];
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        float average = 0;
        if (args.length > 0) {
            feld = new int[args.length];
            try {
                for (int i=0;i<args.length;i++) {
                    feld[i] = Integer.parseInt(args[i]);
                    if (feld[i] < min) {min=feld[i];}
                    if (feld[i] > max) {max=feld[i];}
                    average += feld[i];
                    }
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
                }
            average= average/(float)args.length;
            System.out.println("Anzahl eingelesene Werte: " + args.length);
            System.out.println("Kleinster Wert: " + min);
            System.out.println("Größter Wert: " + max);
            System.out.println("Durchschnitt: " + average);
    }
}
}

3.4.5 Primzahlzerlegung

package s1.block3;
public class Primzahlzerlegung {
    public static void main(String[] args) {
        int firstArg = 0;
        int p=1;
        long time;
        time= System.nanoTime();
        if (args.length > 0) {
            try {
                p = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
                }
            System.out.println("Eingelesene Zahl: " + p); 
            while (p>1) {
                for (int i=2; i<= p; i++) {
                    while (p%i == 0) {
                        System.out.println("Primfaktor: " + i);
                        p /= i;
                    }
                }
            }
        }
    time= System.nanoTime() - time;
    System.out.println("Zeit in m: "+ time);
    }
}

Optimiert:

// Gute Kandidaten
// 2^30-1 = 1073741823
// 2^31-1 = 2147483647
public class Main {

    public static void Primzahlzerlegung(String[] args) {
        int firstArg = 0;
        long p = 1;
        long time;
        time = System.nanoTime();
        if (args.length > 0) {
            try {
                p = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
            }
            long i = 2;
            System.out.println("Eingelesene Zahl: " + p);
            while ((p > 1) && (i <= p)) {
                if (p % i == 0) {
                    System.out.println("Primfaktor: " + i);
                    p /= i;
                    i = 2;
                } 
                else {
                    if (i > Math.sqrt(p)) {
                        // Beende Suche wenn Wurzel von P erreicht
                        i = p;
                    } else {
                        i++;
                    }
                }
            }
        }
        time = System.nanoTime() - time;
        System.out.println("Zeit in m: " + time);
    }
}

3.4.6 Codevereinfachung

a.)

// Annahme: j >= 0
    i = j;

a = (a<b) ? b : a;
b = (a<b) ? a : b;
c = (a<b) ? a : c;

3.4.7 Wochentagberechnung

Hier wurde nur der julianische Kalender implementiert nicht der (aktuelle) gregorianische Kalender.
Hier wurden Felder verwendet, die noch nicht vorgestellt wurden.

package s1.block3;
public class WochentagBerechnung {
    public static void main(String[] args) {
       int monatOffSet[] = new int[13];
       int tag = 0;
       int monat = 0;
       int jahr=0;
       int wochentag0101startJahr= 6;
       int jahresOffSet; // Bedeutung siehe Feld tagText
       String[] tagText = {"Sonntag", "Montag", "Dienstag", "Mittwoch",
                            "Donnerstag", "Freitag", "Samstag"};
       int wochentag; 
       int startJahr = 2010;
       int anzSchaltJahre;
       if (args.length > 1 ) { 
         try { 
            tag = Integer.parseInt(args[0]); 
            monat = Integer.parseInt(args[1]); 
            jahr = Integer.parseInt(args[2]); 
            wochentag0101startJahr = Integer.parseInt(args[3]); 
        } catch (NumberFormatException e) { 
           System.err.println("Argument muss Ganzzahl sein"); 
           System.exit(1); 
        } 
        monatOffSet[1] = 0;
        monatOffSet[2] = (monatOffSet[1]+31)%7;
        monatOffSet[3] = (monatOffSet[2]+28)%7;
        monatOffSet[4] = (monatOffSet[3]+31)%7;
        monatOffSet[5] = (monatOffSet[4]+30)%7;
        monatOffSet[6] = (monatOffSet[5]+31)%7;
        monatOffSet[7] = (monatOffSet[6]+30)%7;
        monatOffSet[8] = (monatOffSet[7]+31)%7;
        monatOffSet[9] = (monatOffSet[8]+31)%7;
        monatOffSet[10] = (monatOffSet[9]+30)%7;
        monatOffSet[11] = (monatOffSet[10]+31)%7; 
        monatOffSet[12] = (monatOffSet[11]+30)%7;
       jahresOffSet = (monatOffSet[12]+31)%7;
       if (monat>2) anzSchaltJahre=jahr/4-startJahr/4; 
       else anzSchaltJahre=(jahr-1)/4-startJahr/4;
       wochentag = (monatOffSet[monat] + tag - 1 + wochentag0101startJahr + (jahr-startJahr)*jahresOffSet + anzSchaltJahre )%7;
       System.out.println ("Der 1.1."+ startJahr+" war ein " + tagText[wochentag0101startJahr]);
       System.out.println ("Der "+ tag + "."+monat+"."+jahr+ " ist ein " + tagText[wochentag]); 
       // Optional: Datumsbestimmung mit Hilfe der Java Infrastruktur Calendar myCal = new GregorianCalendar(jahr,monat+1,tag); 
       System.out.println ("Gregorianischer Java Kalender:"); 
       System.out.println ("Der " + tag + "." + monat + "." + jahr+ " ist ein " + tagText[myCal.get(Calendar.DAY_OF_WEEK)]); 
     } 
   } 
}

3.4.8 Überlauf

Bei der Addition von Ganzzahlen gibt es keine Überlaufsprüfung.

package s1.block3;
public class Ueberlauf {
  public static void main(String[] args) {
       int a = 0;
       int b = 0;
       int result;
       if (args.length > 1 ) {
        try {
           a = Integer.parseInt(args[0]);
           b = Integer.parseInt(args[1]);
        } catch (NumberFormatException e) {
            System.err.println("Argument muss Ganzzahl sein");
            System.exit(1);
            }
        }
       System.out.println("Eingelesene Werte: " + a + ", " + b);
       result = a + b;
       if ((result < a) || (result < b))
           System.out.println("Überlauf!");
       else
           System.out.println(a + " + " + b + " = " + result);
    }
}

3.4.9 Schnitt zweier Linien

Eingabereihenfolge der Parameter ist: a₁, a₂, b ,c , d₁, d₂

package s1.block3;
public class GeradenSchnitt {

    public static void main(String[] args) {
        double a1 = 0.0;
        double a2 = 0.0;
        double b  = 0.0;
        double c  = 0.0;
        double d1 = 0.0;
        double d2 = 0.0;
        double tmp;
        if (args.length > 5) {
            try {
                a1 = Double.parseDouble(args[0]);
                a2 = Double.parseDouble(args[1]);
                b  = Double.parseDouble(args[2]);
                c  = Double.parseDouble(args[3]);
                d1 = Double.parseDouble(args[4]);
                d2 = Double.parseDouble(args[5]);
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Fließkommazahl sein");
                System.exit(1);
            }
        }
        System.out.println("Linie 1: (" + a1 + "," + b + ") bis ("
                + a2 + "," + b + ")");
        System.out.println("Linie 2: (" + c + "," + d1 + ") bis ("
                + c + "," + d2 + ")");
        // Schnittpunkt ist (c,b)
        // Sortieren von a1, a2 .
        if (a1 > a2) {
            tmp = a1; a1 = a2; a2 = tmp;}
        // Sortieren von d1, d2 .
        if (d1 > d2) {
            tmp = d1;
            d1 = d2;
            d2 = tmp;
        }
        System.out.println("Nach sortieren...");
        System.out.println("Linie 1: (" + a1 + "," + b + ") bis ("
                + a2 + "," + b + ")");
        System.out.println("Linie 2: (" + c + "," + d1 + ") bis ("
                + c + "," + d2 + ")");
        if ((a1 <= c) && (c <= a2) && (d1 <= b) && (b <= a2)) 
            System.out.println("Die beiden Strecken schneiden sich");
        else
          System.out.println("Die beiden Strecken schneiden sich nicht");
    }
}

Beispielläufe

java s1.block3.GeradenSchnitt 3.1 8.2 4.0 5.2 11.1 4.9

Linie 1: (3.1,4.0) bis (8.2,4.0)
Linie 2: (5.2,11.1) bis (5.2,4.9)
Nach sortieren...
Linie 1: (3.1,4.0) bis (8.2,4.0)
Linie 2: (5.2,4.9) bis (5.2,11.1)
Die beiden Strecken schneiden sich nicht

java block3.GeradenSchnitt 3.1 8.2 6.0 5.2 11.1 4.9

Linie 1: (3.1,6.0) bis (8.2,6.0)
Linie 2: (5.2,11.1) bis (5.2,4.9)
Nach sortieren...
Linie 1: (3.1,6.0) bis (8.2,6.0)
Linie 2: (5.2,4.9) bis (5.2,11.1)
Die beiden Strecken schneiden sich

3.4.10 Codevereinfachung

a)

a = a * b + 2 * c;

b)

y = ((x<0) && (y<0)) ?  y : -y;
x = ((y>=0) && (x>=0))? -x :  x;
a = x * y;;

3.4.11 Dreiecksbestimmung

package s1.block3;
public class Dreiecksvergleich {
public static void main(String[] args) {
    float x[] = new float[3];
    int j;
    if (args.length > 2 ) {
        try {
           float a;
           for (int i=0; i <3; i++) {
               x[i] = Float.parseFloat(args[i]);
               j=i; // Sortiere Eingabe in steigender Reihenfolge
               while (j>0)
                   if (x[j] < x[j-1]) {
                        a = x[j-1];
                        x[j-1] = x[j];
                        x[j]= a;
                        j--; }
                    else j=0;
                   }
               }
        catch (NumberFormatException e) {
            System.err.println("Argument muss Fließkommazahl sein");
            System.exit(1);
            }
        System.out.println("Eingebene Werte: " + x[0] + "; "
                                               + x[1] + "; "
                                               + x[2]);
        // Die folgenden Vergleiche verlassen sich darauf, dass das Feld
        // aufsteigend sortiert ist.
        if (x[0]+x[1]<=x[2])
            System.out.println("Dreieck ist ungültig");
        else if (x[0] == x[2])
            System.out.println("Dreieck ist gleichseitig (und gleichschenkelig)");
        else {
            if ((x[0] == x[1]) || (x[1] == x[2]))
                System.out.println("Dreieck ist gleichschenkelig (nicht gleichseitig)");
            if (x[0]*x[0]+x[1]*x[1]==x[2]*x[2])
                System.out.println("Dreieck ist rechtwinklig");
        }

    }
}
}

3.4.12 Sortieren

package s1.block3;
public class Sortieren {
public static void main(String[] args) {
       int a = 0;
       int b = 0;
       int c = 0;

       if (args.length > 2 ) {
        try {
           a = Integer.parseInt(args[0]);
           b = Integer.parseInt(args[1]);
           c = Integer.parseInt(args[2]);
        } catch (NumberFormatException e) {
            System.err.println("Argument muss Ganzzahl sein");
            System.exit(1);
            }
        }
       System.out.println("Eingelesene Werte: " + a + ", " + b + ", " + c);
       // alle Moeglichkeiten testen
       if ((a <= b) && (b<=c))
           System.out.println("Sortierte Werte: " + a + ", " + b + ", " + c);
       else if ( (a <= c) && (c <= b) )
           System.out.println("Sortierte Werte: " + a + ", " + c + ", " + b);
       else if ( (b <= a) && (a <= c) )
           System.out.println("Sortierte Werte: " + b + ", " + a + ", " + c);
        else if ( (b <= c) && (c <= a) )
           System.out.println("Sortierte Werte: " + b + ", " + c + ", " + a);
       else if ( (c <= a) && (a <= b) )
           System.out.println("Sortierte Werte: " + c + ", " + a + ", " + b);
       else if ( (c <= b) && (b <= a) )
           System.out.println("Sortierte Werte: " + c + ", " + b + ", " + a);
}
}

3.4.13 Plausibilitätsprüfung

package s1.block3;
public class Plausibilitaetspruefung {
    public static void main(String[] args) {
       int monatTage[] = {0, 31, 28, 31, 30, 31, 30,

int tag = 0; int monat = 0; int jahr = 0; if (args.length > 2 ) { try { tag = Integer.parseInt(args[0]); monat = Integer.parseInt(args[1]); jahr = Integer.parseInt(args[2]); } catch (NumberFormatException e) { System.err.println("Argument muss Ganzzahl sein"); System.exit(1); } System.out.println("Eingabe ist: " + tag + "." + monat + "." + jahr); if ((monat>0) && (monat < 13) && (tag>0)) if (monatTage[monat] >= tag) System.out.println("Datum ist gültig"); else if ((monat == 2) && (tag == 29) && (jahr%4 == 0) && ((jahr%100 !=0) || (jahr%400==0)) ) System.out.println("Datum ist gültig (Schalttag)"); else System.out.println("Datum ist ungültig"); } } }

3.4.14 Textverschlüsselung

Die vorgestellte Lösung ist eine naive, aber in diesem Fall korrekte Lösung da hier der implementierte Wert eines Zeichen im Vordergrund steht und nicht die Bedeutung des Zeichens.

Sie basiert auf der naiven Annahme, dass die den Zeichen (Buchstaben) zugeordnete Zahlenwerte der Sortierreihenfolge der Buchstaben entspricht. Diese Annahme ist für lateinische Zeichensätze meißten, mehr oder weniger richtig. Im Allgemeinen sollte man bei Programmentwicklung an die Internationalisierung denken. Hier gilt:

• Die lexikografische Ordnung (Sortierreihenfolge) ist länderabhängig und hängt von der Landeseinstellung (locale, Codepage) der eingestellten Umgebung ab.
  • Beispiel: Die Buchstaben ß, ö, Ö, ü etc haben in Unicode oder ISO 8852 Werte die nicht der deutschen lexikographischen Ordnung entsprechen. 
• Die von Java verwendete Unicodecodierung erlaubt die Codierung der meisten Zeichen der Welt gleichzeitig. Die Sortierreihenfolge ist hier nicht garantiert. 
  • Beispiel: Es gibt Zeichen die in der japanischen sowie in der chinesichen Sprache verwendet werden. Diese Zeichen sind identisch, haben jedoch eine unterschiedliche Bedeutung. Sie werden daher in China und Japan unterschieldlich sortiert.

 

package s1.block3;
public class Textverschluesselung {

    public static void main(String[] args) {

    String myText = "";

    int offSet = 0;

    char c;


    if (args.length > 1 ) {

        offSet = Integer.parseInt(args[0]);

        myText = args[1];

        }

    System.out.println("Eingabe: <<" + myText + ">>, Verschiebung: " + offSet);

    System.out.print("Ausgabe: <<");

    offSet = offSet%26; // Bei 26 Buchstaben kann der Versatz nur module 26 sein

    for (int i=0;i < myText.length(); i++) {

        // Lese jeden Wert der Zeichenkette aus und erhöhe den Zähler im Feld

        c = myText.charAt(i);

        if ((c>='A') && (c<='Z')) {

            c = (char)(c + offSet);

            if (c > 'Z') c-=(char)26; //Ziehe vom Ergebnis 26 ab da es jenseits von "Z" liegt.

            System.out.print(c);

            }

        }

        System.out.println(">>");

 }       

}

3.4.15 Verzweigung

package s1.block3;
public class Verzweigung {
public static void main(String[] args) {
    int x[] = new int[3];
    if (args.length > 2 ) {
        try {
           for (int i=0; i<3; i++)
               x[i]= Integer.parseInt(args[i]);
           }
        catch (NumberFormatException e) {
            System.err.println("Argument muss Ganzzahl sein");
            System.exit(1);
            }
    }
    System.out.println("Eingabe: " + x[0] +", " + x[1] + ", "+ x[2]);
    if ((x[0]==x[1]) && (x[1]==x[2]))
        System.out.println("Alle Werte sind gleich.");
    if ((x[0]==x[1]) || (x[1]==x[2]) || (x[0]==x[2]))
        System.out.println("Mindestens zwei Werte sind gleich.");
    if ((x[0]!=x[1]) && (x[1]!=x[2]) && (x[0]!=x[2]))
        System.out.println("Alle Werte sind verschieden.");
}
}

3.4.16 Häufigkeit von Zeichen

package s1.block3;
public class Haeufigkeitzeichen {
public static void main(String[] args) {
    String myText="";
    char c;
    int histogram[] = new int[Character.MAX_VALUE];

    if (args.length > 0 ) {
        myText=args[0];
        }
    System.out.println("Eingabe: <<" + myText + ">>");
    for (int i=0;i < myText.length(); i++) {
        // Lese jeden Wert der Zeichenkette aus und erhöhe den Zähler im Feld
        c = myText.charAt(i);
        histogram[c]++;
        }
    for (int i=0; i < Character.MAX_VALUE; i++)
        if (histogram[i]!= 0) {
            // Wichtig: unterdrücke alle leeren Einträge.
            // Das Feld hat ~65000 Zellen!
            System.out.print((char)i + ": ");
            for (int j=0; j< histogram[i]; j++)
                System.out.print('*');
            System.out.println();
        }
    }
}

 3.4.17 Weckzeiten implementieren

package s1.block3;
public class WeckzeitLoesung {
    int wzh = 0; // Weckzeit in Stunden
    int wzm = 0; // Weckzeit in Minuten
    int wzs = 0; // Weckzeit in Sekunden
    public void setzeWeckzeit(int hh, int mm, int ss) {
        if (korrekteWeckzeit(hh,mm,ss)) {
            wzh = hh;
            wzm = mm;
            wzs = ss;
        }
    }
    public boolean korrekteWeckzeit(int h, int m, int s) {
        boolean result;
        // benutzen die Variablen h,m,s um eine gültige Zeit zu bestimmen
        result = ((h>=0) && (h<=12 && (m>=0) && (m<=59)&& (s>=0) && (s<=59)));
        return result;
    }
    public boolean klingeln(int aktH, int aktM, int aktS) {
        boolean result;
        // benutzen die Variablen der aktuellen Zeit aktH (Stunde),
        // aktM (Minute), aktS (Sekunde) und die Weckzeit wzmh, wzm, wzs
        // um zu bestimmern ob der Wecker klingeln soll
        // Bestimme aktuelle Zeit in Sekunden
        int aktZeit  = aktH*3600 + aktM*60+aktS;
        // Bestimme Weckzeit in Sekunden
        int weckZeit = wzh *3600 + wzm *60+wzs;
        // Ist die aktuelle Zeit größer aber nicht größer als 10 Sekunden?
        result = (aktZeit-weckZeit>=0) && (aktZeit-weckZeit<10);
        return result;
    }

}

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zur Ablaufsteuerung und die Frage aus der Übung 3.3.1 Schleifenterminierung zu beantworten.

Feedback

Zur Umfrage

Methoden

Methoden sind ein wichtiges Strukturierungs- und Modularisierungsmittel.

Die Grundidee einer Methode ist wiederkehrende Aufgaben an einer Stelle zu implementieren und damit Redundanz zu vermeiden.

Ein zweiter wichtiger Aspekt ist die Senkung der Komplexität. Dem Benutzer muss die Implementierung einer Methode nicht bekannt sein um sie zu benutzen. 

Der in Java verwendete Begriff wird in anderen Programmiersprachen auch wie folgt bezeichnet:

• Prozedur
• Unterprogramm
• Funktion

In Java wurden alle diese Begriffe der Übersichtlichkeit wegen im Begriff der Methode zusammen gefasst. Methoden gehören immer zu Klassen. Man kann in Java keine alleinstehenden Funktionen, Prozeduren etc. implementieren

Implementierung einer Methode

Methoden bestehen aus

• einem Methodenkopf bestehend aus der Deklaration
  • Namen
  • Signatur: Aufrufargumente, Rückgabewert
• Methodenrumpf
  • der Rumpf wird von geschweiften Klammern eingeschlossen
  • der Rumpf enthält die Implementierung der Methode

Zum Aufruf der Methode ist nur die Kenntnis der Deklaration notwendig

Methodenkopf

Durch ihn wird die Methode deklariert. Das bedeutet, das hiermit eine Schnittstelle festgelegt wird die alle Informationen enthält die ein Benutzer der Methode kennen muss um sie zu benutzen.

public static int multiplizieren( int faktor1, int faktor2) { // Methodenrumpf }
   ^      ^    ^          ^           ^
   1.     2.   3.         4.          5.

1. Zugriffsspezifikation; die Sichtbarkeit der Methode

• public : Die Methode darf von überall aufgerufen werden
• private: Die Methode darf nur innerhalb der Klasse verwendet werden
• protected: Die Methode darf nur innerhalb der Klasse oder von abgeleiteten Klassen verwendet werden

2. Statische Methoden: Das Schlüsselwort static erlaubt den Aufruf der Methode auch wenn es für die Klasse keine Instanz gibt. Das Konzept von Klassen, Objekten und Instanzen wird erst später eingeführt.

3. Rückgabetyp: Der Typ des Ergebnis welche die Methode zurückliefert. Es gibt zwei Möglichkeiten:

• Die Methode liefert ein Ergebnis zurück. Der Typ ist ein beliebiger Typ
• Die Methode liefert kein Ergebnis zurück. Hierzu wird das Schlüsselwort void verwendet.

4. Methodenname: Hiermit werden Methoden in einer Klasse unterschieden.

5. Parameterliste: Sie enthält den Typ und den Namen aller übergebenen Werte innerhalb von runden Klammern.

• Die übergebenen Werte werden in der Methode als Variablen verwendet.
• Die übergebenen Parameter werden mit Komma getrennt.
• Sollen einer Methode keine Parameter mitgegeben werden, so wird ein leeres Klammernpaar ohne Werte verwendet. Bsp. ()
• Die übergebenen Parametervariablen sind immer Kopien der aufrufenden Variablen. Dies bedeutet, dass man in der Methode eine Parametervariable ändern kann, ohne dass die Variable im äusseren Block die den Wert übergeben hat geändert wird.

Methodenrumpf

In Methodenrümpfe kann man:

• Variablen und Konstanten deklarieren
• Anweisungen und Schleifen ausführen
• Methoden der gleichen oder anderer Klassen aufrufen
• die Übergabeparameter nutzen

In Methoden können die im Methodenkopf deklarierten Parameter direkt verwendet werden. Bei einem gegebenen Rückgabeparameter muss dieser mit dem Schlüsselwort return zurückgegeben werden. Mit final bezeichnete Parameter dürfen im Methodenrumpf nicht mehr verändert werden. Beispiel

public static String textverkettung (String text, final int anzahl) {
   String s="";
   for (int i=0; i<anzahl; i++) {
      s = s + text;
   }
   return s; }

Die Rückgabe von Werten mit Hilfe des Schlüsselwort return funktioniert nicht nur mit Variablen, man kann auch Ausdrücke zurückgeben die den passenden Typ haben.

Wie zum Beispiel in der Methode textRahmen() die noch ein Textrahmen von jeweils 3 Zeichen um das Ergebnis legt:

public static String textRahmen (String text) {
   return ">>>" + text + "<<<";
}

Bei einem gegebenen Rückgabeparameter kann der Rumpf an verschiedenen Stellen verlassen werden.

Siehe Beispiel:

package s1.block4;
public class Textverkettung {
    public static void main(String[] args) {
        System.out.println(textverkettung("Sonnenschein", 3));
        System.out.println(textverkettung("Sonnenschein", 0));
    }
    public static String textverkettung(String text, final int anzahl) {
        String s="";
        if (anzahl < 1) {
            return "Gewählte Anzahl ist zu klein";
        } else {
            for (int i = 0; i < anzahl; i++) {
                s = s + text;
            }
            return s;
        }
    }   
}

Der Typ des Rückgabeparameter muss vom Typ her zum deklarierten Rückgabetyp der Methode passen.

Die Methode kann auch ohne einen Rückgabewert definiert werden. Im folgenden Beispiel wird sie den Text direkt selbst ausdrucken:

public class TextverkettungDrucken {
    public static void main(String[] args) {
        textverkettungDrucken("Sonnenschein", 3);
        textverkettungDrucken("Sonnenschein", 0);
    }
    public static void textverkettungDrucken(String text, final int anzahl) {
        String s="";
        if (anzahl >0)
            for (int i = 0; i < anzahl; i++)
                s = s + text;
        System.out.println("Ergebnis: " + s);
    }   
}

Aufruf von Methoden

Direkter Aufruf: Aufruf nur durch Methodenname und aktuelle Parameter

• Die aufgerufene Methode gehört zur gleichen Klasse oder einer Oberklasse (Fall 1 im Beispiel)
• Die Methode ist nicht statisch und wird auf das gleiche Objekt wie die umgebende Methode angewendet (Fall 1 im Beispiel)
• Die Methode ist statisch und kann ohne die Existenz eines Objekts verwendet werden (Fall 2 im Beispiel)

Aufruf mit vorgestelltem Objekt oder Klassenname (statische Methode)

• Die Methode soll für ein bestimmtes Objekt aufgerufen werden. Sie ist nicht statisch (Fall 3 im Beispiel)
• Die Methode ist statisch und gehört zu einer anderen Klasse. (Fall 4 im Beispiel)

Beispiel:

public class Flugzeug {
    String kennzeichen;
    int leerGewicht;
    int besatzung; 
    public void drucken () {
        System.out.println(kennzeichen + " , Crew: " + besatzung + ", "+leerGewicht + "kg");
    }
    public static void main(String[] args) {
        Flugzeug f = new Flugzeug();
        f.drucken(); 
        f.kennzeichenAusgeben(); // Fall 3: Aufruf einer Methode für ein Objekt
        eigenschaft(); // Fall 2: Aufruf einer statischen Methode der gleichen Klasse
        Flughafen.eigenschaft(); // Fall 4: Aufruf einer statischen Methoden die zu einer anderen Klasse gehören kann
        double pi = Math.sqrt(2.0); // Fall 4: Aufruf einer statischen Methoden die zu einer anderen Klasse gehört
    }
    public void kennzeichenAusgeben() {
        drucken(); // Fall 1: Nicht statischer Methodenaufruf einer Methode der gleichen Klasse
    }
    public static void eigenschaft() {
        System.out.println("kann fliegen");
    }
}
 
public class Flughafen {
    public static void eigenschaft() {
        System.out.println("ist laut und schafft Arbeitsplätze");
    }
}

Anwenden von Methoden

Methoden mit Eingabeparametern können bei jedem Aufruf mit anderen Werten arbeiten. Wichtig ist hierbei zu wissen, dass es bei mehreren Parameter auf die Reihenfolge der Parameter ankommt. Sie müssen beim Aufruf, in ihrer Reihenfolge, zur Deklaration passen. Der Übersetzer wird Parameter mit nicht passenden Typen als Fehler anzeigen. Sind die Typen mehrerer Parameter gleich oder kompatibel, muss der Entwickler selbst auf die Reihenfolge achten!

Die oben gezeigte Methode textverkettung kann bei jedem Aufruf einen anderen Text verketten. Man kann die Methode wie folgt aufrufen.

package s1.block4;
public class Textverkettung {
    public static void main(String[] args) {
        String result;
        String text1 = "Mustertext";
        result= textverkettung("PingPong", 2);
        System.out.println("Ergebnis: " + result);
        result= textverkettung(text1, 3); 
        System.out.println("Ergebnis: " + result);
    }
    public static String textverkettung(String text, final int anzahl) {
        String s;
        s = text;
        if (anzahl < 1) {
            return "Gewählte Anzahl ist zu klein";
        } else {
            for (int i = 1; i < anzahl; i++) {
                s = s + text;
            }
            return s;
        }
    } 
}

Das oben gezeigte Codestück sollte auf der Konsole das folgende Ergebnis ausdrucken:

Ergebnis: PingPongPingPong
Ergebnis: MustertextMustertextMustertext

Der Aufruf von Methoden ohne Rückgabeparameter ist noch einfacher. Im folgenden Beispiel wird wie Methode textverketttungDrucken() aufgerufen:

... 
String result;
String text1 = "Mustertext";
textverkettungDrucken("PingPong", 2); textverkettungDrucken(text1, 3);
...

Man kann die Methode ohne eine Ergebnisvariable mit einer vereinfachten Syntax aufrufen. Ruft man Methoden mit Ergebnisvariablen in der oben gezeigten Form, ohne Zuweisung des Ergebnis zu einer Variablen, auf, so geht das Ergebnis verloren. Die Implementierung wird jedoch übersetzt und abgearbeitet. Es tritt keine Fehlermeldung auf.

Verschachtelte Methodenaufrufe und Methodenaufrufe innerhalb von Methoden

Methodenaufrufe mit Ergebnissen können überall benutzt werden wo in einem Ausdruck oder einer Zuweisung der entsprechende Typ gelesen werden soll.

Im folgenden Beispiel wird die Methode textverkettung() verschachtelt mit der Methode zur Rahmenerzeugung textRahmen() aufgerufen. Der geschachtelte Aufruf erfolgt in der Methode testTextRahmen():

public static String textverkettung(String text, final int anzahl) {
   String s="";
   if (anzahl < 1) {
      return "Gewählte Anzahl ist zu klein";
   } else {
      for (int i = 0; i < anzahl; i++) {
         s = s + text;
      }
      return s;
   }
} 
  
public static String textRahmen(String s) {
   return "<< " + s + " >>";
}    
  
public static void testTextRahmen() {
   String s = "Inhalt";
   String result = textRahmen(textverkettung(s,2));
   System.out.println(result);
}

Ein Aufruf der Methode testTextRahmen() ergibt die Ausgabe:

<< InhaltInhalt >>

Methoden können nicht nur wie eben beschrieben geschachtelt werden. Man kann innerhalb eines Methodenrumpfes auch eine andere Methode aufrufen. Dies geschah oben in der Methode testTextRahmen.

Überladen von Methoden

Java erkennt eine Methode einer Klasse an den folgenden Merkmalen:

• Name der Methode
• Reihenfolge und Typ der Eingabeparameter

Man kann also den gleichen Namen einer Methode wiederverwenden solange sich die Typen der Eingabeparameter unterscheiden. Hiermit kann man Methoden implementieren, die "ähnliches" implementieren. Die "Ähnlichkeit" kann man mit dem gleichen Namen dokumentieren, die Parameterlisten müssen sich aber unterscheiden.

Überladene Methoden sind nützlich wenn man den prinzipiell gleichen Algorithmus für unterschiedliche Datentypen oder unterschiedliche Parameterkombinationen ausführen will.

Wichtig: Der Rückgabeparameter einer Methode wird in Java nicht bei der Unterscheidung überladener Methoden beachtet!

Methoden mit Rückgabeparameter können auch ohne Zuweisung ihres Rückgabewertes an eine Variable aufgerufen werden.
In diesem Fall kann der Übersetzer nicht feststellen welche Methode benutzt werden soll, wenn es mehrere Methoden gibt die sich nur im Rückgabewert unterscheiden.

Ein typisches Beispiel ist das drucken von unterschiedlichen Werten. Anbei vier überladene Methoden einer Klasse;

public class drucker {

public void drucken(String s) {
   System.out.println("String:"+ s);
   }

public void drucken(int i) {
   System.out.println("Zahl: " + i);
   }

public void drucken(String s, int i) {
   System.out.println("String/Zahl" + s + "/" + i);
   }

public void drucken(int i, String s) {
   System.out.println("Anders: String/Zahl" + s + "/" + i);
   }
}

Die folgenden zwei Methoden sind keine erlaubten (zusätzlichen) überladene Methoden:

public void drucken(String z, int a) {
   System.out.println("String/Zahl" + z + "/" + a);
   }
public int drucken(String s, int i) {
   System.out.println("String/Zahl" + s + "/" + i);
   return 2*i;
   }

Diese erste Methode besitzt die gleichen Formalparametertypen wie die dritte Methode. Die Namen der Parameter sind nicht relevant.

Die zweite Methode hat zwar einen anderen Rückgabeparameter, jedoch die gleichen Formalparameter wie die dritte Methode. Java ignoriert die Rückgabeparameter und verweigert das Übersetzen der Methode.

Entwurfsprinzipien für Methoden

• Methoden sollten eine klar definierte Teilaufgabe lösen
• Wird eine Methode groß und unübersichtlich sollte man sie in sinnvolle Teilmethoden zerlegen
• Gute Methoden werden an verschiedenen Stellen wieder verwendet
• Methoden sollten möglichst gekapselt sein
  • Die Übergabeparameterlisten sollten so kurz wie möglich sein
  • Methoden sollten möglichst wenig globale Variablen verwenden. Dem Verwender ist das nicht unbedingt bewusst!
  • Ergebnisse sollten wenn möglich als Rückgabewert ausgegeben werden. Das Ändern von globalen Variablen sollte man wenn möglich vermeiden.
• Methoden und ihre Funktionen und Seiteneffekte sollten immer gut dokumentiert sein. Ein Verhältnis von Kommentar zu Quellcode von 1:1 ist durchaus vernünftig!

Programmstrukturierung mit Hilfe von Methoden

Methoden sind einer der Bausteine die die Entwicklung komplexer Anwendungen erlauben. Sie geben Strukturierungsmöglichkeiten um die Gesamtkomplexität von Anwendungen zu reduzieren:

• Abstraktion: Verwender einer Methode müssen nicht wissen wie sie intern funktioniert. Sie können sich auf die Beschreibung und die korrekte Ausführung der Methode verlassen
• Codereduktion: Das wieder verwenden von Methoden erlaubt es mit deutlich weniger Programmcode auszukommen. Die Kosten für die Pflege der Quellen und die Fehlerhäufigkeit der Anwendung sinkt. Bei replizierten Codestücken müssten alle Codestücke gefunden und individuell angepasst werden.
• Strukturierung und Hierarchisierung: Das explizite Zusammenfassen von Codestücken die eine bestimmte Aufgabe lösen erleichtert Verständnis und Pflege der Anwendung. Methoden erlauben durch Aufruf von anderen Methoden die Strukturierung in vielschichtige Hierarchien.
• Teile und Herrsche: Das abstrahieren und Verbergen der Implementierung (Information hiding) erlaubt die Zusammenarbeit in Teams und die Entwicklung komplexer Anwendungen. Das Konzept der Schnittstelle ist ein "Vertrag" zwischen Anbieter und Konsument bei dem nur die semantische Wirkung der Methode verstanden sein muss.

Methoden sind nur das erste von mehreren Strukurierungshilfsmittel der Sprache Java die im Rahmen dieser Vorlesung vorgestellt werden. Klassen, Pakete, Vererbung und globale vs. lokale Variablen sind andere Möglichkeiten.

Variablen sind immer nur in einem gewissen Umfang sichtbar. Sichtbar bedeutet hier benutzbar, gültig.

Die Sichbarkeit von Variablen hängt vom Kontext, dem Block ab in dem sie deklariert worden sind.

Blöcke können sein:

• Programmcode zwischen geschweiften Klammern
• Programmcode innerhalb einer Schleife, Ausführungsektionen (z.Bsp. if Bedingung)
• Bereich einer Methode
• Bereich einer Klasse
• Global

Es gibt hier abhängig von der Sichtbarkeit verschiedene Bereiche

• Blocklokale Variablen
• Methodenlokale Variablen
• Klassenlokale Variablen

Die Gültigkeit von Variablen steht im Zusammenhang mit dem Stapel (Stackkonzept) des Laufzeitsystems.

Das Laufzeitsystem legt beim Beginn eines jeden Blocks die neuen Variablen hinter den Variablen des gerade aktuellen Blocks an.

Nach dem Verlassen eines Blocks wird der Zeiger auf das obere Ende des Stapels wieder auf die Variablen des letzen Blocks zurückgesetzt.

Der Speicher der Variablen des verlassenen Blocks ist hierdurch zur Wiederverwendung wieder freigegeben worden.

Das Verfahren eines Stapels entspricht der üblichen Handhabung von Tellern im Schrank.

• Neue Teller (hier Blöcke) werden immer oben an den Stapel angefügt
• Nicht mehr benötigte Teller werden nur von oben entfernt

Das Stackkonzept des Laufzeitssystems:

Konstruktoren sind spezielle Methoden mit denen Objekte einer Klasse initialisert werden. Das Java Laufzeitsystem legt automatisch einen Standardkonstruktor an wenn kein klassenspezifischer Konstruktor implementiert wird.

Konstruktoren haben die folgende Eigenschaften

• Der Konstruktor hat immer den Namen der Klasse als Methodenname
• Konstruktoren haben keine Rückgabewerte (auch kein Schlüsselwort void!)
• Die Auswahl des passenden Konstruktur erfolgt über die Typen der Eingabeparameter
• Konstruktoren können auch parameterlos sein
• Besitzt eine Klasse einen Konstruktor, so muss einer der Konstruktoren benutzt werden. Man kann die Klasse dann nicht mehr mit dem trivialen (System-)Konstruktor initialisieren.

Beispiel:

package s1.block4;
public class Employee {
    public String surName;
    public String firstName;
    public int employeeId;
    public double salary;
    /**
     * Der Konstruktor initialisert die Attribute für Employee
     * @param ln Nachname
     * @param fn Vorname
     * @param id Mitarbeiternummer
     * @param sal Gehalt. Gehalt wird im Konstruktor auf 100000 begrenzt
     */
    public Employee (String ln, String fn, int id, double sal) {
        surName = ln;
        firstName = fn;
        employeeId = id;
        if (sal > 100000) salary = 100000;
        else salary= sal;
     }
    public void printRecord() {
        System.out.print(employeeId + ", " + surName + " " + firstName);
        System.out.println(",Salary :" + salary);
    }
    /**
     * Teste die Konstruktoren
     * @param args werden nicht benutzt
     */
    public static void main(String[] args) {
        Employee ceo = new Employee("Doe","John",1,80000.0);
        Employee cio = new Employee("Doe","Jane",1,70000.0);
        ceo.printRecord();
        cio.printRecord();
    }
}

In den vorangegangen Abschnitten wurden verschiedene Schleifenkonstrukte vorgestellt mit denen man Codestrecken wiederholt durch laufen kann. Dieses Verfahren nennt man Iteration.

Methoden können aber nicht nur andere Methoden aufrufen, sie können auch sich selbst aufrufen. Dieses Verfahren nennt man Rekursion. Beide Verfahren sind von der Theorie her gleichwertig. Sie können wechselseitig eingesetzt werden. Im folgenden Beispiel wird die Multiplikation durch fortgesetzte Addition nach dem folgenden Prinzip iterativ und rekursiv gelöst.

Rekursive Algorithmen wenden das "Teile und Herrsche" Prinzip an indem Sie ein gegebenes Problem zerlegen in

• ein trivial lösbares Problem
• ein Restproblem welches gleich dem ursprünglichen Problem strukturiert ist (und einfacher ist!)

fib(0) = 0 (ein trivial lösbares Problem)
fib(1) = 1 (ein trivial lösbares Problem)
für alle n > 1
fib(n) = fib(n-1) + fib(n-2) (das einfachere Restproblem)

Beispielprogramm:

package s1.block4;
public class Fibonacci {    

   public static long fib(int f) {
      long ergebnis=0;
      switch (f) {
         case 0: { ergebnis = 0;break;} // Triviales Problem. Keine Rekursion
         case 1: { ergebnis = 1;break;} // Triviales Problem. Keine Rekursion
         default: { // Die Rekursion
            ergebnis = fib(f - 1) + fib(f - 2);
            break;
         } // Ende default
       } // Ende switch
      return ergebnis;
   } // Ende Methode

   public static void main(String[] args) {
      int a = 10; //Anzahl der berechneten Fibonaccizahlen
      System.out.println("Fibonacciberechnung von fib(0) bis fib(" + a + ")");
      for (int i=0; i<=a; i++)
         System.out.println("fib("+i+")= " + fib(i));
  } // Ende main()
} // Ende Klasse

Anmerkung: Diese naive Implementierung ist sehr ineffizient. Das Programm berechnet zu jeder Fibonaccizahl die beiden vorhergehenden Zahlen neu. Der Aufwand zur Berechnung der Fibonaccizahlen steigt daher exponentiell mit der Potenz 2. Dies macht den hier gewähltenAlhorithmus, zur Berechnung für größerer Fibonaccizahlen, ungeeignet.

Beispiel: Quersummenberechnung

Die Methode berechne() berechnet eine Quersumme iterativ mit Hilfe einer while Schleife. Die Methode berechneRekursiv() berechnet das Ergebnis rekursiv (mit Selbstaufruf).

package s1.block4;
public class Quersumme {
    /**
     * Hauptprgramm zum Berechnen der Quersumme
     * @param args wird nicht benutzt
     */
    public static void main (String[] args) {
        long eing = 12345678;
        long ausg = berechne(eing);
        System.out.println ("Ausgabe:" + ausg + "; Eing: " +eing);
        System.out.println("Berechne rekursiv");
        ausg = berechneRekursiv(eing);
        System.out.println ("Ausgabe:" + ausg + "; Eing: " +eing);
    }
    /**
     * Iterative Berechnung einer Quersumme mit einer while Schleife
     * @param eing
     * @return ausgabe 
     */
    public static long berechne(long eing){
        long a = 0;
        while (eing>0) {  //Abbruch bei Null
            a += eing%10; //Aufaddieren der letzen Stelle
            eing /= 10;   //Teilen der Zahl durch 10
        }
        return a;
    }
    /**
     * Rekursive Berechnung einer Quersumme
     * @param eing
     * @return ausgabe 
     */
    public static long berechneRekursiv (long eing){
        long a = 0;
        if (eing>0)  a = (eing%10)+berechneRekursiv(eing/10);
        else         a = 0;  // Triviale Loesung. Nicht rekursiv.
        return a;
    }
}

Implementierung der Türme von Hanoi in Java

package s1.block4;
public class Hanoi {
    public static void bewegeScheiben(int scheiben, 
            String von,
            String nach, 
            String hilfsstab){
        if (scheiben >0) {
            bewegeScheiben(scheiben-1, von, hilfsstab,nach);
            System.out.println(scheiben + ".te Scheibe von " + von + " nach " + nach );
            bewegeScheiben(scheiben-1, hilfsstab, nach, von);
            }
        }

    public static void main(String[] args) {
     bewegeScheiben(3, "links", "mitte", "rechts");
    }

}

Ablauf des Programmes

1.te Scheibe von links nach mitte
2.te Scheibe von links nach rechts
1.te Scheibe von mitte nach rechts
3.te Scheibe von links nach mitte
1.te Scheibe von rechts nach links
2.te Scheibe von rechts nach mitte
1.te Scheibe von links nach mitte

Was geschieht wenn man die Operationen von verschiedenen Typen mischt?

package s1.block4;
public class Rechenarten {
    /* Implementierung */

     public static void main(String[] args) {
        double ergebnis1;
        int ergebnis2;
  
        ergebnis1 = add(5.0, 4.0);
        System.out.println(" 5.0 + 4.0 = " + ergebnis1);
        ergebnis1 = div(9.0, 4.0);
        System.out.println(" 9.0 / 4.0 = " + ergebnis1);
        ergebnis1 = sub(9.0, 4.0);
        System.out.println(" 9.0 - 4.0 = " + ergebnis1);
        ergebnis1 = add(div(9.0, 4.0), 3.0);
        System.out.println(" 9.0 / 4.0 + 3.0 = " + ergebnis1);
 
        ergebnis2 = add(5, 4);
        System.out.println(" 5 + 4 = " + add(5, 4));
        ergebnis2 = div(9, 4);
        System.out.println(" 9 / 4 = " + div(9, 4));
        ergebnis2 = sub(9, 4);
        System.out.println(" 9 - 4 = " + sub(9, 4));
        ergebnis2 = add(div(9, 4), 3);
        System.out.println(" 9 / 4 + 3 = " + add(div(9, 4), 3));
    } 
}

4.5.2 Übung: Flächenberechnung von Dreiecken

Implementieren Sie eine Klasse mit Namen Dreieck. Die Klasse soll Methoden zu Flächenberechnung enthalten. Implementieren sie einzelne Methoden zur Berechnung der folgenden Dreieckstypen. Passen Sie die Anzahl der Parameter an die Gegebenheiten an

• beliebiges Dreieck: 3 Seiten gegeben
• gleichschenkliges Dreieck; 2 Seiten gegeben
• gleichseitiges Dreieck: 1 Seite gegeben
• rechtwinkliges Dreieck:
  • 2 Katheten gegeben
  • 1 Hypotenuse, 1 Kathete gegeben

Nutzen Sie wenn möglich schon implementierte Methoden zur Berechnung der Fläche. Dies bedeutet, dass man ein gleichschenkliges Dreieck für das man nur zwei Eingabeparameter benötigt mit Hilfe der Methode zur Berechnung eines allgemeinen Dreiecks berechnen kann. Das gleichschenklige Dreieck ist ein Spezialfall des allgemeinen Dreiecks.

Tipp: 

1. Nutzen Sie den Satz von Heron
2. Benutzen Sie die Systemklasse Math für das Ziehen der benötigten Wurzel. Dies geschieht mit Math.sqrt().
   • Hinweis. Durch das vorranstellen von Math. benötigen Sie keine Importdeklaration für das Math-Paket.

4.5.3 Übung: Rekursive Addition und Multiplikation

1. Übersetzen Sie das gegebene Beispielprogramm und testen Sie die Funktionsweise

• Vereinfachung: Die Anwendung muss nur für nicht negative Zahlen funktionieren

package s1.block4;
public class Arithmetik {    

/**
* Liest von der Kommazeile zwei Ganzzahlen ein und multipliziert sie
* @param args
*/
public static void main(String[] args) {
int a=5;
int b=8;
int c=0;

if (args.length > 1) {
try {
a = Integer.parseInt(args[0]);
b = Integer.parseInt(args[0]);
} catch (NumberFormatException e) {
System.err.println("Argument muss Ganzzahl sein");
System.exit(1);
}
}
// Kontrolle der Eingaben
System.out.println("Eingabe a: " + a +"; b: " +b);

c = a *b;

// Ergebnisprüfung
System.out.print("Ergebnis c: " + c);
if (c == a*b)
System.out.println(" (korrekt)");
else
System.out.println(" (falsch. Richtig ist " + (a*b)+")");
}
}

2. Benutzen einer for-Schleife mit Addition

Ersetzen Sie die Anweisung:

c = a*b;

durch eine for Schleife in der nur noch addiert wird

3. Einführen einer Methode mult()

Ersetzen Sie die Berechnung des Ergebnisses mit einer for-Schleife durch einen Methodenaufruf:

c = mult(a,b);

Implementieren Sie eine dazu passende Methode mult() die die Multplikation mit der for-Schleife durchführt

4. Eine rekursive Methode mult()

Ersetzen Sie die for-Schleife in der Methode mult() durch einen rekursiven Aufruf.

Tipps:

• Sie benötigen eine Bedingung für das Rekursionsende
• Definition des zu selbst zu lösenden Teilproblems
• Delegation des Restproblems durch rekursiven Aufrufs

5. Ersetzen der Addition durch eine rekursive Additionsmethode add() die nur die Inkrementfunktion benutzt

In gesamten Anwendung sollte jetzt kein * oder + Operator mehr vorkommen...

 4.5.4 Fragen

Typische klausurrelevante Fragen:

• Aus welchen 2 Teilen besteht eine Methode?
• Aus welchen Teilen besteht ein Methodenkopf?
• Welches Schlüsselwort wird verwendet wenn kein Rückgabewert existiert?
• Wie sieht die Parameterliste des Methodenkopfes aus falls es keine Eingabeparameter gibt?
• Nenne ein Beispiel für eine überladene Methode.

4.5.5 Beispiel aus der Vorlesung

Diese Klassen liegen im Paket s1.airlineSolution.block4. 

Klasse Flugzeug

package s1.airlineSolution.block4;

/**
*
* @author stsch
*/
public class Flugzeug {
final static double durchschnittsgewicht = 75;
String kennzeichen;
int passagiere;
private double maximalesGewicht;
double minimalGewicht;

Flugzeug(double minGewicht, double maxGewicht) {
System.out.println("Hallo, ich baue ein Flugzeug");
maximalesGewicht = maxGewicht;
// Kontrolle des Minimalgewichts
if ((minGewicht > 0) && (minGewicht <= maximalesGewicht)) {
minimalGewicht = minGewicht;
} else {
minimalGewicht = 5;
}
// Eine schwachsinnige Initialisierung
passagiere = 1;
}

public double maxG() {
return maximalesGewicht;
}

public void einsteigen() {
passagiere++;
}

public void einsteigen(int einsteiger) {
passagiere = passagiere + einsteiger;
}

double gewicht() {
double ergebnis;
ergebnis = minGewicht + passagiere * durchschnittsgewicht;
return ergebnis;
}

}

Klasse Flughafen

package s1.airlineSolution.block4;

/**
*
* @author stsch
*/
public class Flughafen {

String name;
Flugzeug gate1;
Flugzeug gate2;
Flugzeug gate3;
Flugzeug gate4;
Flugzeug gate5;
Flugzeug gate6;

public static void main(String[] args) {
Flughafen pb;
pb = new Flughafen();
pb.name = "Paderborn";

Flugzeug lh1 = new Flugzeug(222.0D,100000D);
lh1.kennzeichen = "D-A123";
lh1.passagiere = 23;

Flugzeug lh2 = new Flugzeug(3333.0D,100000D);
lh2.kennzeichen = "D-A456";
lh2.passagiere = 11;

pb.gate1 = lh1;
lh1.einsteigen();
lh1.einsteigen();
double meinGewicht = lh1.gewicht();
lh1.gewicht();

pb.gate2 = lh2;
lh2.einsteigen(88);

System.out.println("Mein Flughafen: " + pb.name);
System.out.println("Gate 1: " + pb.gate1.kennzeichen +
", Passagiere: " + pb.gate1.passagiere +
", akt. Gew.: " + pb.gate1.gewicht());
System.out.println("Gate 2: " + pb.gate2.kennzeichen +
", Passagiere: " + pb.gate2.passagiere);
if (pb.gate3 == null) {
System.out.println("Gate 3: leer");
} else {
System.out.println("Gate 3: " + pb.gate3.kennzeichen);
}
}
}
 

4.6.1 Arithmetikmethoden

public class Rechenarten {

    public static double add(double a, double b) {
        return (a + b);
    }

    public static double sub(double a, double b) {
        return (a - b);
    }

    public static double mul(double a, double b) {
        return (a * b);
    }

    public static double div(double a, double b) {
        return (a / b);
    }

    public static int add(int a, int b) {
        return (a + b);
    }

    public static int sub(int a, int b) {
        return (a - b);
    }

    public static int mul(int a, int b) {
        return (a * b);
    }

    public static int div(int a, int b) {
        return (a / b);

    }

    public static void main(String[] args) {
        double ergebnis1;
        int ergebnis2;
  
        ergebnis1 = add(5.0, 4.0);
        System.out.println(" 5.0 + 4.0 = " + ergebnis1);
        ergebnis1 = div(9.0, 4.0);
        System.out.println(" 9.0 / 4.0 = " + ergebnis1);
        ergebnis1 = sub(9.0, 4.0);
        System.out.println(" 9.0 - 4.0 = " + ergebnis1);
        ergebnis1 = add(div(9.0, 4.0), 3.0);
        System.out.println(" 9.0 / 4.0 + 3.0 = " + ergebnis1);
 
        ergebnis2 = add(5, 4);
        System.out.println(" 5 + 4 = " + add(5, 4));
        ergebnis2 = div(9, 4);
        System.out.println(" 9 / 4 = " + div(9, 4));
        ergebnis2 = sub(9, 4);
        System.out.println(" 9 - 4 = " + sub(9, 4));
        ergebnis2 = add(div(9, 4), 3);
        System.out.println(" 9 / 4 + 3 = " + add(div(9, 4), 3));
    } 
}

4.6.2 Flächenberechnung vom Dreieck

public class Dreiecksflaeche {  
    /**
     * Berechnung der Fläche eines Deiecks mit drei beliebigen Seiten.
     * Es wird nicht geprüft ob die Seitenlängen ein korrektes Dreieck ergeben
     * @param a Länge Seite 1
     * @param b Länge Seite 2
     * @param c Länge Seite 3
     * @return Fläche des Dreiecks
     */
    public static double flaeche(double a, double b, double c) {
        double s = (a+b+c)/2;
        return Math.sqrt(s*(s-a)*(s-b)*(s-c));
    }
    /**
     * Berechnung der Fläche eines gleichschenkligen Deiecks.
     * Es wird nicht geprüft ob die Seitenlängen ein korrektes Dreieck ergeben
     * @param gleicherSchenkel die Länge der beiden gleichlangen Seiten
     * @param basis Länge der Basis
     * @return 
     */
    public static double flaeche(double gleicherSchenkel, double basis) {
    return flaeche(gleicherSchenkel,gleicherSchenkel,basis);
    }
    /**
     * Berechnung der Fläche eines gleichschenkligen Deiecks
     * @param gleicheSeite Länge der Seite
     * @return 
     */
    public static double flaeche(double gleicheSeite) {
    return flaeche(gleicheSeite,gleicheSeite);
    }
    /**
     * Berechnung der Fläche eines rechtwinkligen Dreiecks mit zwei Katheden
     * @param k1 Länge erste Kathede
     * @param k2 Länge zweite Kathede
     * @return Fläche
     */
    public static double flaecheKathedenDreieckeck(double k1, double k2){
    return flaeche(Math.sqrt(k1*k1+k2*k2),k1,k2);
    }
    /**
     * Berechnung der Fläche eines rechtwinkligen Dreiecks mit einer
     * Hypotenuse und einer Kathede
     * @param h Länge Hypothenuse
     * @param k Länge Kathede
     * @return Fläche
     */
    public static double flaecheKathedeHypothenuseDreieck(double h, double k){
    return flaecheKathedenDreieckeck(k,Math.sqrt(h*h-k*k));
    }
    /**
      * Hauptprogrsam zum Testen
      * @param args keine Eingabeparameter
      */
    public static void main(String[] args) {
        double aa = 3.0d;
        System.out.println(flaeche(aa,4D,5D));
        System.out.println(flaeche(5D,4D));
        System.out.println(flaeche(3D));
        System.out.println(flaecheKathedenDreieckeck(3D,4D));
        System.out.println(flaecheKathedeHypothenuseDreieck(5D,4D));
    }
}

4.6.3 Rekursive Addition und Multiplikation

Multiplikation mit Hilfe einer addierenden for-Schleife:

public class Arithmetik1 {

    public static void main(String[] args) {
        int a=5;
        int b=8;
        int c=0;

        if (args.length > 1) {
            try {
                a = Integer.parseInt(args[0]);
                b = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
            }
        }
        System.out.println("Eingabe a: " + a +"; b: " +b);

for (int i=0; i<b; i++) {
            c += a;
        }


        System.out.print("Ergebnis c: " + c); 
        if (c == a*b)
            System.out.println(" (korrekt)");
        else
            System.out.println(" (falsch. Richtig ist " + (a*b)+")");

    }

}

Delegation an eine Methode

public class Arithmetik2 {

    public static void main(String[] args) {
        int a=5;
        int b=8;
        int c=0;

        if (args.length > 1) {
            try {
                a = Integer.parseInt(args[0]);
                b = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
            }
        }
        System.out.println("Eingabe a: " + a +"; b: " +b);

c = mult(a,b);

        System.out.print("Ergebnis c: " + c); 
        if (c == a*b)
            System.out.println(" (korrekt)");
        else
            System.out.println(" (falsch. Richtig ist " + (a*b)+")");

    }

public static int mult(int x, int y) {
        int ergebnis=0;
        for (int i=0; i<x; i++) {
            ergebnis += y;
        }
        return ergebnis;
    }  
}

Eine rekursive Multiplikation

public class Arithmetik3 {

    public static void main(String[] args) {
        int a=5;
        int b=8;
        int c=0;

        if (args.length > 1) {
            try {
                a = Integer.parseInt(args[0]);
                b = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
            }
        }
        System.out.println("Eingabe a: " + a +"; b: " +b);

        c = mult(a,b);


        System.out.print("Ergebnis c: " + c); 
        if (c == a*b)
            System.out.println(" (korrekt)");
        else
            System.out.println(" (falsch. Richtig ist " + (a*b)+")");

    }

    /**
     * Diese Methode multipliziert zwei Zahlen rekursiv.
     * Sie funktioniert nur für x Werte die nicht negativ sind!
     * @param x darf nicht negativ sein
     * @param y 
     * @return Ergebnis einer Multiplikation
     */
public static int mult(int x, int y) {
        int ergebnis=0;
        if (x==0) 
            ergebnis=0;
        else 
            ergebnis=mult(y,(x-1))+y;

        return ergebnis;
    } 
}

Multiplikation mit rekursiver Addition und Multiplikation

public class Arithmetik4 {

    public static void main(String[] args) {
        int a=5;
        int b=8;
        int c=0;

        if (args.length > 1) {
            try {
                a = Integer.parseInt(args[0]);
                b = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Argument muss Ganzzahl sein");
                System.exit(1);
            }
        }
        System.out.println("Eingabe a: " + a +"; b: " +b);

        c = mult(a,b);


        System.out.print("Ergebnis c: " + c); 
        if (c == a*b)
            System.out.println(" (korrekt)");
        else
            System.out.println(" (falsch. Richtig ist " + (a*b)+")");

    }

    /**
     * Diese Methode multipliziert zwei Zahlen rekursiiv.
     * Sie funktioniert nur für x Werte die nicht negativ sind!
     * @param x darf nicht negativ sein
     * @param y 
     * @return Ergebnis einer Multiplikation
     */

    public static int mult(int x, int y) {
        int ergebnis=0;
        if (x==0) 
            ergebnis=0;
        else 
            ergebnis=add(mult(y,(x-1)),y);

        return ergebnis;
    }

    /**
     * Diese Methode addiert zwei Zahlen rekursiv.
     * Sie funktioniert nur für x Werte die nicht negativ sind!
     * @param x darf nicht negativ sein
     * @param y 
     * @return Ergebnis einer Multiplikation
     */

public static int add(int x, int y) {
        int ergebnis=0;
        if (y==0) 
            ergebnis=x;
        else {
            ergebnis=add(x,(y-1));
            ergebnis++;
        }

        return ergebnis;
    }

} 

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zu Methoden zu beantworten und die Übung 4.5.4 (Fragen) zu lösen.

Feedback

Zur Umfrage

"Information Hiding" und Datenkapselung im abstrakten Datentyp

Ein Bestandteil der Objektorientierung ist das "information Hiding" welches schon von den abstrakten Datentypen her bekannt ist. Der Zustand des Objekts wird durch seine Attribute bestimmt. Die Attribute sollen aber nicht beliebig geändert werden können. Die Methoden agieren als Wächter für die Zustandsübergänge und "bewachen" so zu sagen die Attribute des Objekts. Dies hat zwei wesentliche Vorteile

• Der Entwickler kann denn Zustand seines Objekts bzw. Datentyps immer genau kontrollieren
• Der Entwickler kann die interne Implementierung des Objekts an neue Anforderungen anpassen ohne, dass er dies mit den Benutzern des Objekts kommunizieren muss. Die Methoden bilden hierdurch eine Schnittstelle zwischen der Implementierung und der externen Sicht des Objekts

Methoden erfüllen in diesem Kontext mehrere Aufgaben:

• Sie lesen die internen, geschützten Datenstrukturen aus
• Sie ändern die internen Datenstrukturen
• Sie können komplexe Berechnungen durchführen
• Sie können wiederum andere Objekte manipulieren (von denen der Benutzer nichts weiß)

Information Hiding: Ein Teilsystem darf nichts von der Implementierung eines anderen Teilsystems wissen

Klasse

Nach Wikipedia:

Unter einer Klasse versteht man in der objektorientierten Programmierung ein abstraktes Modell bzw. einen „Bauplan“ für eine Reihe von ähnlichen Objekten.

Die Klasse dient als Bauplan für Abbildung von realen „Objekten“ in Softwareobjekten und enthält Attribute (Eigenschaften) und Methoden (Verhaltensweisen) der Objekte. Verallgemeinernd könnte man auch sagen, dass eine Klasse dem Datentyp eines Objekts entspricht.

Klassen

• sind eine Menge von gleichartigen, individuellen Objekten
• sind ein schematische Modell
• beschreiben
  • Eigenschaften (die Attribute einer Klasse)
  • Verhalten (Methoden)

Objekt

Nach Wikipedia:

Ein Objekt bezeichnet in der objektorientierten Programmierung (OOP) ein Exemplar eines bestimmten Datentyps oder einer bestimmten Klasse (auch „Objekttyp“ genannt). In diesem Zusammenhang werden Objekte auch als „Instanzen einer Klasse“ bezeichnet. Objekte sind also konkrete Ausprägungen („Instanzen“) eines Objekttyps.

Daumenregeln

• Der Paketname steht durch einen Punkt getrennt vor dem Klassennamen
• Pakete können auch wieder Pakete enthalten
• Eine Klasse mit all Ihren äusseren Paketen ist ein eindeutiger Name
• Klassen ohne einen Paketnamen liegen im Default-Package
  • Klassen ohne Paketnamen zu verwenden geht nicht mehr in neueren Java Versionen!
• Nutzt man einen Klassennamen ohne den Paketkontext, so kommt sie aus dem gleichen Paket

Diese Daumenregelen reichen nicht um die Klausur zu bestehen...

5.4.1 Übung: Vektorrechnung Ein Vektor im zweidimensionalen Raum kann durch 2 reelle Zahlen dargestellt werden. Erstellen Sie eine Klasse "Vektor", die Operationen(Methoden) für die Addition von Vektoren, die Multiplikation eines Vektors mit einem Skalar, die Bildung des Skalarprodukts zweier Vektoren (d.h. die Summe der Produkte der entsprechenden Komponenten) anbietet. Schreiben Sie auch einen geeigneten Konstruktor und implementieren Sie eine Ausgabemethode drucken(). Normalisieren Sie die Vektoren nach jeder Berechnung, so dass ihr Betrag den Wert 1 hat.

5.4.2 Übung: Komplexe Zahlen

Eine komplexe Zahl (z.B. 3.2 + i1.75) besteht aus einem reellen und einem imaginären Teil, beide vom Typ double. Erstellen Sie eine Klasse Complex, die komplexe Zahlen implementiert. Als Operationen (Methoden) sollen die vier Grundrechenarten sowie ein geeigneter Konstruktor angeboten werden. Hinweis:

Für jede

z1 = a + bi a,b ∈ ℝ
z2 = c + di c,d ∈ ℝ  
z1 + z2 = (a + ib) + (c + id) = (a + c) + i(b + d)
z1 - z2 = (a + ib) - (c + id) = (a - c) + i(b - d)
z1 * z2 = (a + ib) * (c + id) = (a*c - b*d) + i(a*d + b*c)
z1 / z2 = (a + ib) / (c + id) = (a*c + b*d)/(c*c + d*d) + i(b*c - a*d)/(c*c + d*d)

Benutzen Sie die Klasse Main als Hauptprogramm um auf die Klasse Complex zuzugreifen:

package s1.block5; public class Main { public static void main(String[] args) { Complex a = new Complex (1.0,2.0); Complex b = new Complex (3.0,4.0); Complex c,d,e,f; c = a.add(b); d = a.sub(b); e = a.mul(b); f = a.div(b); System.out.println (" a = " + a.toString()); System.out.println (" b = " + b.toString()); System.out.println (" c = " + c.toString()); System.out.println (" d = " + d.toString()); System.out.println (" e = " + e.toString()); System.out.println (" f = " + f.toString()); } }

Die Klasse Complex soll neben den Methoden add(), sub(), mul(), div() auch eine Methode toString() besitzen, die eine Zeichenkette mit dem Wert der komplexen Zahl im Format "(1.1 + i 2.2)" für einen Realteil von 1.1 und einem Imaginärteil von 2.2 ausgibt.

5.4.3 Übung: Modellierung der Datenkapselung

Erweitern Sie eine Klasse Flugzeug.java von einer einfachen Klasse mit einem öffentlichen Attribut zu einer objektorientierten Klasse mit geschützten Attributen und Zugriffsmethoden.

Vorsicht: Der unten aufgeführte Quellcode liegt nicht im default package. Der Quellcode liegt in package block5! Achten Sie auf das korrekte Paket beim Anlegen der Klassen.

1. Kopieren Sie sich die beiden Klassen Flugzeug.java und FlugzeugTest.java auf Ihren Rechner. Die Klasse FlugzeugTest dient zum Testen und Starten der Anwendung.
2. (Schritt 1-5) Implementieren die notwendigen Attribute als geschützte Attribute. Die Namen der Attribute sind auch in der drucken() Methode zu finden
3. (Schritt 6) Implementieren Sie die Methode zur Berechnung des aktuellen Gewichts
4. (Schritt 7): Entfernen Sie die Kommentare in der drucken() Methode.
5. (Schritt 8): Implementieren Sie einen Konstruktor für die Klasse Flugzeug. Der Konstruktor soll die Eingaben auf unvernünftige Werte prüfen und die Eingaben korrigieren (Werte kleiner Null, Maximalgewicht kleiner Leergewicht etc.)
6. (Schritt 9):  Schalten Sie im Hauptprogramm FlugzeugTest.main() den Aufruf der Methode phase1() frei und testen Sie das Programm durch den Aufruf der Klasse FlugzeugTest
7. (Schritt 10-13): Implementieren Sie alle benötigten Methoden (siehe Diagramm)
8. (Schritt 14): Schalten Sie im Hauptprogramm FlugzeugTest.main() den Aufruf der Methode phase2() frei und testen Sie das Programm durch den Aufruf der Klasse FlugzeugTest
9. (Schritt 15): Schalten Sie im Hauptprogramm FlugzeugTest.main() den Aufruf der Methode phase3() frei und testen Sie das Programm durch den Aufruf der Klasse FlugzeugTest. Analysieren Sie die Umsteigeimplementierung in phase3(). Testen Sie einige Sonderfälle durch Veränderung der Passagierzahlen. Beispiel: Was geschieht wenn das defekte Flugzeug mehr Passagiere hat als das Ersatzflugzeug?
10. (Schritt 16): Implementieren Sie die Methode phase4() und schalten Sie im Hauptprogramm FlugzeugTest.main() den Aufruf der Methode phase4() frei. Testen Sie das Programm durch den Aufruf der Klasse FlugzeugTest.
    • Implementieren Sie in Phase das Umsteigen von einem Airbus mit 560 Passagieren in zwei kleinere Jumbo Jets.
    • Verändern Sie die Ausgangssituation derart, dass in den Jumbo Jets schon zu viele Passagiere eingestiegen sind und nicht alle Passagiere des Airbus untergebracht werden können. Werden stehen gelassene Passagiere auf der Konsole gemeldet?

Gegeben:

Klasse Flugzeug

package block5;
public class Flugzeug {

public String kennzeichen; // Ein Attribut vom Typ einer Zeichenkette
// 1. Privates Attribut zur Verwaltung der Passagierkapazität
// Tipp: Untersuchen Sie die Druckmethode zur Wahl der
// Variablennamen (1-5)!

// 2. Privates Attribut zur Verwaltung der aktuellen Pasagiere

// 3. Leergewicht in privates Attribut ändern
// Ein Attribut vom Typ einer Ganzzahl
// 4. Maximales Gewicht des Flugzeugs

// 5. Öffentliche Konstante für durchschn. Passagiergewicht
/**
* 8. Konstruktor implementieren
* Konstruktor der Klasse Flugzeug
* @param kennz Kennzeichen des Flugzeugs
* @param kapazitaet Passagierkapazität
* @param leergew Leergewicht in kg
* @param maxgew Maximalgewicht in kg
*/
/**
* einsteigen()
* 10. Fügt einen Passagier zum aktuellen Flugzeug hinzu
*/
/**
* aussteigen()
* 11. Entfernt einen Passagier des aktuellen Flugzeugs
*/

/**
* anzahlPassagiere()
* 12. Ausgabe der aktuellen Anzahl der Passagiere
* @return aktuelle Anzahl der Passagiere
*/

/**
* gewicht()
* 6. Berechnen des aktuellen Gewichts
* @return aktuelles Gewicht
*/

/**
* passagierkapazität()
* 13. Ausgabe der maximalen Anzahl der Passagiere
* @return Maximale Anzahl der Passagiere
*/

/**
* Eine Methode zum Drucken der Attributbelegung des Objekts
* Die Methode erfordert keine Eingaben. Sie erzeugt keine
* Aufgaben
*/
public void drucken() {
// 7. Vervollständigen der Druckmethode
System.out.println("*****************************");
System.out.println("Kennzeichen: " + kennzeichen);
//System.out.println("Leergewicht: " + leergewicht + "kg");
//System.out.println("Maximalgewicht: " + maxgewicht + "kg");
//System.out.println("Aktuelles Gewicht : " + gewicht() + "kg");
//System.out.println("Passagiere: " + passagiere);
//System.out.println("Maximal Anzahl P.: " + maxPassagiere);
System.out.println("*****************************");
}

}

Klasse FlugzeugTest.java

package block5;

public class FlugzeugTest {
public static Flugzeug jumbo;
public static Flugzeug a380;

/**
* Die Methode main() wir zum Starten des Programms benutzt
* @param args Übergabe von Konsolenparameter. Hier nicht genutzt
*/
public static void main(String[] args) {
//phase1(); // 9. Phase 1 testen
//phase2(); // 14. Phase 2 testen
//phase3(); // 15. Phase 3 testen
//phase4();
}

/* Entfernen zum Testen von Phase 1
public static void phase1() {
System.out.println(" Phase 1: 2 Flugzeuge");
// Erzeugen zweier Objekte
jumbo = new Flugzeug("D-ABYT",360,191000,400000);
a380 = new Flugzeug("D-AIMD",560,286000,500000);

// Drucken der beiden Objekte auf der Konsole
jumbo.drucken();
a380.drucken();
}
*/
/* Entfernen zum Testen von Phase 2
public static void phase2() {

// 7. Testen des vorangehenden Hauptprogramms
System.out.println(" Phase 2: Einsteigen mit Überbuchung");

System.out.println("Ein Passagier in Jumbo einsteigen");
jumbo.einsteigen();
jumbo.drucken();
System.out.println("300 Passagiere in Jumbo einsteigen");
for (int i=0; i<300; i++) jumbo.einsteigen();
jumbo.drucken();
System.out.println("200 Passagiere aus Jumbo aussteigen");
for (int i=0; i<200; i++) jumbo.aussteigen();
jumbo.drucken();
System.out.println("200 Passagiere aus Jumbo aussteigen");
for (int i=0; i<200; i++) jumbo.aussteigen();
jumbo.drucken();