Selbstvorstellung

Diese Umfrage hilft dem Dozenten Sie besser kennnen zulernen und die nächsten Vorlesungen zu planen.

1.1 Buchreferenzen

Skript

• DHBW Mosbach, Prof. Dr, Herbert Neuendorf: Skript der Parallelvorlesung
  • Foliensatz 1A, Foliensatz 1B
  • Foliensatz 2A, Foliensatz 2B

Kostenlose E-Books

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

1.2 Grundlegende Konzepte

 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.

public class Flugzeug {
    String kennzeichen; // Ein Attribut vom Typ einer Zeichenkette
    int leerGewicht; // Ein Attribut vom Type einer Ganzzahl

    /**
     * Eine Methode zum Drucken der Attributbelegung des Objekts
     * Die Methode erfordert keine Eingaben. Sie erzeugt keine
     * Aufgaben
     */
    public void drucken() {
        System.out.println("Kennzeichen " + kennzeichen + " "
                + leerGewicht + "kg");
    }

    /**
     * Die Methode main() wird zum Starten des Programms benutzt
     * @param args Übergabe von Konsolenparameter. Hier nicht genutzt
     */
    public static void main(String[] args) {
        // Erzeugen zweier Objekte
        Flugzeug jumbo = new Flugzeug();
        Flugzeug a380 = new Flugzeug();
        // Belegen der Attribute des ersten Objekts mit Werten

        jumbo.kennzeichen = "D-ABYT";
        jumbo.leerGewicht = 191000;

        // Belegen der Attribute des zweiten Objekts mit Werten
        a380.kennzeichen = "D-AIMD";
        a380.leerGewicht = 286000;

        // Drucken der beiden Objekte auf der Konsole
        jumbo.drucken();
        a380.drucken();
    }
}

1.3 Java Abgrenzung, Begriffsbestimmung

(Lizenz)

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
    • 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
      • RTS: "Real time System" Edition, Laufzeitumgebung für Realzeitanwendungen
        • Demo auf youtube

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.

$ java HelloWorld
Hello World!

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

public class HelloWorldApplet extends Applet{
    // Diese Methode wird aufgerufen wenn das Applet started
    public void init() {
         // Die Methode ist notwendig. Sie muss aber nicht mit Inhalt gefüllt
         // werden.
         System.out.println("HelloWorldApplet.init() aufgerfen");
     }


    // Diese Methode wird aufgerufen wenn das Applet beendet wird.
    // Der Benutzer hat die html Seite verlassen
     public void stop()
     {
     System.out.println("HelloWorldApplet.stop() aufgerufen");
     }

    // Die Standardmethode um etwas auf den Bildschirm zu malen

     public void paint(Graphics g)
     {
     //Diese Methode malt Text auf den Bildschirm
     // Text, x Koordinate, y Koordinate
      g.drawString("Dies ist ein Text",20,20);
      g.drawString("Hello World!",20,40);
     }
}

1.4 Von der Javaweiterentwicklung zum Produkt

 JCP: Java Community Prozess

• Konsortium aus Industrievertretern, OpenSource-Gruppen, Spezialisten
• Ziel: Weiterentwicklung und Standardisierung von allen Javakomponenten

Prinzipielles Vorgehen ist das Arbeiten in gemeinsamen Untergruppen: JSR (Java Specification Request) nach folgendem Prinzip

• Themenvorschlag für JSR
• Annahme wenn relevant (allgemeines Interesse, kein Überlap etc.)
• Gründung einer "Expert Group" unter Leitung des "Spezification Lead"
• Gemeinsame Entwicklung eine Spezifikation bestehend aus
  • Spezifikation
  • Referenzimplementierung
  • TCK: Test Compatiblity Kit zum Testen von späteren Implementierungen von dritten PArteien
• Standardisierung nach einer Reihe von Kontroll- und Freigabeprozessen in der Community

Ziel ist die breite allgemeine Verfügbarkeit der Technologie.

Wichtig:

• Referenzimplementierung und TCK sind geistiges Eigentum des "Specification lead" um ihn für die Entwicklungskosten zu kompensieren
• Die Modalitäten der Verbreitung kann der "Specification Leader" selbst bestimmen
  • Lizensierungsbedingungen von Referenzimplementierung und TCK
  • Open Source
  • kostenlose zur Verfügungstellung von Produkten
  • etc.

OpenJDK

Ein großer Teil der Java Standardedition von Oracle/Sun als Open Source bei OpenJDK.org freigegeben.

Hier findet zur Zeit (Stand 10.2010) die Entwicklung zu JDK 7 statt.

Produktverfügbarkeiten

Folge der unterschiedlichen Kollaborationsmodelle sind unterschiedlichste Produkte die zu unterschiedlichen Bedingungen genutzt werden können:

• Kostenlos nutzbare Produkte (mit und ohne kommerzieller Wartung)
  • Beispiel Sun/Oracle JDK für Java SE
• Lizenzpflichtige Produkte
  • z.Teil bei der Enterprise Edition
• Gerätegebundene Produkte
  • JavaME: Mobile Edition
• Open Source Lizensmodelle

Wichtig: Für Standard-, Micro-, Enterpriseedition: Nur Produkte die Zertifizierungstest mit den entsprechenden TCKs bestanden haben dürfen sich "Java" nennen.

1.5 Programme des Java JDK

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

• JRE: Java Runtime Edition
• 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 7.0 Dokumentation 

$ javac HelloWorld.java

$ java HelloWorld

$ java -version
java version "1.6.0_20"
Java(TM) SE Runtime Environment (build 1.6.0_20-b02-279-10M3065)
Java HotSpot(TM) Client VM (build 16.3-b01-279, mixed mode)

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

$javac HelloWorld.java

$ java HelloWorld
Hello World!

$ javac [Optionen] [Quelldateien] 

sschneid@scalingbits:~/l1$ javap HelloWorld
Compiled from "HelloWorld.java"
class HelloWorld extends java.lang.Object{
    HelloWorld();
    public static void main(java.lang.String[]);
}

/**
 *
 * @author Ihr Name
 */
public class HelloWorld {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}

sschneid@scalingbits:~/l1$ javadoc HelloWorld.java 
Loading source file HelloWorld.java...
Constructing Javadoc information...
Standard Doclet version 1.6.0_18
Building tree for all the packages and classes...
Generating HelloWorld.html...
Generating package-frame.html...
Generating package-summary.html...
Generating package-tree.html...
Generating constant-values.html...
Building index for all the packages and classes...
Generating overview-tree.html...
Generating index-all.html...
Generating deprecated-list.html

/**
 *
 * @author Stefan Schneider
 */
public class HelloWorld {
   native int test();

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        System.out.println("Hello Gedit");
    }
}

javac HelloWorld.java
javah HelloWorld

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class HelloWorld */

#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     HelloWorld
 * Method:    test
 * Signature: ()I
 */
JNIEXPORT jint JNICALL Java_HelloWorld_test
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

java DemoFrame

jps
254 
16964 Jps
16959 DemoFrame

jconsole 16959

java DemoFrame

Pegasus:bin sschneid$ jconsole 16959
Pegasus:bin sschneid$ jps
254 
17168 Jps
17166 DemoFrame

Pegasus:bin sschneid$ jinfo 17166
Attaching to process ID 17166, please wait...
Debugger attached successfully.
Client compiler detected.
JVM version is 16.3-b01-279
Java System Properties:

java.runtime.name = Java(TM) SE Runtime Environment
sun.boot.library.path = /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Libraries
java.vm.version = 16.3-b01-279
awt.nativeDoubleBuffering = true
gopherProxySet = false
mrj.build = 10M3065
java.vm.vendor = Apple Inc.
java.vendor.url = http://www.apple.com/
path.separator = :
java.vm.name = Java HotSpot(TM) Client VM
file.encoding.pkg = sun.io
sun.java.launcher = SUN_STANDARD
user.country = DE
sun.os.patch.level = unknown
java.vm.specification.name = Java Virtual Machine Specification
user.dir = /Users/sschneid/Documents/JavaKurs/beispiele/l1/HelloWorld
java.runtime.version = 1.6.0_20-b02-279-10M3065
java.awt.graphicsenv = apple.awt.CGraphicsEnvironment
java.endorsed.dirs = /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home/lib/endorsed
os.arch = i386
apple.awt.graphics.UseOpenGL = false
java.io.tmpdir = /var/folders/UO/UOnPVFsvGEO5k3UJnjadeE+++TI/-Tmp-/
line.separator = 

java.vm.specification.vendor = Sun Microsystems Inc.
os.name = Mac OS X
sun.jnu.encoding = MacRoman
java.library.path = .:/Library/Java/Extensions:/System/Library/Java/Extensions:/usr/lib/java
java.specification.name = Java Platform API Specification
java.class.version = 50.0
sun.management.compiler = HotSpot Client Compiler
os.version = 10.6.4
http.nonProxyHosts = local|*.local|169.254/16|*.169.254/16
user.home = /Users/sschneid
user.timezone = 
java.awt.printerjob = apple.awt.CPrinterJob
file.encoding = MacRoman
java.specification.version = 1.6
java.class.path = .
user.name = sschneid
apple.awt.graphics.UseQuartz = false
java.vm.specification.version = 1.0
java.home = /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home
sun.arch.data.model = 32
user.language = de
java.specification.vendor = Sun Microsystems Inc.
awt.toolkit = apple.awt.CToolkit
java.vm.info = mixed mode
java.version = 1.6.0_20
java.ext.dirs = /Library/Java/Extensions:/System/Library/Java/Extensions:/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home/lib/ext
sun.boot.class.path = /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Classes/jsfd.jar:/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Classes/classes.jar:/System/Library/Frameworks/JavaVM.framework/Frameworks/JavaRuntimeSupport.framework/Resources/Java/JavaRuntimeSupport.jar:/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Classes/ui.jar:/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Classes/laf.jar:/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Classes/sunrsasign.jar:/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Classes/jsse.jar:/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Classes/jce.jar:/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Classes/charsets.jar
java.vendor = Apple Inc.
file.separator = /
java.vendor.url.bug = http://bugreport.apple.com/
sun.io.unicode.encoding = UnicodeLittle
sun.cpu.endian = little
mrj.version = 1060.1.6.0_20-279
socksNonProxyHosts = local|*.local|169.254/16|*.169.254/16
ftp.nonProxyHosts = local|*.local|169.254/16|*.169.254/16
sun.awt.exception.handler = apple.awt.CToolkit$EventQueueExceptionHandler
sun.cpu.isalist = 

VM Flags:

import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorldApplet extends Applet{
    /**
     * Diese Methode wird aufgerufen wenn das Applet started
     * 
     */
    public void init() {
         // Die Methode ist notwendig. Sie muss aber nicht mit Inhalt gefüllt
         // werden.
         System.out.println("HelloWorldApplet.init() aufgerufen");
     }

    /**
     * Diese Methode wird aufgerufen wenn das Applet beendet wird.
     * Der Benutzer hat die html Seite verlassen
     */
     public void stop()
     {
     System.out.println("HelloWorldApplet.stop() aufgerufen");
     }

     /**
      * Die Standardmethode um etwas auf den Bildschirm zu malen
      */
     public void paint(Graphics g)
     {
     //Diese Methode malt Text auf den Bildschirm
     // Text, x Koordinate, y Koordinate
      g.drawString("Dies ist ein Text",20,20);
      g.drawString("Hello World!",20,40);
     }
}

java HelloWordApplet.java

<html>
   <applet code="HelloWorldApplet.class" width="200" height="50" >
   </applet>
</html>

appletviewer HelloWorld.html

1.6 Variablen und Zuweisungen

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. Dies erfolgt mit einer Deklaration in der folgenden Syntax:

Beispiele:

int x;
float y,z;

Variablen erhalten mit Zuweisungen eine neue Belegung. Hierfür können Konstanten, Variablen oder Operationen 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 auf der rechten Seite aus und weist erst dann 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.

Anmerkung: DIe Prozessorschritte der Überprüfung der Variablen x auf Null wurde hier nicht explizit aufgeführt.

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;

1.7 Übungen

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

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

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.8 Lösungen

(Lizenz)

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.9 Fragen

1.9.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.9.3 Zuweisungsbeispiel

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

Notieren Sie zur Hilfe alle Zwischenzustände

1.9.4 Welche C-Funktion muss implementiert werden?

Ein chaotischer Entwickler sind Ihnen die Binärdatei Raetsel.class und bittet Sie die notwendige native C Methode zu implementieren?

Ansonsten gibt er Ihnen leider keine zusaätzlichen Informationen...

• Welcher Methoden und Attribute hat die Klasse Raetsel? Welches Werkzeug hilft Ihnen hier?
• Wie heißt die C-Funktion die Sie implementieren sollen? Welches Werkzeug hilft Ihnen hier?

1.10 Antworten

1.10.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
    
  • javah
• Welcher Typ von Dateien wird vom Befehl javadoc erzeugt?
  • javadoc erzeugt Dokumentationsdateien im html Format. Die Dateiendung ist daher .html

1.10.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.10.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

1.10.4 Welche C-Funktion muss implementiert werden?

Laden Sie die Binärdatei auf Ihren Rechner.

Der folgende Befehl dissambliert die Klasse und erzeugt eine Klassenbeschreibung mit allen öffentlichen Komponenten der Klasse.

Rufen Sie javap in dem Verzeichniss aus in dem die Datei Raetsel.class steht:

pegasus:classes sschneid$ javap Raetsel
Compiled from "Raetsel.java"
public class Raetsel extends java.lang.Object{
    public int variable1;
    public float variable2;
    public java.lang.String variable3;
    public Raetsel();
    public void testMethode();
    public native void methodeInC();
}

Der notwendige C-Prototyp Raetsel.h wird mit dem Kommando javah erzeugt. Man muss das Kommando im Verzeichnis aufrufen in dem die Datei Raetsel.class steht:

javah Raetsel

Hierdurch wird eine Datei Raetsel.h erzeugt:

* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class Raetsel */
#ifndef _Included_Raetsel
#define _Included_Raetsel
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     Raetsel
 * Method:    methodeInC
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_Raetsel_methodeInC
  (JNIEnv *, jobject);
#ifdef __cplusplus
}
#endif
#endif

Der Name der zu implementierenden Funktion ist fettgedruckt. Alle anderen Zeilen bestehen au Direktiven für die Programmiersprachen C, C++ und aus Kommentaren.

1.11 Lernziele

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zu beantworten:

• 1.1 Starten einer Anwendung
• 1.3 Dateiextensionen und Javabefehle
• 1.4 Wozu dient jar?
• 1.29 Anwendungen des Java Development Kits

2.1 Schlüsselwörter, Literale, Variablennamen, Kommentare

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). Ähnliches 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
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: (Stand 2012)  Java 7 ist ein neuer Standard der noch nicht überall eingesetzt wird:

• 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 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
*/

2.2 Datentypen und Wertebereiche

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.

class  AufzaehlungsDemo {
   enum Kartenfarbe {KARO, HERZ, PIK, KREUZ}
   enum Wochentag {MONTAG, DIENSTAG, MITTWOCH, DONNERSTAG, FREITAG, SAMSTAG, SONNTAG}
}

Wochentag heute = Wochentag.MITTWOCH;
Kartenfarbe dame = Kartenfarbe.HERZ;

short a;
int b;
....
a = b;

short a;
int b;
....
a = (short)b; 

2.3 Operatoren und Ausdrücke

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 block2;
public class Main {
    public static void PrePostFixTest(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.

Bedingungsoperatoren

Der dreistellige 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 größer als x ist.

Bedingt auswertende && und || Operatoren

Die bedingt auswertenden Operatoren werten Terme nur soweit aus bis das Endergebnis fest steht. Dies macht sie seht 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

Bitoperator

Mit Bitoperatoren werden alle Bits zweier Variablen einzeln manipuliert.

Beispiel

package 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 

Beispiel

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

x = 4; shift = 1 result = 8
x = 4; shift = 1 result = 2
x = 4; shift = 1 result = 1
x = 4; shift = 1 result = 0
x = 4; shift = 1 result = 0

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:

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:

2.4 Übungen

• 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.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Calendar;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
/**
 *
 * @author sschneid
 */
public class Uhr extends JPanel {
static int sekunde = 0;
    static int minute = 0;
    static int stunde = 0;
    static String tzString; // aktuelle Zeitzone

     /**
     * 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(2 * Zeiger.maxRadius + 80, 2 * Zeiger.maxRadius + 80);
        hf.setVisible(true);
        hf.setAlwaysOnTop(true);
        // 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);
        int xCenter = Zeiger.maxRadius + 40;
        int yCenter = Zeiger.maxRadius + 20;
        int maxRadius = Zeiger.maxRadius;
        int charCenterOffSet = 5;
        String timeString = stunde + ":" + minute + ":" + sekunde
                + " " + tzString;
        // Zeichne Uhrenhintergrung und Koordinatensystem
        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", xCenter + 45, yCenter + +charCenterOffSet);
        g.drawString("Y", xCenter - charCenterOffSet, yCenter + 55);
        g.drawString("12", xCenter - charCenterOffSet, yCenter - maxRadius);
        g.drawString("3", xCenter + maxRadius, yCenter + charCenterOffSet);
        g.drawString("6", xCenter, yCenter + maxRadius);
        g.drawString("9", xCenter - maxRadius - charCenterOffSet,
                yCenter + charCenterOffSet);
        // Zeichne aktuelle Zeit zum Debuggen
        g.drawString(timeString, 0, yCenter + maxRadius + 10);
        
        // Zeichne Stundenzeiger
        g.setColor(Color.BLACK);
        g.drawLine(xCenter, yCenter,
                xCenter + Zeiger.stundeX(stunde),
                yCenter + Zeiger.stundeY(stunde));
        g.drawString("h["
                + Zeiger.stundeX(stunde) 
                + "," + Zeiger.stundeY(stunde) + "]",
                0, yCenter + maxRadius - 40);
        // Zeichne Minutenzeiger
        g.setColor(Color.RED);
        g.drawLine(xCenter, yCenter,
                xCenter + Zeiger.minuteX(minute),
                yCenter + Zeiger.minuteY(minute));
        g.drawString("m["
                + Zeiger.minuteX(minute) + "," 
                + Zeiger.minuteY(minute) + "]", 0, yCenter + maxRadius - 25);
        // Zeichne Sekundenzeiger
        g.setColor(Color.BLUE);
        g.drawLine(xCenter, yCenter,
                xCenter + Zeiger.sekundeX(sekunde),
                yCenter + Zeiger.sekundeY(sekunde));
        g.drawString("s["
                + Zeiger.sekundeX(sekunde) + "," 
                + Zeiger.sekundeY(sekunde) + "]", 0, yCenter + maxRadius - 10);
    }
}

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 int Sekunden der aktuellen Zeit. Ein Wert zwischen 0 und 59 
     * @return int 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 int Sekunden der aktuellen Zeit. Ein Wert zwischen 0 und 59 
     * @return int 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 int Minuten der aktuellen Zeit. Ein Wert zwischen 0 und 59 
     * @return int 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 int Minuten der aktuellen Zeit. Ein Wert zwischen 0 und 59 
     * @return int 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 int Stunden der aktuellen Zeit. Ein Wert zwischen 0 und 12 
     * @return int aktuelle X Koordinate der Zeigerspitze des Stundenzeigers 
     *             auf dem Bildschirm
     */
    public static int stundeX(int h) {
        int xs;
        /* Implementierung Beginn */
        xs = h; // Proformazuweisung. Sie ist zu ersetzen
        /* Implementierung Ende */
        return xs;
    }
    
    /**
     * @param int Stunden der aktuellen Zeit. Ein Wert zwischen 0 und 12 
     * @return int aktuelle Y Koordinate der Zeigerspitze des Stundenzeigers 
     *             auf dem Bildschirm
     */
    public static int stundeY(int h) {
        int ys;
        /* Implementierung Beginn */
        ys = h; // Proformazuweisung. Sie ist zu ersetzen
        /* Implementierung Ende */
        return ys;
    }
}

2.5 Lösungen

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.4.11 Analoge Uhr

import static java.lang.Math.*;
/**
*
* @author sschneid
*/
public class Zeiger {
   public static final int maxRadius = 100; // Beeinflusst GUI-Größe !
   /**
   * @param int Sekunden der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return int 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 int Sekunden der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return int 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 int Minuten der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return int 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 int Minuten der aktuellen Zeit. Ein Wert zwischen 0 und 59
   * @return int 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 int Stunden der aktuellen Zeit. Ein Wert zwischen 0 und 12
   * @return int aktuelle X Koordinate der Zeigerspitze des Stundenzeigers
   * auf dem Bildschirm
   */
   public static int stundeX(int h) {
      int xs;
      /* Implementierung Beginn */
      double sx = sin(h*2*PI/12)*maxRadius*0.5;
      xs = (int)sx;
     /* Implementierung Ende */
     return xs;
   }
   /**
   * @param int Stunden der aktuellen Zeit. Ein Wert zwischen 0 und 12
   * @return int aktuelle Y Koordinate der Zeigerspitze des Stundenzeigers
   * auf dem Bildschirm
   */
   public static int stundeY(int h) {
      int ys;
      /* Implementierung Beginn */
      double sy = -cos(h*2*PI/12)*maxRadius*0.5;
      ys = (int)sy;
      /* Implementierung Ende */
      return ys;
   }
}

2.6 Webcast: Java Variablen, Zuweisungen und Operatoren

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

2.7 Fragen

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 Antworten

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.

2.9 Lernziele

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zu beantworten:

• Zuweisungen mit dem Datentyp char
• Die erste ganze Zahl berechnen die man mit dem Typ int noch darstellen kann aber nicht mehr mit dem Typ float.
• 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
• Syntax von Zuweisungen
• Syntax von Bezeichnern
• Nicht erlaubte Namen für Bezeichnern
• Vererbung, Konstruktoren, Verfolgen des Ablauf

(Nur das Markieren der Schlüsselwörter ist für diesen Abschnitt relevant)

3.1 Verzweigungen und Vergleichsoperationen

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

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

Im Fall der if Bedingung ohne else Klausel kann man die geschweiften Klammer mit einem Anweisungsblock weglassen und durch eine einzelne Anweisung ersetzen.

int x = 8;
int y;
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 =b0; 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 nur eine else Bedingung von der  nicht  unbedingt klar 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, char, 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:

int Wochentag;
...
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"); }

3.2 Schleifen und Felder

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(en)} 

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(en)} 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 anspruchscollste der 3 Schleifenarten:

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

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 benutz 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 der Methode .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)  // for each i in xxx[]
  System.out.println("Wert: " + position);

Wird das folgende Ergebnis liefern:

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

3.3 Übungen

    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 

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: Schleifentransformation

  int s = 0;
  for(;;) {
    int x = System.in.read(); //liest ein Zeichen von der Konsole
    if (x < 0) break;
    s = s + x;
}

Der Quellcode wird erst ausführbar wenn man einen potentiellen IO Fehler behandelt. Siehe

...
import java.io.IOException;
...
            try {
                x = System.in.read(); //liest ein Zeichen von der Konsole
            } catch (IOException ex) {
                System.out.println(" Java IO Exception");
            }

3.3.5 Ü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 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.6 Übung: Primfaktorzerlegung

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

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

package 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.7 Übung: Codevereinfachung

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

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

3.3.8 Ü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.9 Ü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.10 Ü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.11 Ü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.12 Ü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.13 Ü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.14 Ü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.

3.3.15 Ü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.16 Ü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.17 Ü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.18 Ü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 Weckuhr 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

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

/*
 * Zeichnen einer analogen Uhr in einem JFrame
 */
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Calendar;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JTextField;
/**
 *
 * @author sschneid
 */
public class WeckerUhr extends JPanel {
int sekunde = 0;
    int minute = 0;
    int stunde = 0;
    boolean klingeln = false;
    String tzString; // aktuelle Zeitzone
    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);
     }
     /**
     * 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);
        int xCenter = Zeiger.maxRadius + 40;
        int yCenter = Zeiger.maxRadius + 20;
        int maxRadius = Zeiger.maxRadius;
        int charCenterOffSet = 5;
        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-klingelRadius/2,yCenter-klingelRadius/2,
                    klingelRadius,klingelRadius);
             }
        // Zeichne Uhrenhintergrung und Koordinatensystem
        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", xCenter + 45, yCenter + +charCenterOffSet);
        g.drawString("Y", xCenter - charCenterOffSet, yCenter + 55);
        g.drawString("12", xCenter - charCenterOffSet, yCenter - maxRadius);
        g.drawString("3", xCenter + maxRadius, yCenter + charCenterOffSet);
        g.drawString("6", xCenter, yCenter + maxRadius);
        g.drawString("9", xCenter - maxRadius - charCenterOffSet,
                yCenter + charCenterOffSet);
        // Zeichne aktuelle Zeit zum Debuggen
        g.drawString(timeString, 0, yCenter + maxRadius + 10);
        // Zeichne Weckzeit zum Debuggen
        g.drawString(klingelString, 0, yCenter + maxRadius + 25);
        // Zeichne Stundenzeiger
        g.setColor(Color.BLACK);
        g.drawLine(xCenter, yCenter,
                xCenter + Zeiger.stundeX(stunde),
                yCenter + Zeiger.stundeY(stunde));
        g.drawString("h["
                + Zeiger.stundeX(stunde)
                + "," + Zeiger.stundeY(stunde) + "]",
                0, yCenter + maxRadius - 40);
        // Zeichne Minutenzeiger
        g.setColor(Color.RED);
        g.drawLine(xCenter, yCenter,
                xCenter + Zeiger.minuteX(minute),
                yCenter + Zeiger.minuteY(minute));
        g.drawString("m["
                + Zeiger.minuteX(minute) + ","
                + Zeiger.minuteY(minute) + "]", 0, yCenter + maxRadius - 25);
        // Zeichne Sekundenzeiger
        g.setColor(Color.BLUE);
        g.drawLine(xCenter, yCenter,
                xCenter + Zeiger.sekundeX(sekunde),
                yCenter + Zeiger.sekundeY(sekunde));
        g.drawString("s["
                + Zeiger.sekundeX(sekunde) + ","
                + Zeiger.sekundeY(sekunde) + "]", 0, yCenter + maxRadius - 10);
    }
}

3.4 Lösungen

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 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 Schleifentransformation

package block3;
import java.io.IOException;

public class Schleifentransformation {
    public static void main(String[] args) {
        int s = 0;
        int x = 0;

        while(true) { //Option 1
            try {
                x = System.in.read(); //liest ein Zeichen von der Konsole
            } catch (IOException ex) {
                System.out.println(" Java IO Exception");
            }
            if (x < 0) break;
            s = s + x;
        }
        do { //Option 2
            try {
                x = System.in.read(); //liest ein Zeichen von der Konsole
            } catch (IOException ex) {
                System.out.println(" Java IO Exception");
            }
            if (x < 0) break;
            s = s + x;
        } while(true);
        }
}

3.4.5 Zahlenstatistik

package 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.6 Primzahlzerlegung

package 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.7 Codevereinfachung

a.)

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

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

3.4.8 Wochentagberechnung

Hier wurde nur der julianische Kalender implementiert nicht der (aktuelle) gregorianische Kalender.

package 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;

       tagText[0] = "Sonntag";
       tagText[1] = "Montag";
       tagText[2] = "Dienstag";
       tagText[3] = "Mittwoch";
       tagText[4] = "Donnerstag";
       tagText[5] = "Freitag";
       tagText[6] = "Samstag";

       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.9 Überlauf

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

package 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.10 Schnitt zweier Linien

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

package 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 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.11 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.12 Dreiecksbestimmung

package 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.13 Sortieren

package 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.14 Plausibilitätsprüfung

package block3;
public class Plausibilitaetspruefung {
    public static void main(String[] args) {
       int monatTage[] = {0, 31, 28, 31, 30, 31, 30,
                             31, 31, 30, 31, 30, 13};
       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.15 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 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.16 Verzweigung

package 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.17 Häufigkeit von Zeichen

package 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.18 Weckzeiten implementieren

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;
    }
}

3.5 Lernziele

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zu beantworten:

• Frage aus der Übung 3.3.1 Schleifenterminierung
• Codetransformation
• Codetransformation von Schleifen
• Codetransformation switch-case

4.1 Methoden

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);
   ^      ^    ^          ^           ^
   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 ähnlich wie 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 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.

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. Es muss jedoch in jeder Variante der geforderte Typ zurückgegeben werden.

Siehe Beispiel:

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 Prameter

• 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 (Fall1 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 (Fall3 im Beispiel)
• Die Methode ist statisch und gehört zu einer anderen Klasse. (Fall 4 im Beispiel)

Beispiel:

public class Flugzeug {
    public void drucken () {
        //...
    }
    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
        Flugzeug.eigenschaft(); // Fall4: Aufruf einer statischen Methoden die zu einer anderen Klasse gehören kann
        double pi = Math.sqrt(2.0); // Fall4: Aufruf einer statischen Methoden die zu einer anderen Klasse gehört
    }
    public void kennzeichenAusgeben() {
        drucken(); // Fall 1: Nicht statischer Methodenaufruf
    }
    public static void eigenschaft() {
        System.out.println("kann fliegen");
    }
}

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.

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

Überladene Methoden

Ü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.

4.2 Variablen, (Sichtbarkeit lokal, global)

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:

4.3 Konstruktoren (1)

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 bock4;
public class Employee {
    public String surName;
    public String firstName;
    public int employeeId;
    public double salary;

    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.println(employeeId + ", " + surName + " " + firstName);
        System.out.println("Salary :" + salary);
    }
}
public class Main {

    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();
    }
}

4.4 Iteration und Rekursion

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 block4;
public class Fibonacci {
    
    public static long fib(int f) {
        long ergebnis=0;
        switch (f) {
            case 0:  { ergebnis = 0;break;}
            case 1:  { ergebnis = 1;break;}
            default: { // Die Rekursion
                ergebnis = fib(f - 1) + fib(f - 2);
                break;
            }    
        }
        return ergebnis;
    }
    
    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));          
    } 
}

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.

Implementierung der Türme von Hanoi in Java

package 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

4.5 Übungen

Was geschieht wenn man die Operationen von verschiedenen Typen mischt?

public class Rechenarten {
    /* Implementierung */

    public static void main(String[] args) {
        System.out.println(" 5.0 + 4.0 = " + add(5.0,4.0));
        System.out.println(" 9.0 / 4.0 = " + div(9.0,4.0));
        System.out.println(" 9.0 - 4.0 = " + sub(9.0,4.0));
        System.out.println(" 9.0 / 4.0 + 3.0 = " + add(div(9.0,4.0),3.0));

        System.out.println(" 5 + 4 = " + add(5,4));
        System.out.println(" 9 / 4 = " + div(9,4));
        System.out.println(" 9 - 4 = " + sub(9,4));
        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 Katheden gegeben
  • 1 Hypotenuse, 1 Kathede gegeben

Nutzen Sie wenn möglich andere Methoden zur Berechnung der Fläche.

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

• Tipp: Entfernen Sie den Importbefehl in der Zeile "package block4;" falls Sie mit Kommandozeilenwerkzeugen arbeiten und Packageverzeichnisse vermeiden wollen
• Vereinfachung: Die Anwendung muss nur für nicht negative Zahlen funktionieren

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 die die Berechnung des Ergebnises 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.6 Lösungen

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) {
        System.out.println(" 5.0 + 4.0 = " + add(5.0,4.0));
        System.out.println(" 9.0 / 4.0 = " + div(9.0,4.0));
        System.out.println(" 9.0 - 4.0 = " + sub(9.0,4.0));
        System.out.println(" 9.0 / 4.0 + 3.0 = " + add(div(9.0,4.0),3.0));

        System.out.println(" 5 + 4 = " + add(5,4));
        System.out.println(" 9 / 4 = " + div(9,4));
        System.out.println(" 9 - 4 = " + sub(9,4));
        System.out.println(" 9 / 4 + 3 = " + add(div(9,4),3));
    }

4.6.2 Flächenberechnung vom Dreieck

public class l4dreiecksflaeche {
  
    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));
    }
  
    public static double flaeche(double gleicherSchenkel, double basis) {
      return flaeche(gleicherSchenkel, gleicherSchenkel, basis);
    }

   public static double flaeche(double gleicheSeite) {
        return flaeche(gleicheSeite, gleicheSeite);
    }
  
   public static void main(String[] args) {
        System.out.println(" 3,4,5 = " + flaeche(3.0, 4.0, 5.0));
        System.out.println(" 2*4,5 = " + flaeche(4.0, 5.0));
        System.out.println(" 3*3 = " + flaeche(3.0));
    }  
}

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;
    }
    
} 

4.7 Programmieren mit Java: Testfragen (1-4)

 Die folgenden Fragen können auch in der Klausur gestellt werden.

im Test werden 24 Punkte vergeben. Sie haben 24 Minuten zum Lösen der Aufgaben. In der Klausur werden 100 Punkte in 90 Minuten vergeben.

4.8 Lernziele

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zu beantworten:

• Methoden Implementieren und Dokumentieren
• Konstruktoren (Diese Aufgabe benötigt Wissen was zum Teil erst in Block 6 vermittelt  wird)
• Lebensdauer lokaler Variablen
• Übung 4.5.4 (Fragen)
• Implementieren einer Methode
• Bestandteile eines Methodenkopfs
• Überladene Methoden

5.1 Einführung Objektorientierung

Die objektorientierte Programmierung hilft große Softwareentwicklungsprojekte überschaubarer und handlicher zu machen.

Die Grundidee besteht darin die zu verarbeitenden Daten und die Algorithmen (Methoden) mit denen die Daten verarbeitet werden zu handlichen, wartbaren Einheiten zusammenzufassen.

Objektorientierte Programmierung fasst man mit den folgenden Konzepten zusammen:

• Datenkapselung (Information Hiding)
• Klassenbildung
• Polymorphimus
• Vererbung

Das erste Konzept, die Datenkapselung, kann man als eine technische Weiterentwicklung der Datentypen sehen.

1. Primitive Datentypen (z.Bsp. int x = 10;)
2. Strukturierte Datentypen wie Felder oder struct in der Programmiersprache C erlauben mehrere Typen in einer Struktur zusammenzufassen.
3. Klassen, die es erlauben mehrere Datentypen (diese werden Attribute genannt) mit den dazugehörigen Methoden zusammenzufassen und zu kapseln.
   • Beispiel: Eine Linie, die aus zwei Punkten besteht und den Zugriff auf die Punkte nur nach bestimmten Vorschriften in Methoden kapselt.

"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önne 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.

5.2 Javaklassen und -objekte

Bisher wurden Klassen nur benutzt um mit Methoden zu arbeiten. Die main() Methode wurde immer als Hauptprogramm genutzt um Methoden aufzurufen. Klassen sind jedoch Strukturen die auch Variablen und Konstanten in Form von Attributen aufnehmen können. 

Im folgenden Beispiel wird ein Kraftwagen modelliert:

class Kraftwagen {
   public String nummernschild;
   public double leergewicht;
   public int neupreis;

   /**
   * Ein selbstgewählter Konstruktor
   * @param String Das Kennzeichen des Fahrzeugs
   */
   public Kraftwagen(String kennzeichen) {
       nummernschild = kennzeichen;
   }

   public void drucken() {
      System.out.println("Nummernschild: " + nummernschild);
      System.out.println("Leergewicht: " +  leergewicht );
      System.out.println("Neupreis: " +  neupreis );
   }
}

Die Klasse Kraftwagen unterscheidet sich in einer Reihe von Aspekten von den bisher benutzten Klassen:

• Sie besitzt keine main() Methode. Sie ist nicht als Hauptprogramm ausführbahr.
• die drucken() Methode is nicht als static deklariert
• die Klasse verfügt über Attribute

Die Klasse Kraftwagen kann nun von anderen Klassen verwendet werden:

class Fuhrpark{
   public static void main( String[] args ) {
      Kraftwagen wagen1 = new Kraftwagen("M-O-4711");
      Kraftwagen wagen2 = new Kraftwagen("MA-Y-11");
      Kraftwagen wagen3 = new Kraftwagen("S-AY-7");
      wagen1.leergewicht = 890.0d;
      wagen1.neupreis = 20000;
   
      wagen2.leergewicht = 1050.0d;
      wagen2.neupreis = 15000;

      wagen3.leergewicht = 1250.0d;
      wagen3.neupreis = 28000;

      wagen1.drucken();
      wagen2.drucken();
      wagen3.drucken();

   }
}

Die Methode main() der Klasse Fuhrpark legt hier drei Objekte (Instanzen) der Klasse Kraftwagen an. Die Attribute der drei Objekten können mit individuellen Werten belegt werden. Die Attribute wagen1, wagen2 und wagen3 nennt man Objektvariablen. Objektvariablen können auf Objekte eines bestimmten Typs zeigen. Im Beispiel oben können sie auf ein beliebiges Objekt vom Typ Kraftwagen zeigen.

Die Beziehung zwischen einer Klasse und ihren Instanziierungen, den Objekten beschreibt man in UML wie folgt:

Erzeugen von Objekten

Die Instanzen von Klassen, also die Objekte haben einen anderen Lebenszyklus als normale Variablen mit einfachen Typen. Instanzen (Objekte) können auch ausserhalb eines Blocks oder einer Methode existieren. Sie liegen nicht auf dem Stapel (Stack). Sie werden dynamisch im (prozess-)globalen Adressraum angelegt und sie bestehen so lange sie von Objektvariablen referenziert werden.

Mit dem new() Operator werden neue Objekte von Klassen angelegt. Beim Anlegen eines Objekts werden alle Attribute durch die Konstruktoren initialisiert. Im Beispiel oben wird ein Konstruktor ohne Übergabeparameter benutzt. In diesem Fall wird der selbst definierte Konstruktor ohne Parameter der Klasse zur Initialisierung aufgerufen. Existiert dieser Konstruktor nicht, so wird ein Standardkonstruktor aufgerufen.

Kraftwagen wagen1 = new Kraftwagen ("M-O-4711)";
Kraftwagen wagen2 = wagen1;
Kraftwagen wagen3 = new Kraftwagen("S-AY-7");

Benutzen der Objektvariablen und Methoden (Punktoperator)

Wie im Beispiel oben gezeigt kann man in der Klasse Fuhrpark mit der Objektvariablen wagen1 auch auf die Attribute und Methoden der Klasse Kraftwagen zugreifen. Hierzu dient der Punktoperator:

      ...
      wagen1.leergewicht = 980.0d;
      wagen1.drucken();
      ...

Man kann mit dem Punkt sowohl auf Attribute (hier leergewicht) zugreifen sowie man Methoden (hier drucken() ) aufrufen kann.

Information Hiding in Java mit Hilfe des Schlüsselworts "private"

Java erlaubt es den Zugriff auf Methoden und Variablen mit Hilfe des Schlüsselworts private zu beschränken. Ist eine Objektvariable oder eine Methode mit private gekennzeichnet, so kann man sie nur innerhalb der Klasse benutzen. Der Zugriff ist dann nur noch über öffentlich zugängliche Methoden möglich.

Mit dem Schlüsselwort public wird der öffentliche Zugriff explizit gewährt. Ein Schlüsselwort das den Zugriff regelt ist protected. Es wird später behandelt.

Im folgenden Beispiel sieht man wie man die Variable neupreis der Klasse Kraftwagen vor dem Zugriff der Klasse Fuhrpark schützt. Die Methode getNeupreis erlaubt den Zugriff von ausserhalb der Klasse.

class Kraftwagen {
   public String nummernschild;
   public double leergewicht;
   private int neupreis;

   public int getNeupreis() { return neupreis;}

   ...
}

Klassenvariablen

• Klassenvariablen sind Variablen die zur Klasse gehören und nicht zu einem einzelnen Objekt.
• Klassenvariablen sind Variablen die für alle Objekte einer Klasse gelten.
• Klassenvariablen können auch ohne die Existenz von Objekten einer Klasse verwendet werden
• Klassenvariablen werden mit dem Schlüsselwort static gekennzeichnet.

Beispiel:

class Fuhrpark{
   static int anzahlFahrzeuge;
   public static void main( String[] args ) {
      int a = Fuhrpark.anzahlFahrzeuge;   // Aufruf ausserhalb der Klasse Fuhrpark
          a = anzahlFahrzeuge;            // Aufruf innerhalb der Klasse Fuhrpark
      ...
   }
}

Hinweis: Die "normalen" nicht mit static gekennzeichneten Attribute einer Klasse nennt man zur Unterscheidung auch Instanzvariablen, da sie nur im Kontext einer Instanz (Objekt) existieren können.

Klassenmethoden

Klassenmethoden werden ebenfalls mit dem Schlüsselwort static gekennzeichnet. Sie können wie normale Methoden im Kontext von Objekten aufgerufen werden. Sie können jedoch auch ohne die Existenz von Objekten benutzt werden. Will man eine Methode einer Klasse ohne eine existierende Instanz aufrufen, muss die Methode vorher mit static gekennzeichnet worden sein.

Im Falle der Klasse Fuhrpark kann man sie zum Beispiel zum Auslesen der Anzahl der Fahrzeuge benutzen:

class Fuhrpark{
   private static int anzahlFahrzeuge;
   public  static int getAnzahlFahrzeuge() {return anzahlFahrzeuge;}
      ...
   }
}

Die main() Methode sowie die Methoden der Klasse Math sind typische Methoden, die mit static deklariert sind, da sie ohne Objektinstanzen auskommen (müssen).

5.3 Übungen

(Lizenz)

5.3.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.3.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:

(a + ib) + (c + id) = (a + c) + i(b + d)
(a + ib) - (c + id) = (a - c) + i(b - d)
(a + ib) * (c + id) = (a*c - b*d) + i(a*d + b*c)
(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:

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.toText()); System.out.println (" b = " + b.toText()); System.out.println (" c = " + c.toText()); System.out.println (" d = " + d.toText()); System.out.println (" e = " + e.toText()); System.out.println (" f = " + f.toText()); } }

Die Klasse Complex soll neben den Methoden add(), sub(), mul(), div() auch eine Methode toText() 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.3.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 de6
    //           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();
        
    }
*/
/* Entfernen zum Testen von Phase 3
    public static void phase3() {
        
        System.out.println(" Phase 3: Jumbo Flugzeugdefekt");
        Flugzeug jumboAlt = new Flugzeug("D-ABYU",360,191000,400000);
        Flugzeug a380Neu = new Flugzeug("D-AIME",560,286000,500000);
        jumboAlt.drucken();
        a380Neu.drucken();
        
        System.out.println("300 Passagiere in JumboAlt einsteigen");
        for (int i=0; i<300; i++) jumboAlt.einsteigen();
        System.out.println("100 Passagiere in Airbus 380 Neu einsteigen");
        for (int i=0; i<100; i++) a380Neu.einsteigen();
        jumboAlt.drucken();
        a380Neu.drucken();
        System.out.println("Jumbo ist defekt. Alle in Airbus umsteigen");
        while (jumboAlt.anzahlPassagiere()> 0) {
            jumboAlt.aussteigen();
            a380Neu.einsteigen();
        }
        System.out.println("Alle umgestiegen. Bereit zum Start");
        jumboAlt.drucken();
        a380Neu.drucken();
    }
*/
/* Entfernen zum Testen von Phase 4    
    public static void phase4() {
        
        System.out.println(" Phase 3: A380 Flugzeugdefekt mit 560 Passagieren");
        Flugzeug jumbo1 = new Flugzeug("D-ABYV",360,191000,400000);
        Flugzeug jumbo2 = new Flugzeug("D-ABYW",360,191000,400000);
        Flugzeug a380Defekt = new Flugzeug("D-AIME",560,286000,500000);
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
        System.out.println("50 Passagiere in Jumbo 1 und 2 einsteigen");
        // 17. Lassen Sie 200 Passagiere in jeden Jumbo einsteigen
        //     Hiermit ist nicht mehr Platz für alle Airbuspassagiere
        //     Testen Sie den Fall der Überbuchung
        for (int i=0; i<50; i++) {
            jumbo1.einsteigen();
            jumbo2.einsteigen();
        }
        System.out.println("560 Passagiere in Airbus 380 (defekt) einsteigen");
        for (int i=0; i<560; i++) a380Defekt.einsteigen();
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
        
        
        System.out.println("Airbus ist defekt. Alle in Jumbos umsteigen");
        // 16. Implementieren Sie das Evakuieren des Airbus
        //     Beide Jumbos sollen falls notwendig benutzt werden
        //     Drucken Sie eine Warnung aus falls Sie einen Passagier
        //     nicht umsteigen lassen.
        
            
        System.out.println("Airbus evakuiert. Bereit zum Start");
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
    }
*/
}

5.3.4 Klassenvariablen (static variables)

Die Übung baut auf der vorherigen Übung aus. Bitte benutzen Sie die Musterlösung falls Sie die vorherige Übung nicht gelöst haben.

Implementieren Sie einen Zähler für jedes Flugzeugobjekt der Klasse Flugzeug welches erzeugt wird.

Empfohlenes Vorgehen:

• Implementieren Sie eine statische, geschützte Variable in der Klasse Flugzeug
• Inkrementieren Sie diese Variable bei jedem Konstruktoraufruf der Klasse Flugzeug
• Erweitern Sie die Methode drucken() und geben Sie die aktuelle Gesamtzahl von Flugzeugen aus
• Implementieren Sie eine öffentliche, statische Methode anzahlFlugzeuge() die den Zähler ausgibt
• Benutzen Sie das existierende Programm in der Klasse FlugzeugTest zum Testen Ihrer Implementierung

Lernziel: Unterscheiden der Variablen die objektspezifisch sind und derer die klassenspezifisch sind.

5.3.5 Überladene Methoden

Die Übung baut auf der vorherigen Übung aus. Bitte benutzen Sie die Musterlösung falls Sie die vorherige Übung nicht gelöst haben.

Implementieren sie überladene Methoden um das Einsteigen und Aussteigen in der Klasse Flugzeug zu vereinfachen. Die neuen Methoden haben

• die gleichen Namen wie die Methoden zum Ein- und Aussteigen eines einzelnen Passagiers,
• sie haben einen Übergabeparameter der die Anzahl der Passagiere zum Ein- und Aussteigen angibt
• es werden nur nicht negative Werte beachtet
• die Operation wird nur ausgeführt falls ALLE Passagiere in der aktuellen Anforderung ein- oder aussteigen können.

 Testen Sie die Implementierung mit der Klasse FlugzeugTest:

• Kopieren Sie die Methoden phase3() und phase4(). Benennen Sie diese um in phase3a(), phase4a()
• Ändern Sie die Implementierung deart, dass anstatt der for-Schleifen einzelne Aufrufe der neuen Methoden durchgeführt werden
  • Tipp: Ändern Sie die Flugzeugkennzeichen. Es werden neue Objekte angelegt. Es ist daher nützlich nicht zwei Flugzeuge mit dem gleichen Kennzeichen zu benutzen.
• Fügen die Methoden phase3a() und phase4a() in die main() Methode ein.
   

5.4 Lösungen

5.4.1 Vektorrechnung

public class Vektor {

   private double x;
    privatedouble y;

    Vektor(double xx, double yy) {
        x = xx;
        y = yy;
        normalisierung();
    }

    public void normalisierung() {
        double laenge = Math.sqrt(x*x+y*y);
        x = x/laenge;
        y = y/laenge;
    }

    public void addition(Vektor v) {
        x = v.x + x;
        y = v.y + y;
        normalisierung();
    }
     public void multi(double skalar) {
        x = x * skalar;
        y = y * skalar;
        // normalisierung();
    }
     public void skalarproduct(Vektor v) {
        x = x * v.x;
        y = y * v.y;
        normalisierung();
    }
     public void drucken() {
     System.out.println("(" + x + "," + y + ")");
     }

}

public class Main {

    public static void main(String[] args) {
        Vektor a = new Vektor(1.0, 2.0);
        Vektor b = new Vektor(2.0, 1.0);
        Vektor c = new Vektor(3.0, 3.0);

        a.drucken();
        b.drucken();
        c.drucken();

        a.addition(b);
        a.drucken();
        a.multi(10);
        a.drucken();
        b.skalarproduct(c);
        b.drucken();
    }
}

5.4.2 Komplexe Zahlen

public class Complex {

    private double re; // Realteil der Zahl
    private double im; // Imaginaerteil der Zahl (i)

    public Complex(double r, double i) {
        re = r;
        im = i;
    }

    public Complex add(Complex z) {
        Complex k = new Complex(re+z.re,im+z.im);
        return k;
    }

    public Complex sub(Complex z) {
        Complex k = new Complex(re-z.re,im-z.im);
        return k;
    }

    public Complex mul(Complex z) {
        Complex k = new Complex(re*z.re-im*z.im,re*z.im+im*z.re);
        return k;
    }

    public Complex div(Complex z) {
        Complex k = new Complex((re*z.re+im*z.im)/(z.im*z.im+z.im*z.im),
                                (im*z.re-im*z.im)/(z.im*z.im+z.im*z.im));
        return k;
    }

     public String toText() {
        String s = "(" + re + " + i" + im + ")";
        return s;
    }
}

5.4.3 Übung: Modellierung der Datenkapselung

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();
    }
        
    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();
    }
    
    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();  
    }
    
    public static void phase3() {
        System.out.println(" Phase 3: Jumbo Flugzeugdefekt");
        Flugzeug jumboAlt = new Flugzeug("D-ABYU",360,191000,400000);
        Flugzeug a380Neu = new Flugzeug("D-AIME",560,286000,500000);
        jumboAlt.drucken();
        a380Neu.drucken();
        
        System.out.println("300 Passagiere in JumboAlt einsteigen");
        for (int i=0; i<300; i++) jumboAlt.einsteigen();
        System.out.println("100 Passagiere in Airbus 380 Neu einsteigen");
        for (int i=0; i<100; i++) a380Neu.einsteigen();
        jumboAlt.drucken();
        a380Neu.drucken();
        System.out.println("Jumbo ist defekt. Alle in Airbus umsteigen");
        while (jumboAlt.anzahlPassagiere()> 0) {
            jumboAlt.aussteigen();
            a380Neu.einsteigen();
        }
        System.out.println("Alle umgestiegen. Bereit zum Start");
        jumboAlt.drucken();
        a380Neu.drucken();
    }

    public static void phase4() {        
        System.out.println(" Phase 4: A380 Flugzeugdefekt mit 560 Passagieren");
        Flugzeug jumbo1 = new Flugzeug("D-ABYV",360,191000,400000);
        Flugzeug jumbo2 = new Flugzeug("D-ABYW",360,191000,400000);
        Flugzeug a380Defekt = new Flugzeug("D-AIME",560,286000,500000);
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
        System.out.println("50 Passagiere in Jumbo 1 und 2 einsteigen");
        // 17. Lassen Sie 200 Passagiere in jeden Jumbo einsteigen
        //     Hiermit ist nicht mehr Platz für alle Airbuspassagiere
        //     Testen Sie den Fall der Überbuchung
        for (int i=0; i<50; i++) {
            jumbo1.einsteigen();
            jumbo2.einsteigen();
        }
        System.out.println("560 Passagiere in Airbus 380 (defekt) einsteigen");
        for (int i=0; i<560; i++) a380Defekt.einsteigen();
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();

        System.out.println("Airbus ist defekt. Alle in Jumbos umsteigen");
        // 16. Implementieren Sie das Evakuieren des Airbus
        //     Beide Jumbos sollen benutzt werden falls notwendig
        //     Drucken Sie eine Warnung aus falls Sie einen Passagier
        //     nicht umsteigen lassen.
        while (a380Defekt.anzahlPassagiere()> 0) {
            if (jumbo1.anzahlPassagiere() < jumbo1.passagierkapazität()) {
                a380Defekt.aussteigen();
                jumbo1.einsteigen();
            }
            else // Jumbo 1 is voll...
            if (jumbo2.anzahlPassagiere() < jumbo2.passagierkapazität()) {
                a380Defekt.aussteigen();
                jumbo2.einsteigen();
            }
            else // Beide Jumbos sind voll
            {
            a380Defekt.aussteigen();
            System.out.println("Ein Passagier bleibt zurück...");
            }
            
        }
        System.out.println("Airbus evakuiert. Bereit zum Start");
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
    }
}

Klasse Flugzeug.java

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)!
    private int maxPassagiere;
    // 2. Privates Attribut zur Verwaltung der aktuellen Pasagiere
    private int passagiere;
    // 3. Leergewicht in privates Attribut ändern
    public int leergewicht; // Ein Attribut vom Type einer Ganzzahl
    // 4. Maximales Gewicht des Flugzeugs
    private int maxgewicht;
    // 5. Öffentliche Konstante für durchschn. Passagiergewicht
    public final static int PASSAGIERGEWICHT = 85;
 
     /**
     * 8. Konstruktor implementieren
     * Konstruktur der Klasse Flugzeug
     * @param kennz     Kennzeichen des Flugzeugs
     * @param kapazitaet Passagierkapazität
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
    public Flugzeug(String kennz, int kapazitaet, int leergew, int maxgew) {
        kennzeichen = kennz;
        // Prüfen ob Kapazität größere Null ist
        if (kapazitaet >= 0) {
            maxPassagiere = kapazitaet;
        } else {
            maxPassagiere = 0;
        }
        // Prüfen ob Leergewicht größer Null ist
        if (leergew > 0) {
            leergewicht = leergew;
        } else {
            leergewicht = 0;
        }
        // Prüfen ob Maximalgewicht größer-gleich Leergeicht ist.
        if (maxgew > leergewicht) {
            maxgewicht = maxgew;
        } else {
            maxgewicht = leergewicht; // Viel Spass...
        }
    }
     
     /**
     * 10. Fügt einen Passagier zum aktuellen Flugzeug hinzu
     */
    public void einsteigen() {
        if (passagiere < maxPassagiere) {
            passagiere++;
        }
    }
 
     /**
     * 11. Entfernt einen Passagier des aktuellen Flugzeugs 
     */
    public void aussteigen() {
        if (passagiere > 0) {
            passagiere--;
        }
    }
    
    /** 
     * 12. Ausgabe der aktuellen Anzahl der Passagiere
     * @return aktuelle Anzahl der Passagiere 
     */
    public int anzahlPassagiere() {return passagiere;}
    
    
    /**
     * 6. Berechnen des aktuellen Gewichts
     * @return aktuelles Gewicht
     */
    public int gewicht() {
    return (leergewicht+ passagiere*PASSAGIERGEWICHT);}
    
    /** 
     * 13. Ausgabe der maximalen Anzahl der Passagiere
     * @return Maximale Anzahl der Passagiere 
     */
    public int passagierkapazitaet() {return maxPassagiere;}

     /**
     * Eine Methode zum Drucken der Attributbelegung des Objekts
     * Die Methode erfordert keine Eingaben. Sie erzeugt keine
     * Ausgaben
     */
    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("*****************************");
    }
}

5.4.4 Lösung: Statische Klassenattribute

Klasse Flugzeug

Erweitert um die statische Variable

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)!
    private int maxPassagiere;
    // 2. Privates Attribut zur Verwaltung der aktuellen Pasagiere
    private int passagiere;
    // 3. Leergewicht in privates Attribut ändern
    public int leergewicht; // Ein Attribut vom Type einer Ganzzahl
    // 4. Maximales Gewicht des Flugzeugs
    private int maxgewicht;
    // 5. Öffentliche Konstante für durchschn. Passagiergewicht
    public final int PASSAGIERGEWICHT = 85;
    
    // Anzahl aller erzeugten Flugzeuge
    private static int objekte;
 
     /**
     * 8. Konstruktor implementieren
     * Konstruktur der Klasse Flugzeug
     * @param kennz     Kennzeichen des Flugzeugs
     * @param kapazitaet Passagierkapazität
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
    public Flugzeug(String kennz, int kapazitaet, int leergew, int maxgew) {
        kennzeichen = kennz;
        objekte++;
        // Prüfen ob Kapazität größere Null ist
        if (kapazitaet >= 0) {
            maxPassagiere = kapazitaet;
        } else {
            maxPassagiere = 0;
        }
        // Prüfen ob Leergewicht größer Null ist
        if (leergew > 0) {
            leergewicht = leergew;
        } else {
            leergewicht = 0;
        }
        // Prüfen ob Maximalgewicht größer-gleich Leergeicht ist.
        if (maxgew > leergewicht) {
            maxgewicht = maxgew;
        } else {
            maxgewicht = leergewicht; // Viel Spass...
        }
    }
     
     /**
     * 10. Fügt einen Passagier zum aktuellen Flugzeug hinzu
     */
    public void einsteigen() {
        if (passagiere < maxPassagiere) {
            passagiere++;
        }
    }
 
     /**
     * 11. Entfernt einen Passagier des aktuellen Flugzeugs 
     */
    public void aussteigen() {
        if (passagiere > 0) {
            passagiere--;
        }
    }
    
    /** 
     * 12. Ausgabe der aktuellen Anzahl der Passagiere
     * @return aktuelle Anzahl der Passagiere 
     */
    public int anzahlPassagiere() {return passagiere;}
    
    
    /**
     * 6. Berechnen des aktuellen Gewichts
     * @return aktuelles Gewicht
     */
    public int gewicht() {
    return (leergewicht+ passagiere*PASSAGIERGEWICHT);}
    
    /** 
     * 13. Ausgabe der maximalen Anzahl der Passagiere
     * @return Maximale Anzahl der Passagiere 
     */
    public int passagierkapazitaet() {return maxPassagiere;}
    
    /**
     * 
     * @return Anzahl aller erzeugten Objekte der Klasse Flugzeug 
     */
    public int anzahlFlugzeuge() {return objekte;}
 
     /**
     * Eine Methode zum Drucken der Attributbelegung des Objekts
     * Die Methode erfordert keine Eingaben. Sie erzeugt keine
     * Ausgaben
     */
    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("******************** " + objekte + " Flugz.");
    }
}

5.4.5 Überladene Methoden

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)!
    private int maxPassagiere;
    // 2. Privates Attribut zur Verwaltung der aktuellen Pasagiere
    private int passagiere;
    // 3. Leergewicht in privates Attribut ändern
    public int leergewicht; // Ein Attribut vom Type einer Ganzzahl
    // 4. Maximales Gewicht des Flugzeugs
    private int maxgewicht;
    // 5. Öffentliche Konstante für durchschn. Passagiergewicht
    public final int PASSAGIERGEWICHT = 85;
    
    // Anzahl aller erzeugten Flugzeuge
    private static int objekte;
 
     /**
     * 8. Konstruktor implementieren
     * Konstruktur der Klasse Flugzeug
     * @param kennz     Kennzeichen des Flugzeugs
     * @param kapazitaet Passagierkapazität
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
    public Flugzeug(String kennz, int kapazitaet, int leergew, int maxgew) {
        kennzeichen = kennz;
        objekte++;
        // Prüfen ob Kapazität größere Null ist
        if (kapazitaet >= 0) {
            maxPassagiere = kapazitaet;
        } else {
            maxPassagiere = 0;
        }
        // Prüfen ob Leergewicht größer Null ist
        if (leergew > 0) {
            leergewicht = leergew;
        } else {
            leergewicht = 0;
        }
        // Prüfen ob Maximalgewicht größer-gleich Leergeicht ist.
        if (maxgew > leergewicht) {
            maxgewicht = maxgew;
        } else {
            maxgewicht = leergewicht; // Viel Spass...
        }
    }
     
     /**
     * 10. Fügt einen Passagier zum aktuellen Flugzeug hinzu
     */
    public void einsteigen() {
        if (passagiere < maxPassagiere) {
            passagiere++;
        }
    }
 
    /**
     * 
     * @param anzahl Anzahl der Passagiere die einsteigen sollen
     */
    public void einsteigen(int anzahl) {
        if ((anzahl >0) && (passagiere+anzahl) <= maxPassagiere) {
            passagiere+= anzahl;
        }
    }
 
     /**
     * 11. Entfernt einen Passagier des aktuellen Flugzeugs 
     */
    public void aussteigen() {
        if (passagiere > 0) {
            passagiere--;
        }
    }
    
    /**
     * 
     * @param anzahl Anzahl der Passagiere die aussteigen sollen
     */
    public void aussteigen(int anzahl) {
        if ((anzahl >0) && (passagiere-anzahl) >=0) {
            passagiere-= anzahl;
        }
    }
    
    /** 
     * 12. Ausgabe der aktuellen Anzahl der Passagiere
     * @return aktuelle Anzahl der Passagiere 
     */
    public int anzahlPassagiere() {return passagiere;}
    
    
    /**
     * 6. Berechnen des aktuellen Gewichts
     * @return aktuelles Gewicht
     */
    public int gewicht() {
    return (leergewicht+ passagiere*PASSAGIERGEWICHT);}
    
    /** 
     * 13. Ausgabe der maximalen Anzahl der Passagiere
     * @return Maximale Anzahl der Passagiere 
     */
    public int passagierkapazitaet() {return maxPassagiere;}
    
    /**
     * 
     * @return Anzahl aller erzeugten Objekte der Klasse Flugzeug 
     */
    public static int anzahlFlugzeuge() {return objekte;}
    
    /**
     * Eine Methode zum Drucken der Attributbelegung des Objekts
     * Die Methode erfordert keine Eingaben. Sie erzeugt keine
     * Ausgaben
     */
    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("******************** " + objekte + " Flugz.");
    }
}

Klasse FlugzeugTest

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();
        phase3a();
        phase4a();
    }
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();
    }
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();
}
public static void phase3() { 
        System.out.println(" Phase 3: Jumbo Flugzeugdefekt");
        Flugzeug jumboAlt = new Flugzeug("D-ABYU", 360, 191000, 400000);
        Flugzeug a380Neu = new Flugzeug("D-AIME", 560, 286000, 500000);
        jumboAlt.drucken();
        a380Neu.drucken();
 
        System.out.println("300 Passagiere in JumboAlt einsteigen");
        for (int i = 0; i < 300; i++) {
            jumboAlt.einsteigen();
        }
        System.out.println("100 Passagiere in Airbus 380 Neu einsteigen");
        for (int i = 0; i < 100; i++) {
            a380Neu.einsteigen();
        }
        jumboAlt.drucken();
        a380Neu.drucken();
        System.out.println("Jumbo ist defekt. Alle in Airbus umsteigen");
        while (jumboAlt.anzahlPassagiere() > 0) {
            jumboAlt.aussteigen();
            a380Neu.einsteigen();
        }
        System.out.println("Alle umgestiegen. Bereit zum Start");
        jumboAlt.drucken();
        a380Neu.drucken();
    }
public static void phase4() {
        System.out.println(" Phase 4: A380 Flugzeugdefekt mit 560 Passagieren");
        Flugzeug jumbo1 = new Flugzeug("D-ABYV", 360, 191000, 400000);
        Flugzeug jumbo2 = new Flugzeug("D-ABYW", 360, 191000, 400000);
        Flugzeug a380Defekt = new Flugzeug("D-AIME", 560, 286000, 500000);
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
        System.out.println("50 Passagiere in Jumbo 1 und 2 einsteigen");
        // 17. Lassen Sie 200 Passagiere in jeden Jumbo einsteigen
        //     Hiermit ist nicht mehr Platz für alle Airbuspassagiere
        //     Testen Sie den Fall der Überbuchung
        for (int i = 0; i < 50; i++) {
            jumbo1.einsteigen();
            jumbo2.einsteigen();
        }
        System.out.println("560 Passagiere in Airbus 380 (defekt) einsteigen");
        for (int i = 0; i < 560; i++) {
            a380Defekt.einsteigen();
        }
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();

        System.out.println("Airbus ist defekt. Alle in Jumbos umsteigen");
        // 16. Implementieren Sie das Evakuieren des Airbus
        //     Beide Jumbos sollen falls notwendig benutzt werden
        //     Drucken Sie eine Warnung aus falls Sie einen Passagier
        //     nicht umsteigen lassen.
        while (a380Defekt.anzahlPassagiere() > 0) {
            if (jumbo1.anzahlPassagiere() < jumbo1.passagierkapazitaet()) {
                a380Defekt.aussteigen();
                jumbo1.einsteigen();
            } else // Jumbo 1 is voll...
            if (jumbo2.anzahlPassagiere() < jumbo2.passagierkapazitaet()) {
                a380Defekt.aussteigen();
                jumbo2.einsteigen();
            } else // Beide Jumbos sind voll
            {
                a380Defekt.aussteigen();
                System.out.println("Ein Passagier bleibt zurück...");
            }
        }
        System.out.println("Airbus evakuiert. Bereit zum Start");
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
    }
   public static void phase3a() {
        System.out.println(" Phase 3a: Jumbo Flugzeugdefekt");
        Flugzeug jumboAlt = new Flugzeug("D-ABYA", 360, 191000, 400000);
        Flugzeug a380Neu = new Flugzeug("D-AIMF", 560, 286000, 500000);
        jumboAlt.drucken();
        a380Neu.drucken();
 
        System.out.println("300 Passagiere in JumboAlt einsteigen");
        jumboAlt.einsteigen(300);
        System.out.println("100 Passagiere in Airbus 380 Neu einsteigen");
        a380Neu.einsteigen(100);
        jumboAlt.drucken();
        a380Neu.drucken();
        System.out.println("Jumbo ist defekt. Alle in Airbus umsteigen");
        int warteRaum = jumbo.anzahlPassagiere();
        jumboAlt.aussteigen(jumbo.anzahlPassagiere());
        // Zu diesem Zeitpunkt hat man ohne warteRaum die Passagiere des
        // Jumbos vergessen!
        a380Neu.einsteigen(warteRaum);
        System.out.println("Alle umgestiegen. Bereit zum Start");
        jumboAlt.drucken();
        a380Neu.drucken();
    }
    public static void phase4a() {
 
        System.out.println(" Phase 4a: A380 Flugzeugdefekt mit 560 Passagieren");
        Flugzeug jumbo1 = new Flugzeug("D-ABYX", 360, 191000, 400000);
        Flugzeug jumbo2 = new Flugzeug("D-ABYY", 360, 191000, 400000);
        Flugzeug a380Defekt = new Flugzeug("D-AIMG", 560, 286000, 500000);
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
        System.out.println("50 Passagiere in Jumbo 1 und 2 einsteigen");
        jumbo1.einsteigen(50);
        jumbo2.einsteigen(50);
        System.out.println("560 Passagiere in Airbus 380 (defekt) einsteigen");
        a380Defekt.einsteigen(560);
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
 
        System.out.println("Airbus ist defekt. Alle in Jumbos umsteigen");
        // 16. Implementieren Sie das Evakuieren des Airbus
        //     Beide Jumbos sollen falls notwendig benutzt werden
        //     Drucken Sie eine Warnung aus falls Sie einen Passagier
        //     nicht umsteigen lassen.
        // Alle aus Airbus in den Warteraum
        int warteRaum = a380.anzahlPassagiere();
        int freiJumbo1 = jumbo1.passagierkapazitaet() - jumbo1.anzahlPassagiere();
        a380Defekt.aussteigen(a380.anzahlPassagiere());
        if (warteRaum <= freiJumbo1) { // Alle Passagiere passen in jumbo1
            jumbo1.einsteigen(warteRaum);
        } else { // Nur ein Teil der Passagiere kann mitgenommen werden
            jumbo1.einsteigen(freiJumbo1);  // Jumbo ist voll
            warteRaum -= freiJumbo1; // warteRaum reduziert
            // Nutzen des zweiten Jumbo...
            int freiJumbo2 = jumbo2.passagierkapazitaet() - jumbo2.anzahlPassagiere();
            if (warteRaum <= freiJumbo2) { // Alle Passagiere passen in jumbo2
                jumbo2.einsteigen(warteRaum);
            } else { // Nur ein Teil der Passagiere kann mitgenommen werden
                jumbo2.einsteigen(freiJumbo2); // jumbo2 ist jetzt voll
                warteRaum -= freiJumbo2; // warteRaum reduziert
                System.out.println(warteRaum + " Passagiere können nicht umbebucht werden.");
            }
        }
        System.out.println("Airbus evakuiert. Bereit zum Start");
        jumbo1.drucken();
        jumbo2.drucken();
        a380Defekt.drucken();
    }
}

5.5 Lernziele

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zu beantworten:

• Der Modifizierer "static" in Javamethoden
• Anzahl von Instanzen (Objekte) erkennen

6.1 Datenkapselung

Datenkapselung ist das Verbergen von Attributen und Methoden durch Einschränkung des Zugriffs von Aussen.

Durch dieses Prinzip ergeben sich beim Entwurf und bei der Wartung von Anwendungen eine Reihe von Vorteilen:

• Divide et impera (Teile und herrsche): Benutzer und Implementierer einer Klasse können unabhängig von einander entwickeln. Der Entwickler muss nur darauf achten die externen Schnittstellen (öffentliche Methoden und Attribute) stabil zu halten.
• Integrität: Unbeabsichtigte Zustandsänderungen werden unterbunden. Beim Setzen eines Attributs müssen eventuell noch andere Operationen durchgeführt werden.

Datenkapselung ist die Voraussetzung zur Implementierung von Schnittstellen:

 Entwickler sollten beim Anwendungsentwurf eine:

• maximale Datenkapselung und
• minimale Schnittstelle

einplanen. Klassen sollten möglichst autark sein und auf möglichst wenig andere Schnittstellen und Klassen zugreifen

Sichtbarkeitssteuerung in Java mit Hilfe der Schlüsselwörter public und private

Java erlaubt den Zugriff auf Methoden und Attribute mit Hilfe der Schlüsselwörter private und public vor dem Namen des Attributs oder Methode zu steuern:

• public: Methoden und Attribute einer Klasse können
  • von Methoden der Klasse selbst genutzt werden
  • von Methoden andere Klassen genutzt werden (externe Benutzung)
• private: Methoden und Attribute einer Klasse können
  • von Methoden der Klasse selbst genutzt werden
  • nicht von Methoden ausserhalb der Klasse genutzt werden

Diese Zugriffssteuerung erlaubt die Implementierung der folgenden Empfehlung

 Attribute und Methoden ohne ein Schlüsselwort werden in Java als public Attribute und Methoden behandelt.

Java verfügt auch über das Schlüsselwort protected welches den Zugriff nur innerhalb eines Pakets erlaubt. Pakete werden erst in der weiterführenden Vorlesung eingeführt werden.

Zugriffssteuerung mit Get- und Set- Methoden

Es ist eine Konvention (und guter Programmierstil) in Java den Zugriff auf private Attribute mit Methoden zu gewähren denen man vor dem Attributnamen get- bzw. set- voranstellt:

class Person() { private String name; public void setName(String n) { name = n;} public String getName() { return name;} }

Dieser Programmierstil bietet eine Reihe von Vorteilen:

• zukünftige Wartungsaufwände und Erweiterungen können leichter implementiert werden, da externe Benutzer ihre Implementierung nicht ändern müssen
  • Die interne Implementierung kann vollständig geändert werden solange die Signatur der öffentlichen Methoden unverändert bleibt.
• get-, set- Methoden erlauben das Implementieren weitergehender Konsistenzprüfungen.

Anmerkung: Laufzeiteinbußen durch solche Trivialmethoden sind in der Regel nicht zu befürchten. Der Java "Just in Time" (JIT) Übersetzer des Laufzeitsystems wird mit hoher Wahrscheinlichkeit solche Methoden zur Laufzeit durch Methoden-inlining wegoptimieren.

6.2 Architekturprinzipien

Trennung der Zuständigkeiten

Trennung von Zuständigkeiten(Separation of Concerns) ist ein Konzept welches auf Datenkapselung aufbaut.

Die Idee besteht darin Zuständigkeiten Klassen zu zuordnen.

Alle Aufgaben die in einen Bereich fallen sollen möglichst von genau einer Klasse implementiert werden. Ziel ist es, dass unabhängige Dinge auch in der Implementierung unabhängig voneinander bleiben. Hierdurch

• sinkt die Gesamtkomplexität und Systeme sind einfacher zu verstehen 
• unterschiedliche Komponenten können unabhängig von einander gepflegt werden
• Fehler in einem Bereich sollen sich möglichst nicht in einem anderen Bereich bemerkbar machen

Ziel ist es Klassen so zu modellieren, dass sie möglichst in sich abgeschlossen sind.

Ein Beispiel hierfür:

• Die Webarchitektur
  • html (Hypertext Markup Language) ist die Seitenbeschreibungssprache
    • css (Cascading Style Sheets) ist die Sprache zur Beschreibung des Layouts der Seite (getrennt vom Inhalt)
  • http ist das Protokoll zur Übertragung der html Seiten (getrennt vom Inhalt)

Entwurfsmuster "Model View Controller" (MVC)

MVC ist ein Entwurfmuster welches aus den folgenden drei Einheiten besteht: Model (Datenmodell) Alle Aspekte die die Daten betreffen (Integrität, Speicherung, Konvertierung etc.) View (Präsentation): typischerweise die Benutzerschnittstelle einer Anwendung mit allen graphischen und interaktiven Komponenten Controller(Programmsteuerung): Die Ablauflogik und Steuerung eines Programmes

Die Einteilung einer Anwendung in die folgenden drei Bereich ist oft vorteilhaft da häufig

• die Benutzerschnittstellen angepasst oder ausgetauscht werden müssen. Das Datenmodell ist dann nicht betroffen. Die Benutzerschnittstelle sollte unabhängig von den anderen Komponenten sein um unterschiedliche Technologien (Web, rich client, OS spezifische Bibliotheken) nutzen zu können
• das Datenmodell auf andere Datenbankprodukte angepasst werden muss ohne das andere Komponenten davon betroffen sein sollen
• die Ablauflogik angepasst werden muss und die Änderungen in den Benutzerschnittstellen minimal gehalten werden sollen

Wichtig ist zu verstehen, dass die drei Komponenten zusammenarbeiten und idealerweise unabhängig voneinander sind. Das Model sollte zum Beispiel auf Aufrufe von View und Controller reagieren, jedoch nicht selbst diese Komponenten aufrufen.

Schichtenarchitektur

Schichtenarchitekuren sind eine andere Ausprägug der "Separation of Concerns".

Java selbst und Javaanwendungen basieren auf dem Schichtenmodell.

6.3 this Referenz

Java verfügt über das Schlüsselwort this um auf die aktuelle Instanz innerhalb eines Methodenrumpfes zu referenzieren. Mit Hilfe der folgenden Notation kann man mit dem Schlüsselwort  this die Methoden und Attribute der eigenen Klasse referenzieren:

• this.Attributname
• this.methodenName()

Hinweis: Die this Referenz ist final. D.h. man kann ihr keinen anderen Wert zuweisen.

Es gibt eine Reihe von typischen Anwendungsfällen:

Einfache Selbstreferenz

Eine Methode einer Klasse soll die Instanz der Klasse einem Konsumenten bekannt machen. Zum Beispiel:

• Selbst hinzufügen bzw. registrieren zu einem Addressbuch innerhalb des Konstruktors der Klasse Person
• Methoden oder Attributaufruf (siehe Aufruf von setNachName(nn) im Konstruktor)
• Rückgabe einer Referenz auf sich selbst (siehe setNachName() )

import class AddressBuch;
class Person {
   private String nachName;
   private String vorName;
...
   public Person (String vn, String nn) {
      this.setNachName(nn);
      vorName  = vn;
      Adressbuch.eintragen(this);
      ...
   }
   public Person setNachName(String nn) {
      nachName = nn;
      return this;
   }
}

Auflösen von Mehrdeutigkeiten

Die this Referenz erlaubt auch das Auflösen von Mehrdeutigkeiten innerhalb eines Namensraumes. Im folgenden Beispiel verdecken die Übergabeparameter nachName, vorName im Konstruktor der Klasse Person die gleichnamigen Attribute:

import class AddressBuch;
class Person {
   private String nachName;
   private String vorName;
...
   public Person (String vorName, String nachName) {
      this.nachName = nachName;
      this.vorName  = vorName;
      Adressbuch.eintragen(this);
      ...
   }
}

Aufruf alternativer Konstruktoren mit this()

Das Schlüsselwort this kann auch als Methodenaufruf this() verwendet werden. Dies erlaubt den Aufruf von Konstruktoren der eigenen Klasse.

Diese Technik ist sehr nützlich um bei mehreren Konstruktoren die Replikation von Code zu vermeiden. Dies geschieht im folgenden Beispiel der Klasse Person() bei einem Konstruktor ohne Parameter. Er benutzt den Konstruktor mit Parameter zum Setzen des Namens indem er einen Standardnamen verwendet:

import class AddressBuch;
class Person {
   private String nachName;
   private String vorName;
...
   public Person (String vorName, String nachName) {
      this.nachName = nachName;
      this.vorName  = vorName;
      Adressbuch.eintragen(this);
      ...
   }
   public Person() {
      /* Rufe den Konstruktor Person(String vorName, String nachName) auf */
      this("John","Doe");
   }
}

Der Vorteil dieser Programmiertechnik liegt in der Vermeidung von Redundanzen. Beim Aufruf des Konstruktors ohne Parameter wird durch den Aufruf des Konstruktors mit Name, Vorname zum Beispiel auch das Addressbuch gepflegt.

6.4 Konstruktoren (2)

Die schon früher angesprochenen Konstruktoren sind eine wichtige Komponente der Datenkapselung, da man mit ihnen eine komplexe und korrekte Initialisierung von Objekten erzwingen kann.

Konstruktoren mit Parametern

Konstruktoren können wie Methoden Übergabeparameter enthalten. Sie werden vom new() Operator erfasst, der dann nach dem Initialisieren der Datenstrukturen den entsprechenden Konstruktor aufruft.

Punkt p1 = new Punkt (3.3, 4.1);

Hier wird ein Konstruktor der Klasse Punkt aufgerufen der folgende Methodenparameter hat

class Punkt {
   private double x;
   private double y;

   public Punkt (double xKoord, double yKoord) {
      x = xKoord;
      y = yKoord;
   }
}

Das Schreiben von Konstruktoren ist optional. Es können mehrere Konstruktoren implementiert werden. Alle Konstruktoren müssen sich jedoch in der Parameterliste unterscheiden. Hier zählt die Reihenfolge und Anzahl der Parametertypen, jedoch nicht der Name der Parametervariablen. Der Übersetzer braucht diese Information um die unterschiedlichen Konstruktoren auszuwählen.

Überladene Konstruktoren

Java unterscheidet die unterschiedlichen Methoden und Konstruktoren an den Eingabelisten der Parameter jedoch nicht am Rückgabeparameter!

Es kann sehr nützlich sein mehrere Konstruktoren zur Initialisierung einer Klasse zur Verfügung zu stellen wie man am Beispiel der Klasse Punkt sehen kann. Die Klasse Punkt erlaubt hier die folgenden Initialisierungsarten:

• Initialisierung mit Nullpunkt(0,0)
• Initialisierung mit x,y Koordinate
• Initialisierung mit den Werten eines anderen Punkts

class Punkt {
   private double x;
   private double y;

   public Punkt (double xKoord, double yKoord) {
      x = xKoord;
      y = yKoord;
      }

   public Punkt (Punkt p) { this(p.x,p.y);}

   public Punkt () { this(0,0); }
}
...
Punkt p1 = new Punkt();        // Initialisierung mit (0,0)
Punkt p2 = new Punkt(1.1,2.2); // Initialisierung mit (1.1,2.2)
Punkt p3 = new Punkt(p2);      // Initialisierung mit (1.1,2.2) durch Punkt p2
...

Der Default-Konstruktor (ohne Parameter) wurde hier selbst implementiert. Er ruft mit Hilfe des Schlüsselworts this den Konstruktor mit den beiden Fliesskommazahlen als Parameter auf. Er initialisiert die Datenstruktur nicht selbst, sondern er delegiert die Initialisierung an einen anderen Konstruktor. Dies ist nicht notwendig aber üblich.

Der Konstruktor mit der Parameterliste Punkt verfährt ähnlich.

Ein optionaler this() Aufruf muss das erste Kommando im Codeblock des Konstruktors sein um die Integrität des mit this() aufgerufenen Konstruktors zu gewährleisten.

Ein Konstruktor ist die erste Methode die ein Objekt initialisiert. Das ist aber nicht mehr für den aufgerufenen Konstruktor geährleistet, wenn dem aufrufenden Konstruktor schon Objektmanipulationen vor dem this() Aufruf erlaubt sind.

Regeln zum Aufruf von Konstruktoren

Java stellt einen Standardkonstruktor (Default-Konstruktor) ohne Parameter zur Verfügung der alle Attribute mit Standardwerten belegt. Implementiert man eigene Konstruktoren gelten die folgenden Regeln für die Benutzer von Konstruktoren:

• Wurde kein Konstruktor implementiert, generiert Java einen Default-Konstruktor ohne Parameter.
• Wird mindestens ein Konstruktor selbst implementiert so generiert Java zur Laufzeit keinen Standardkonstruktor. Benutzer müssen einen der selbst implementierten Konstruktoren verwenden.
  • Wird ein Konstruktor ohne Parameter implementiert wird dieser anstatt eines Standardonstruktor benutzt, da er für den Anwender die gleiche Syntax hat.

Dieses Vorgehen ist notwendig um eine Datenkapselung zu erzwingen.

Bei einer Implementierung mit eigenen Konstruktoren aber ohne einen Default-Konstruktor führt der folgende Konstruktoraufruf zu einem Übersetzungsfehler:

class Punkt {
   private double x;
   private double y;

   public Punkt (double xKoord, double yKoord) {...}
   public Punkt (Punkt p) { this(p.x,p.y);}
...
}

...
Punkt p1 = new Punkt();        // Initialisierung mit Default-Konstruktor ist nicht möglich
...

Erklärung der von Java geforderten Semantik:

• Hat ein Entwickler keinen Konstruktor implementiert, so war ihm die Initialisierung des Objekts nicht wichtig. 
  • Das Objekt wird von einem automatisch generierten Konstruktor mit Nullwerten initialisiert
  • Der Standardkonstruktor wird benutzt wie ein Konstruktor ohne Parameter
• Hat der Entwickler mindestens einen Konstruktor selbst implementiert, so ist eine spezielle Initialisierung des Objekts gewünscht
  • Ein Konsument muss das Objekt mit Hilfe einer der selbstimplementierten Konstruktoren initialisieren
  • Würde das Java einen zusätzlichen Standardkonstruktor generieren könnte man die vom Entwickler gewünschte Initialisierung umgehen. Dies ist nicht gewünscht.

Verbieten des Instanziieren von Objekten einer Klasse

Java bietet die Möglichkeit einen Konstruktor als private zu deklarieren. Hiermit kann niemand ausserhalb der Klasse Instanzen erzeugen. Diese Möglichkeit erlaubt die Anzahl von Instanzen bei Bedarf genau zu kontrollieren. Ein Anwendungsfall ist ist das Benutzen einer statischen Methode und eines privaten Kontruktors:

class Punkt {
   private double x;
   private double y;

   public static Punkt createPunkt (double xKoord, double yKoord) {
      Punkt pp = new Punkt(xKoord, yKoord);
      return pp;
      }

   private Punkt (double xx, double yy) { x=xx; y=yy;}

}
...
Punkt p1 = Punkt.createPunkt(1.1,2.2); 
Punkt p2 = new Punkt(4.4, 5.5);      // Fehler!!
...

Ein anderer Anwendungsfall ist die Benutzung des Entwurfsmodell "Singleton" d.h. einer Klasse von der es genau eine Instanz gibt. Ein Beispiel ist die Klasse Addressbuch:

class Addressbuch {
   private Addressbuch myInstance;

   private Addressbuch() {
      // Initialisiere Addressbuch
      }

   public static Addressbuch getAddressbuch() {
      if (myInstance == null) myInstance = new Addressbuch();
     return myInstance; 
   }
}
...
Addressbuch ab = getAddressbuch ();
...

Mit dieser Implementierung wird beim ersten Anfordern eines Addressbuchs genau einmal ein Addressbuch angelegt.

6.5 Ablauf der Initialisierung einer Klasse

 Begriffsbestimmung:

Beim Erzeugen eines Javaobjekts wie zum Beispiel einer Instanz der Klasse Punkt:

class Punkt { private double x; private double y; public Punkt (double xKoord, double yKoord) { x = xKoord; y = yKoord; } } ... Punkt p2 = new Punkt(1.1,2.2); ... Mit der Variable p2 l laufen die folgenden Schritte beim Aufruf der Programmzeile Punkt p2=new Punkt() ab: Die Referenzvariable p2 wird angelegt und mit dem Wert null belegt Der new Operator der Klasse Punkt wird aufgerufen. Auf dem Java-Heap wird der Platz für ein Objekt der Klasse Punkt zur Verfügung gestellt. Es wird instanziiert. Die Datenfelder des Objekts werden initialisiert. Dies geschieht je nach Typ mit den Belegungen: null, false, 0, 0f etc. Der Methodenblock des entsprechenden Konstruktors wird ausgeführt. Der new Operator gibt die Referenz auf das Objekt zurück welches in p2 gespeichert wird.

6.6 Übungen

Klasse 1: Kraftwagen

Anforderungen

• verwalten von
  • Verkaufspreis
  • Einkaufspreis
  • Kennzeichen
• Schutz der Variablen gegen inkonsistente Änderungen mit Hilfe von Zugriffs- und Auslesemethoden
• Methode drucken() zum Drucken der Attribute eines Wagens
• Zugriffsmethoden (Lesen/Schreiben) die alle drei Attribute kapseln und einfache Konsistenzchecks durchführen
• Implementierung eines Konstruktors der alle drei Parameter erfasst
  • Konsistenzcheck für die Preise: Ist der Verkaufspreis niedriger als der Einkaufspreis so werden die Werte getauscht.
• Zum Testen
  • Methode public static void main(String[] args) Anlegen von mehreren Kraftwagen mit verschiedenen Werten. Testen der Konsistenzprüfungen und Ausgaben der Werte

Klasse 2: Verkaeufer

Anforderungen

• verwalten von mindestens 2 Kraftwagen pro Verkäufer
• Verkäuferattribute und Methoden
  
  • Name
  • bisher gemachter Gewinn
  • gebundene Mittel (Summe aller Einkaufspreise aller Wagen)
  • Verkauf eines Wagens zu gegebenem Preis
    • Austragen aus dem Fahrzeugbestand
    • Pflegen des Gewinn
  • Aufnehmen eines Wagens in den persönlichen Bestand
    • Existierende Wagen im Bestand können ersatzlos ersetzt werden
  • Abfrage der Anzahl der Wagen im Bestand
  • Abfrage eines Kraftwagens aus dem Bestand
  •  Abfrage der gebundenen Mittel
  • Abfrage des geplanten Umsatzes
  • Methode drucken() zum Ausdrucken aller Daten des Verkäufers und aller Daten des Fahrzeugbestands
• Warnen bei Verkauf eines Wagen unter Einkaufspreis (Konsolenausgabe)
• Konstruktor zum Anlegen eines Verkäufers mit einem Namen. Der Namen darf nicht mehr geändert werden.
• Zum Testen:
  • Methode public static void main(String[] args) : Anlegen von drei Verkaeufern mit verschiedenen Werten und Fahrzeugen.
  • Verkauf diverser Fahrzeuge und Abfrage des Status mit Hilfe der Methode drucken()
  • Testen gegen diverse Fehlerfälle beim Verkauf

Klasse 3: Haendler

Anforderungen

• Verwalten von mindestens 3 Verkäufern
• Methoden
  • Einstellen von drei Verkäufern mit gegebenem Namen
  • Geschäftseröffnung mit Einstellen von 6 Fahrzeugen und beliebige Verteilung auf 3 Verkäufer.
  • Zugriff auf jeden der drei Verkäufer
  • gesamter Wert des Fuhrparks
  • gesamter Gewinn
  • gesamter Umsatz
  • verkaufe Fahrzeug für gegebenen Verkäufer (index) und Wagen des Verkäufers (index) zu gegebenen Preis
  • stelle neues Fahrzeug für Verkäufer (index) auf einer bestimmten Position des Verkäufers ein
  • suche des Verkäufers mit den größten Gewinn
  • Methode drucken() zur Ausgabe aller Daten des Unternehmens
• Zum Testen im Hauptprogramm public static void main(String[] args)
  • Ausdruck des Zustandes des gesamten Unternehmens
  • Berechnen der geplanten Erlöse des Fuhrparks
  • Berechnen des gesamten Werts der Flotte
  • Verkäufer mit dem meisten Umsätzen finden
  • Verkauf eines Wagens
  • EInstellen eines neuen Wagens

Hinweis: Die Spezifikation ist nicht vollständig. Das Team muss auf die folgenden Dinge selbst achten:

• Zeitplanung (Integrationstests benötigen viel Zeit!)
• Übergang der Phasen (inklusive notwendige Rückschritte)
• Gegenseitige Überprüfung der Spezifikation und sinngemässe Ergänzung
  • Man darf sich von anderen Klassen zusätzliche Methoden wünschen wenn sinnvoll. Man sollte dann auch zur Implementierung beitragen...
• Gegenseitige Hilfe bei der Implementierung ist erlaubt und erwünscht (Die einzelnen Teilaufgaben können unterschiedlich aufwendig sein!)

6.6.2 Mehrere Konstruktoren

Benutzen Sie das Beispiel der Klasse Flugzeug und der Klasse FlugzeugTest aus der Übung 5.4.5 Überladenen Methode.

Fügen zur Klasse Flugzeug einen weiteren Konstruktor hinzu. Der Konstruktor soll im Gegensatz zum existierenden Konstruktor keinen Parameter zur Passagierkapazität besitzen.

• Berechnen Sie die Passagierkapazität aus der Differenz des Maximal- und Leergewicht. Teilen Sie die Differenz durch das durchschnittliche Passagiergewicht.
• Sie müssen nicht alle Zuweisungen und Kontrollen des alten Konstruktors neu implementieren!
• Rufen Sie den alten Konstruktor mit dem this() Schlüsselwort auf.

Der Dokumentationskommentar zum zu implementierenden Konstruktor

     /**
     * Konstruktur der Klasse Flugzeug
     * Berechnet Passagierkapazität automatisch
     * @param kennz     Kennzeichen des Flugzeugs
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */

Hinweis:

1. Die Konstante PASSAGIERGEWICHT muss bei der Deklaration in der Klasse Flugzeug mit dem Schlüsselwort static versehen werden. Man darf zu diesem Zeitpunkt im Konstruktor noch keine Objektvariablen verwenden.
2. Vorsicht beim Kopieren. Die Klasse Flugzeug befindet sich im Paket block5. Kopieren Sie die Klasse Flugzeug in das Paket block6 oder verwenden Sie import Anweisungen!

Testen Sie das Programm mit der Routine phase6a() der Klasse FlugzeugTest:

package block6;
 
public class FlugzeugTest {
 
    /**
     * Die Methode main() wir zum Starten des Programms benutzt
     * @param args Übergabe von Konsolenparameter. Hier nicht genutzt
     */
 
    public static void main(String[] args) {
        phase6a(); 
        
    }
   
   /**
     * Testen des überladenen Konstruktors
     */
    public static void phase6a() {        
        Flugzeug b737_500 = new Flugzeug("D-ABIAA", 31900, 52000);
        Flugzeug b737_300 = new Flugzeug("D-ABIAB", 12815, 56470);
        System.out.println("Kapazität Boing 737-300: " + b737_300.passagierkapazitaet());
        System.out.println("Kapazität Boing 737-500: " + b737_500.passagierkapazitaet());
    }
}

Warum ist die automatisch berechnete Sitzkapazität der Boing 737 viel zu groß?

Was wurde bei der Modellierung der Klasse nicht berücksichtigt?

6.7 Lösungen

6.7.1 Fuhrparkmanagement

Klasse Kraftwagen

public class Kraftwagen {

    private double verkaufsPreis;
    private double einkaufsPreis;
    private String kennzeichen;

    public Kraftwagen(double ek, double vk, String nummernSchild) {

        // Initialisierung der Variablen mit einfachen Konsistenzprüfungen
        verkaufsPreis = (ek < vk) ? vk : ek;
        einkaufsPreis = (ek < vk) ? ek : vk;
        kennzeichen = nummernSchild;
    }

    public double get_Epreis() {
        return einkaufsPreis;
    }

    public void set_Epreis(double pr) {
        einkaufsPreis = pr;
    }

    public double get_Vpreis() {
        return verkaufsPreis;
    }

    public void set_Vpreis(double pr) {

        verkaufsPreis = pr;
    }

    public String get_kennzeichen() {
        return kennzeichen;
    }

    public void set_kennzeichen(String s) {
        kennzeichen = s;
    }


    public void drucken() {
        System.out.println("Einkaufspreis: " + einkaufsPreis);
        System.out.println("Verkaufspreis: " + verkaufsPreis);
        System.out.println("Kennzeichen: " + kennzeichen);
    }

    public static void Main (String args) {
        
    }
   
}

Klasse Verkaeufer

public class Verkaeufer {

    private String name;
    private double gewinn;
    private double gebundeneMittel;
    private Kraftwagen[] meineWagen;

    public Verkaeufer(String nam) {
        meineWagen = new Kraftwagen[2];
        name = nam;
        gewinn = 0.0;
    }

    public void neuerWagen(int pos, Kraftwagen w) {
        if ((pos >= 0) && (pos < 2)) {
            meineWagen[pos] = w;
        }

    }

    public Kraftwagen imBestand(int pos) {
        if ((pos >= 0) && (pos < 2)) {
            return meineWagen[pos];
        } else {
            return null;
        }
    }

    public Kraftwagen verkaufeFahrzeug(int pos, int erloes) {
        Kraftwagen result;
        if (erloes < meineWagen[pos].get_Vpreis()) {
            System.out.println("Wagen mit Kennzeichen " +
                    meineWagen[pos].get_kennzeichen() +
                    " sollte unter Einkaufspreis verkauft werden.");
            result = null;
        } else {
            gewinn += erloes-meineWagen[pos].get_Epreis();
            result = meineWagen[pos];
            meineWagen[pos] = null; // Wagen gehört nicht mehr zum Bestand
        }
        return result;
    }

    public int fahrzeugeInFlotte() {
        int result = 0;
        int i = 0;
        while (i < meineWagen.length) {
            if (meineWagen[i] != null) {
                result++;
            }
            i++;
        }
        return result;
    }

    public double gebundeneMittel() {
        double result = 0.0;
        for (int i = 0; i < meineWagen.length; i++) {
            if (meineWagen[i] != null) {
                result += meineWagen[i].get_Epreis();
            }
        }
        return result;
    }

    public double geplanterUmsatz() {
        double result = 0.0;
        for (int i = 0; i < meineWagen.length; i++) {
            if (meineWagen[i] != null) {
                result += meineWagen[i].get_Vpreis();
            }
        }
        return result;
    }

    public void drucken() {
        Kraftwagen w1 = imBestand(0);
        Kraftwagen w2 = imBestand(1);

        System.out.println("<*** Verkäufername : " + name + " ***>");
        System.out.println("Erlös bisher: " + gewinn);
        System.out.println("Gebundene Mittel: " + gebundeneMittel());
        System.out.println("Geplanter Umsatz: " + geplanterUmsatz());
        System.out.println("Fahrzeuge in Flotte: " + fahrzeugeInFlotte());
        if (w1 != null) w1.drucken();
        if (w2 != null) w2.drucken();
        System.out.println("<*********************************>");
    }

    public static void main(String[] args) {
        Kraftwagen w1 = new Kraftwagen(20000.00, 30000.00, "M-S 1234");
        Kraftwagen w2 = new Kraftwagen(10000.00, 15000.00, "B-A 5678");
        Kraftwagen w3 = new Kraftwagen(5000.00, 10000.00, "D-T 8901");

        Verkaeufer v1 = new Verkaeufer("Hans");
        v1.neuerWagen(0, w1);
        v1.neuerWagen(1, w2);
        v1.drucken();

        Kraftwagen verkWagen = v1.verkaufeFahrzeug(0, 50000);
        System.out.println("Verkaufter Wagen: " + verkWagen.get_kennzeichen());
        v1.drucken();
    }
}

Klasse Haendler

public class Haendler {
    private Verkaeufer[] team;
    private String name;

    public Haendler(String n ) {
    name = n;
    team = new Verkaeufer[3];
    }

    public void einstellenTeam(String name1, String name2, String name3) {
        team[0] = new Verkaeufer(name1);
        team[1] = new Verkaeufer(name1);
        team[2] = new Verkaeufer(name1);
    }


    public void geschäftsEröffnung(Kraftwagen[] k) {
        team[0].neuerWagen(0, k[0]);
        team[1].neuerWagen(0, k[1]);
        team[2].neuerWagen(0, k[2]);
        team[0].neuerWagen(1, k[3]);
        team[1].neuerWagen(1, k[4]);
        team[2].neuerWagen(1, k[5]);
    }

    public double gesamtGewinn() {
        double g =0;
        for (int i=0; i

6.7.2 Mehrere Konstruktoren

Klasse Flugzeug

package block6;
/**
 * Eine Flugzeug mit Gewicht und Passagieren
 * Am besten mit {@link block6.FlugzeugTest#main FlugzeugTest} testen
 * @author sschneid
 */
public class Flugzeug {
    public String kennzeichen; // Ein Attribut vom Typ einer Zeichenkette
    private int maxPassagiere;
    private int passagiere;
    public int leergewicht; // Ein Attribut vom Type einer Ganzzahl
    private int maxgewicht;
    public static final int PASSAGIERGEWICHT = 85;  
    // Anzahl aller erzeugten Flugzeuge
    private static int objekte;
 
     /**
     *  
     * Konstruktur der Klasse Flugzeug
     * @param kennz     Kennzeichen des Flugzeugs
     * @param kapazitaet Passagierkapazität
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
    public Flugzeug(String kennz, int kapazitaet, int leergew, int maxgew) {
        kennzeichen = kennz;
        objekte++;
        // Prüfen ob Kapazität größere Null ist
        if (kapazitaet >= 0) {
            maxPassagiere = kapazitaet;
        } else {
            maxPassagiere = 0;
        }
        // Prüfen ob Leergewicht größer Null ist
        if (leergew > 0) {
            leergewicht = leergew;
        } else {
            leergewicht = 0;
        }
        // Prüfen ob Maximalgewicht größer-gleich Leergeicht ist.
        if (maxgew > leergewicht) {
            maxgewicht = maxgew;
        } else {
            maxgewicht = leergewicht; // Viel Spass...
        }
    }
    
    /**
     * Konstruktur der Klasse Flugzeug
     * Berechnet Passagierkapazität automatisch
     * @param kennz     Kennzeichen des Flugzeugs
     * @param leergew   Leergewicht in kg
     * @param maxgew    Maximalgewicht in kg
     */
    public Flugzeug(String kennz, int leergew, int maxgew) {
        this(kennz,(maxgew-leergew)/PASSAGIERGEWICHT,leergew,maxgew);
    }
     
     /**
     * Fügt einen Passagier zum aktuellen Flugzeug hinzu
     */
    public void einsteigen() {
        if (passagiere < maxPassagiere) {
            passagiere++;
        }
    }
    
    /**
     * @param anzahl Anzahl der Passagiere die einsteigen sollen
     */
    public void einsteigen(int anzahl) {
        if ((anzahl >0) && (passagiere+anzahl) <= maxPassagiere) {
            passagiere+= anzahl;
        }
    }
 
     /**
     * Entfernt einen Passagier des aktuellen Flugzeugs 
     */
    public void aussteigen() {
        if (passagiere > 0) {
            passagiere--;
        }
    }
    
    /**
     * Entfernt Passagiere des aktuellen Flugzeugs
     * @param anzahl Anzahl der Passagiere die aussteigen sollen
     */
    public void aussteigen(int anzahl) {
        if ((anzahl >0) && (passagiere-anzahl) >=0) {
            passagiere-= anzahl;
        }
    }
    
    /** 
     * Ausgabe der aktuellen Anzahl der Passagiere
     * @return aktuelle Anzahl der Passagiere 
     */
    public int anzahlPassagiere() {return passagiere;}
    
    
    /**
     * Berechnen des aktuellen Gewichts
     * @return aktuelles Gewicht
     */
    public int gewicht() {
    return (leergewicht+ passagiere*PASSAGIERGEWICHT);}
    
    /** 
     * Ausgabe der maximalen Anzahl der Passagiere
     * @return Maximale Anzahl der Passagiere 
     */
    public int passagierkapazitaet() {return maxPassagiere;}
    
    /**
     * 
     * @return Anzahl aller erzeugten Objekte der Klasse Flugzeug 
     */
    public static int anzahlFlugzeuge() {return objekte;}
    
    /**
     * Eine Methode zum Drucken der Attributbelegung des Objekts
     * Die Methode erfordert keine Eingaben. Sie erzeugt keine
     * Ausgaben
     */
    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("******************** " + objekte + " Flugz.");
    }
}

6.8 Lernziele

Lernzielkontrolle

Sie sind in der Lage die folgenden Fragen zu beantworten:

• Konstruktoren, Abfolge
• Schlüsselwort this
• Konstruktoren und Datenkapselung
• Standardkonstruktoren und selbst implementierte Konstruktoren
• Anwendung der Datenkapselung in Java

7.1 Die "null" und "this" Referenz

7.1.1 Die "null" Referenz

Java verfügt über eine "null" Konstante mit deren Wert man Referenzen belegen kann um:

• ein Objekt zu dereferenzieren weil die Anwendungslogik dies erfordert. Das dereferenzierte Objekt wird (irgendwann) gelöscht nachdem niemand mehr auf es zeigt
• Referenzen zu initialisieren.

Im folgenden Beispiel ist zu sehen was geschieht wenn wagen1 und wagen2 mit der null Referenz belegt werden: package block7.reference; public class Main { public static void main(String[] args) { Kraftwagen wagen1 = new Kraftwagen("0-1"); Kraftwagen wagen2 = wagen1; Kraftwagen wagen3 = new Kraftwagen("0-2"); wagen2 = null; wagen3 = null; } } Der Wagen"0-2" wird ein Kandidat zum Löschen. Der Wagen "0-1" wird noch über die Referenz wagen1 referenziert. Enthält eine Referenz eine Null Variable so zeigt sie nicht mehr auf ein Objekt und man kann nicht mehr die Methoden und Datenfelder einer Instanz aufrufen. Mit static deklarierte Methoden und Attribute sind hiervon ausgenommen.

Das Javalaufzeitsystem wird in diesem Fall eine NullPointerException werfen und das Programm beenden. Das folgende Beispiel zeigt den Fall einer unbehandelten Ausnahme sowie die Behandlung einer Ausnahme:

package block7.reference;

public class Main {

public static void main(String[] args) {
    Kraftwagen wagen1 = new Kraftwagen("O-1");
    Kraftwagen wagen2 = wagen1;
    Kraftwagen wagen3 = new Kraftwagen("O-2");
    wagen2 = null;
    wagen3 = null;
        
    try{
        System.out.println(wagen2.getKennzeichen());
        }
    catch (NullPointerException e)
        {
            System.out.println("Variable wagen2 ist eine Null Referenz");
        }
    System.out.println(wagen3.getKennzeichen());
    //Das Programm wurde wegen der unbehandelten Ausnahme beendet
    // Die folgende Zeile nicht nicht mehr erreicht
    System.out.println("Diese Zeile des Programms wird nicht erreicht..");
    }
}

Das Programm wird bei der Ausführung die folgenden Ausgaben auf der Konsole erzeugen;

Variable wagen2 ist eine Null Referenz
Exception in thread "main" java.lang.NullPointerException
	at block7.reference.Main.main(Main.java:20)

Die erste Ausnahme, der Aufruf von wagen2.getKennzeichen() wird mit mit einem try-catch Block aufgefangen. Nach der Behandlung im catch-Block wird die Methode weiter ausgeführt.

Der Aufruf von wagen3.getKennzeichen() wird nicht aufgefangen und führt zu einer Ausnahme in Zeile 20 die das Programm beendet. Ausnahmen und Ausnahmebehandlungen werden in einem späteren Abschnitt behandelt.

7.1.2 Die Eigenreferenz mit dem Schlüsselwort this

Es gibt Fälle in denen man als Parameter einer aufzurufenden Methode einer anderen Klasse einen Zeiger auf die aktuelle Instanz, in deren Methoden man gerade arbeitet, mitgeben möchte. Hierzu dient das Schlüsselwort this. Es kann benutzt werden um auf die aktuelle Instanz zu zeigen, solange man sich nicht in einer static Methode befindet. static Methoden können auch ohne eine existierende Instanz benutzt werden. Eine Objektinstanz existiert daher nicht unbedingt.

Beispiel:

class Person { ... public void sitzPlatzZuweisen (Reservierung r) { ... r.buchung(this); ... } } ... // Beliebige andere Klasse Person p = new Person(); Reservierung buchung; buchung = new Reservierung("LH454","17B"); // Zeitpunkt 1 p.sitzPlatzZuweisen(buchung); // Zeitpunkt 2 ...

7.2 Heap-Größe und Freigabe von Speicher (Garbage Collection)

Die Java Objekte werden innerhalb des Javaprozesses in einem Speicherbereich mit dem Namen "Java Heap" verwaltet. In diesem Speicherbereich werden alle Datenstrukturen mit einer nicht festen Größe verwaltet. Diese Datenstrukturen sind:

• Objekte (Instanzen von Klassen)
• Felder von Basistypen oder Objekten
• Zeichenketten (Sonderfall da Zeichenketten nicht mit dem new Operator angelegt werden müssen)

Dieser Bereich

• hat eine initiale Größe
• kann bis zu einem gegeben Limit wachsen
• zwingt die Java Laufzeitumgebung eine OutOfMemory Ausnahme zu werfen wenn der Speicherbereich voll gelaufen ist.

Java VM Optionen

Optionen zum Heapmanagement(siehe auch Java Optionen (Referenzdokumentation)

• initiale Heapgröße -Xms
• maximale Heapgröße -Xmx
• Protokollieren von Garbagekollektorläufen: -XX:+PrintGC oder -XX:+PrintGCDetails

Beispiel: Starten einer Anwendung Main.class mit 500 Megabytes initialem Heap (Freispeicher), 800 Megabytes maximalem Heap und Protokollierung von Garbagekollektorläufen:

java -Xms500m -Xmx800m -XX:+PrintGC Main

Nicht mehr referenzierte Objekte werden von der JavaVM automatisch, im Hintergrund von einem "Garbage Collector" gelöscht.

Dieser "Garbage Collector" (GC) kann manuell getriggert werden. Dies sollte man aber nicht in einem produktiven Programm durchführen. Der explizit angestossene GC bringt die Anwendung während seiner Arbeit zum Stehen! Automatisch ausgeführte GCs bewirken dies (normalerweise) nicht. Das explizite Anstoßen geschieht mit der statischem Methode System.gc()

System.gc()

Die Konsolenausgabe der Option -XX:+PrintGC sieht wie folgt aus:

[GC 38835K->38906K(63936K), 0.1601889 secs]
[GC 39175K(63936K), 0.0050223 secs]
[GC 52090K->52122K(65856K), 0.1452102 secs]
[GC 65306K->65266K(79040K), 0.1433074 secs]

Sie zeigt an wieviel Speicher die Objekte von der "Garbage Collection" vorher und nachher belegen. Die benötigte Zeit wird ebenfalls angezeigt.

Die Arbeit des "Garbage Collector" und die Füllstände der Pools kann man in den Videos des Java Performance Primer's sehen.

Verwalten von Objekten auf dem Heap

Der Freispeicher (Heap) kann je nach Konfiguration eine konstante Größe haben oder er kann dynamisch bis zu einer vorgegebenen maximalen Größe wachsen. Der Entwickler ist daran interessiert, dass seine Anwendung alle benötigten Objekte im Freispeicher (Heap) verwalten kann. Kann das Javalaufzeitsystem keine neuen Objekte mehr anlegen wird es die Anwendung mit einer OutOfMemoryError Ausnahme beenden.

Dies wird normalerweise durch den Garbage-Collector der automatisch alle Objekte löscht die nicht mehr referenziert werden vermieden.

Beispiel

Im folgenden Programm werden eine Reihe von Personen erzeugt, die über eine Vater und Mutter Beziehung aufeinander referenzieren können.

package dereferenzieren;
 
public class Person {
 
    public Person vater;
    public Person mutter;
 
    public static void main (String[] args ) {
        Person p1 = new Person();
        Person p2 = new Person();
        // Zeitpunkt 1
        p1.vater = p2;
        p2 = null;
        // Zeitpunkt 2
        aufruf(p1);
        //Zeitpunkt 5
    }
 
    public static void aufruf(Person p) {
        Person[] persFeld = new Person[2];
        // Zeitpunkt 3
        persFeld[1] = p;
        persFeld[0] = new Person();
        persFeld[0].vater = new Person();
        persFeld[0].mutter = new Person();
        // Zeitpunkt 4
    }
 
}

Das Hauptprogramm main() erzeugt zwei Instanzen der Klasse Person und ruft dann die Methode aufruf() auf die ein kleines Feld und einige weitere Instanzen erzeugt. 

Hinweis: Im folgenden Beispiel wird ein Feld verwendet. Javafelder werden im Detail im folgenden Kapitel erklärt.

Zum Zeitpunkt 1 sind in der main() Methode die folgenden Objekte erzeugt:

Zum Zeitpunkt 2 wurde in der main() Methode bereits die Vater-Referenz und der ursprüngliche Zeiger p2 mit null dereferenziert.

Zum Zeitpunkt 3 wurde die Methode aufruf() aufgerufen und das Feld persFeld mit zwei Feldern auf dem Heap angelegt.

Zum Zeitpunkt 4 sind drei weitere Personen angelegt worden. Die drei neuen Personen sind über den Index 0 von perrsFeld erreichbar.
Zu diesem Zeitpunkt können alle Objekte auf dem Heap direkt, oder indirekt von Datenstrukturen auf dem Stapel (stack) erreicht werden.

Zum Zeitpunkt 5 wurde die Methode excute() bereits verlassen.Die lokalen Variablen der Methode aufruf() wurden vom Stack gelöscht und stehen nicht mehr zur Verfügung.

Hierdurch können eine Reihe von Instanzen der Klasse Person und das Feld auf dem Heap (Freispeicher) nicht mehr erreicht werden.

Die nicht mehr erreichbaren Objekte sind Müll (Garbarge) geworden und belegen verfügbaren Speicherplatz. Sie werden bei Bedarf vom Garbage-Collector (GC) gelöscht. Der Garbage-Collector wird alle Objekte löschen die vom Stack und statischen Variablen nicht mehr erreichbar sind. Dies hat für die Anwendung keine Implikationen da die Objekte auch von der Anwendung nicht mehr erreichbar sind. 

"Memory Leak"

Objekte die versehentlich bzw. ungewollt referenziert werden können nicht gelöscht werden. Diese Objekte können nach und nach den Heap füllen und zu einem Programmabbruch mangels Hauptspeicher (OutOfMemoryError Ausnahme) führen. Diesen Zustand der früher oder später zum ungewollten Abbruch eines Programms führen kann, nennt man im englischen "Memory Leak" (Speicherleck) da man über die Zeit nutzbaren Speicher verliert wie ein Tank Wasser durch ein Leck verlieren kann.

Modifiziertes Beispiel (Memory Leak)

Ein Speicherleck kann durch eine minimale Änderung im vorhergehenden Beispiel entstehen. Gibt die Methode aufruf() als Ergebnis einen Zeiger auf das Feld von Personen zurück werden die drei Personen und das Feld nicht dereferenziert.

package dereferenzieren;
 
public class Person {
 
    public Person vater;
    public Person mutter;
 
    public static void main (String[] args ) {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.vater = p2;
        p2 = null;
        Person[] f = aufruf(p1);
        //Zeitpunkt 7
    }
 
    public static Person[] aufruf(Person p) {
        Person[] persFeld = new Person[2];
        persFeld[1] = p;
        persFeld[0] = new Person();
        persFeld[0].vater = new Person();
        persFeld[0].mutter = new Person();
        // Zeitpunkt 6
 return persFeld;
    }
}

Zum Zeitpunkt 6 sieht Objektmodell noch aus wie im vorhergehenden Beispiel:

Durch die Rückgabe der Referenz auf das Feld beim Beenden der Methode aufruf(), ist das Feld und die drei Objekte noch vom Stack erreichbar:

Die Variable f in main() referenziert das Feld. Das Feld wiederum referenziert 3 weitere Objekte.

Hier liegt ein Speicherleck nur vor, wenn der Entwickler nicht davon ausgeht, dass das Feld und alle referenzierten Objekte noch erreichbar sind. Ein Speicherleck ist kein Problem des Laufzeitsystems, da das Laufzeitsystem nicht zwischen noch benötigten und nicht mehr benötigten Objekten unterscheiden kann.

Dieses Problem wird vom Javaentwickler durch das Dereferenzieren von Objekten vermieden.

Dereferenzieren von Objekten

Der Javaentwickler muss nicht (und kann nicht) wie in anderen Programmiersprachen nicht mehr benötigte Objekte selbst löschen. Es verbleibt jedoch die Aufgabe sicherzustellen, dass nicht mehr benötigte Objekte nicht mehr referenziert werden um ein vollaufen des Heap zu vermeiden.

Implizites Deferenzieren

Zeigt eine lokale Variable auf ein Objekt, so verschwindet die Referenz auf das Objekt mit dem Verlassen des Blocks in dem die lokale Referenzvariable definiert war.

Im der unten aufgeführten Methode warePrüfen() gibt es zwei Referenzvariablen w und w1 die auf eine Instanz einer Ware zeigen

public void warePrüfen(Ware w) {
   Ware w1 = w;
   ....
}

Beim Aufruf dieser Methode erhöht sich die Anzahl der Referenzen auf eine bestimmte Instanz der Klasse Ware um zwei Referenzen. Da die beiden Variablen aber am Ende des Blocks beim Verlassen der Methode wieder gelöscht werden erniedrigt sich die Anzahl der Referenzen auf ein gegebenes Objekt um zwei.

"Memory Leaks" entstehen daher typischerweise nicht durch lokale Variablen. Werden Methoden jedoch sehr spät verlassen (main() Methode!) werden auch die entsprechenden lokalen Referenzevariablen erst sehr spät gelöscht.

Beispiel

Die erste Variante des Beispiels in dem das Feld auf Personen nur innerhalb des Methodenblocks verwendet wurde ist ein Fall von impliziten Dereferenzieren

Explizites Dereferenzieren

Entwickler sollten Referenzvariablen auf Objekte explizit mit dem null belegen wenn Sie wissen, dass ein Objekt sicher nicht mehr benötigt wird.

o.ref = a-reference;
...
o.ref = null;

Das Derefenzieren einer Referenzvariable und den null Wert ist insbesondere wichtig wenn die Variable ein Attribut einer Klasse ist. Die Lebensdauer des Objekts o ist nicht unbedingt ersichtlich für den Entwickler. Das Setzen der Referenzvariablen o.ref auf null gewährleistet, dass das Objekt auf das mit der Variable a-reference gezeigt wird bei Bedarf gelöscht werden kann.

Beispiel

Das Speicherleck im zweiten Beispiel kann durch zwei verschiedene Änderungen vermieden werden:

1. Möglichkeit: Dereferenzieren  der Variable persFeld in der Methode aufruf()

public static Person[] aufruf(Person p) {
        Person[] persFeld = new Person[2];
        persFeld[1] = p;
        persFeld[0] = new Person();
        persFeld[0].vater = new Person();
        persFeld[0].mutter = new Person();
        // Zeitpunkt 1
        persFeld = null;
    return persFeld;
    }

2. Möglichkeit: Dereferenzieren der Variable f in der main() Methode:

public static void main (String[] args ) {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.vater = p2;
        p2 = null;
        Person[] f = aufruf(p1);
        //Zeitpunkt 2
        f = null;
    }

7.3 Kopieren von Objekten

 Objekte kopieren ist nicht trivial. Die folgende Java-Anweisung

Person p1;
Person p2;
p1 = new Person("John", "Doe");
p2=p1;

dupliziert nicht das erzeugte Objekt, es dupliziert nur die Referenz auf das gleiche Objekt. Dies bedeutet, dass man das Objekt über p1 sowie über p2 erreichen und modifizieren kann.

Das duplizieren von Objekten muss vom Entwickler explizit implementiert werden. Dies geschieht typischer in einem eigen Konstruktor dem "Copy Construktor". Der typische "Copy Constructor" wird wie folgt implementiert:

• Der Eingabeparameter für den Konstruktor ist das zu duplizierende Objekt
• Alle Attribute des zu kopierenden Objekts werden dupliziert

Das Vorgehen beim Kopieren der Objektvariablen obliegt dem Implementierer. Er hat hier zwei Möglichkeiten mit verschiedener Semantik:

• Die Referenz wird umkopiert: Das geklonte Objekt zeigt auf die gleichen Objekte wie das ursprüngliche Objekt. Die referenzierten Objekte werden geteilt.
• Das referenzierte Objekt wird ebenfalls geklont. Jetzt hat das neue Objekt einen exklusiven Satz von Objekten. Hierbei ist zu beachten, dass man bei diesem Vorgang keinen endlos rekursiven Kopiervorgang anstößt.

Das rekursive Kopieren von Objekten wird im Englischen auch als "deep copy" bezeichnet. 
Das einfache wiederbenutzen der Objekte ist im folgenden Beispiel implementiert:

public class Person {
   Person vater;
   Person mutter;
   String name;
...
   public Person (Person orig) {
      vater  = orig.vater;
      mutter = orig.mutter;
      name   = orig.name;
    }
    public Person(String n){
       name = n;
    }
}
...
Person p1 = new Person("John Doe");
p1.mutter = new Person("mum");
p1.vater = new Person("dad");
Person p2 = new Person(p1);

public class Person {
   Person vater;
   Person mutter;
   String name;
...
   public Person (Person orig) {
      if (orig.vater != null)
         vater  = new Person(orig.vater);     
      if (orig.mutter != null)
         mutter = new Person(orig.mutter);
      name   = orig.name;
   }
   public Person(String n){
      name = n;
   }
}
...
Person p1 = new Person("John Doe");
p1.mutter = new Person("mum");
p1.vater  = new Person("dad");
Person p2 = new Person(p1);

7.4 Vergleiche zwischen Objektvariablen

 In Java muss man bei Vergleichen die folgenden, unterschiedlichen Fälle unterscheiden:

• Vergleiche von primitiven Typen
• Vergleiche von Objekten
  • Vergleich auf Identität (gleiche Objektinstanz)
  • Vergleich auf Inhalt (enthalten zwei Instanzen die gleichen Informationen)

Vergleiche mit den == und != Operatoren

Bei primitiven Typen ist der Vergleich recht einfach

int i = 1;
int j = 2;
if (i ==j) ...

Beim Vergleich von Objekten ist hier jedoch Vorsicht geboten. Beispiel:

class Person {
   String name;
   public Person (String nameparam) { ...}
}

   ...
   Person p1 = new Person ("John Doe");
   if (p1 == "John Doe") 
   ...

 p1 ist eine Referenz auf ein Objekt. p1 wird hier direkt mit dem Zeichenliteral "John Doe" verglichen. Dieser Vergleich ist erlaubt, er führt jedoch nicht zum gewünschten Ergebnis. Die Zeichenkette "John Doe" hat einen anderen Typ und ein anderes Objekt als p1.

Vergleiche mit der equals() Methode

In Java erben alle Klassen die Methoden der Basisklasse Object. Alle Klassen erben eine Implementierung der equals() Methode von der Klasse Object.

Diese erlaubt das vergleichen von Objekten wie im folgenden Beispiel

Person p1;
Person p2;
...
if (p1.equals(p2)) ...

Die Methode equals()

• kann auf mit null belegte Referenzen aufgerufen werden (Das Ergebnis ist immer false)
• vergleicht zuerst auf Identität
• vergleicht in der vererbten Implementierung der Klasse Object nur auf Identität
• kann für jede eigene Klasse selbst mit einer komplexen Logik implementiert werden

Vorsicht: Implementiert man diese Methode selbst, dann sollte auch die Methode hashCode() selbst implementiert (überschrieben) werden. Sie wird von vielen Hilfsklassen im Zusammenhang mit equals() gleichzeitig benutzt.

Beispiel:

class Person {
   String name;
...
     public boolean equals(Object obj) {
         boolean result;
         Person target = (Person) obj;
         result = (name.equals(target.name));
     return result;
     }
}

7.5 Das Schlüsselwort "final" und Objektvariablen

 Das Schlüsselwort final erlaubt es zu spezifizieren, dass Variablen nur genau einmal belegt werden dürfen (Siehe Javaspezifikation).

Hiermit kann man erzwingen, dass Variablen später nicht mehr modifiziert werden können.

Siehe Beispiel:

public class Person {
    ...
    final String name;
    ...
    final Adresse geburtsort;

Das Attribut name ist eine Zeichenkette. Man kann genau einmal eine Zeichenkette zuweisen. Eine spätere Änderung ist nicht mehr möglich.

Der Modifizierer final (englisch modifier) hat bei Referenztypen (hier die Klasse Adresse) eine besondere Wirkung:

• Man kann auf genau ein Objekt referenzieren
• Man kann nicht später auf ein anderes Objekt referenzieren
• Man kann jedoch die Attribute des referenzierten Objekts gemäß seiner Implementierung verändern!

7.6 Zeichenketten (Strings)

 Zeichenketten werden in Java mit der Klasse String verwaltet. Sie sind Objekte.

Sie wurden bisher wie die Basistypen Character, Integer oder Float behandelt. Zeichenketten werden jedoch ähnlich wie Referenzen behandelt da Zeichenketten unterschiedlich lang sein können. Man kann Zeichenketten daher nicht die Zahlentypen mit fester Größe einfach in den Speicherbereich eines Objekts einbetten.

Zeichenketten werden bei Bedarf im Hauptspeicher (Heap) angelegt und referenziert. Die Referenz auf die Zeichenkette selbst hat eine konstante Größe.

Zeichenketten können mit einer direkten Zuweisung erzeugt werden. Sie können jedoch auch gleichwertig mit dem new() Operator und dem Konstruktor der Klasse String angelegt werden. Beide Varianten sind nur in der Syntax unterschiedlich. Der einzige Unterschied besteht darin, dass das Objekt "John" schon beim Laden der Klasse angelegt wird. Das Objekt "Doe" wird erst beim Aufruf des Befehls angelegt.

String a = "John"; String b = new String("Doe");

 a sowie b sind Objektreferenzen nicht aber der direkte Datenbehälter!

Zeichenketten(Strings) können einfach mit dem plus "+" Operator verkettet werden. Der plus Operator konvertiert automatisch andere Basistypen in Zeichenketten bevor die neue verkettete Zeichenkette zugewiesen wird:

String a = "Das Ergebnis ist ";
double pi = 3.1415;
String b = "***";
String c = a + pi + b;

Tipp: Die Klasse String verfügt über eine ganze Reihe von hilfreichen Methoden. Hier eine Auswahl:

• (static) valueOf(beliebiger Typ): Konvertierung eines beliebigen Typs (Basistypen, Objekte, Felder etc.) in eine Zeichenkette
• length(): Länge der Zeichenkette
• toLowerCase(): Umwandlung in Kleinbuchstaben
• equalsIgnoreCase(String s): Vergleicht eine gegebene Zeichenkette mit einer Zeichenkette s ohne Groß- und KLeinschreibung zubeachten

Zeichenketten werden von der virtuellen Maschine als unveränderbare ("immutable") Objekte gehandhabt. Sie können daher nicht überschrieben oder verändert werden. Die Implikationen können am folgenden Beispiel gezeigt werden.

Schritt 1: Anlegen der Zeichenketten

String a = "John"; String b = a; String c = " Doe";

Schritt 2: Verkettung und Objektallokation

Eine Verkettung der Zeichenketten mit dem plus Operator ergibt das folgende Speicherabbild c = a + c; Die Variable c zeigt jetzt auf ein neues Objekt. Die Zeichenkette " Doe" ist eventuell nicht mehr referenziert und wird dann vielleicht irgendwann gelöscht. Bei der oben gezeigten Verkettung entstehen typischerweise sehr viele neue Objekte und es werden sehr viele Stringobjekte zum Löschen freigesetzt!

Vergleich

Da ein Objekt vom Typ String eine Referenz auf eine Zeichenkette ist, muss man beim Vergleich von Zeichenketten unterscheiden, ob man die Referenz oder den Inhalt der Zeichenkette vergleichen möchte um Fehler zu vermeiden.

Der Javaübersetzer und das Javalaufzeitsystem speichern Literale wenn möglich nur einmal im Hauptspeicher. Konstante Literale die man zur Übersetzungszeit erkennen kann werden in Referenzen auf ein einziges Objekt zusammengefasst. Dynamisch erzeugte Zeichenketten werden in eigenen Objekten verwaltet. Die genaue Semantik ist in der Java Sprachspezifikation (3.te Version von 2005, Paragraph 3.10.5 String Literals) beschrieben.

Wichtig: Identische Zeichenketten haben nicht unbedingt die gleiche Objektidentität. Ein Vergleich mit Hilfe der Objektidentität ist daher im Normalfall nicht ratsam.

String a = "John";
String b = a;
String c = "John";
String d = "Jo"+"hn"; // Der konstante Ausdruck 
      // wird schon bei der Übersetzung aufgelöst!
String e = new String("John");

Ein Vergleich mit dem == Operator vergleicht nur die Adressen der referenzierten Objekte nicht aber deren Inhalt. Zum Vergleich der Inhalte wird die .equals() Methode benötigt. Siehe

if (a == b) System.out.println(" a und b zeigen auf das gleiche Objekt");
    else System.out.println(" a und b zeigen nicht auf das gleiche Objekt");
if (a == c) System.out.println(" a und c zeigen auf das gleiche Objekt");
    else System.out.println(" a und c zeigen nicht auf das gleiche Objekt");
if (a == d) System.out.println(" a und d zeigen auf das gleiche Objekt");
    else System.out.println(" a und d zeigen nicht auf das gleiche Objekt");
if (a == e) System.out.println(" a und e zeigen auf das gleiche Objekt");
    else System.out.println(" a und e zeigen nicht auf das gleiche Objekt");
if (a.equals(b)) System.out.println(" a und b sind gleiche Zeichenketten");
    else System.out.println(" a und b sind nicht gleiche Zeichenketten");
if (a.equals(c)) System.out.println(" a und c sind gleiche Zeichenketten");
    else System.out.println(" a und c sind nicht gleiche Zeichenketten");
if (a.equals(d)) System.out.println(" a und d sind gleiche Zeichenketten");
   else System.out.println(" a und d sind nicht gleiche Zeichenketten");
if (a.equals(e)) System.out.println(" a und e sind gleiche Zeichenketten");
   else System.out.println(" a und e sind nicht gleiche Zeichenketten");

Führt zum Ergebnis:

 a und b zeigen auf das gleiche Objekt
 a und c zeigen auf das gleiche Objekt
 a und d zeigen auf das gleiche Objekt
 a und e zeigen nicht auf das gleiche Objekt
 a und b sind gleiche Zeichenketten
 a und c sind gleiche Zeichenketten
 a und d sind gleiche Zeichenketten
 a und e sind gleiche Zeichenketten

Zeichenkettenverwaltung im "Stringpool"

Der javac Übersetzer erkennt Literale schon beim Übersetzen einer Klasse und speichert sie nur einmal in der .class Datei mit dem Binärcode. Zur Laufzeit eines Javaprogramms wird die entsprechende Klasse bei der ersten Benutzung dynamisch geladen und die konstanten Zeichenketten (Literale) zu einem "Stringpool" hinzugefügt, wenn sie vorher noch nicht im Stringpool existierten. Dieses Verfahren minimiert den Speicherverbrauch und steigert den Durchsatz da Zeichenketten, in der Regel, kleine Objekte sind, die sonst den Freispeicher (Heap) dauerhaft belegen und fragmentieren.

Der Stringpool ist ein spezialisierter Bereich des Freispeichers. Objekte im allgemeinen Freispeicher und im Stringpool verhalten sich gleich. Der einzige Unterschied besteht darin, dass alle Literale im Stringpool nur genau einmal vorkommen.

Wird eine Zeichenkette dynamisch mit new String() angelegt so wird sie wie ein normales Objekt auf dem Freispeicher (Heap) angelegt und nicht im Stringpool. Die Klasse String hat jedoch eine Methode String.intern() die immer auf das kanonisierte Literal im Stringpool zeigt.

Der Zusammenhang zwischen Stringobjekten im Freispeicher wird durch das folgende Beispielprogramm deutlich:

String a = new String("Test"); String b = a.intern(); String c = new String("Test"); String d = c.intern(); String e = "Test"; if (a == c) System.out.println ("a,c sind die gleichen Objekte"); if (b == d) System.out.println ("b,d sind die gleichen Objekte"+ " im Stringpool"); if (e == d) System.out.println ("e,d sind die gleichen Objekte"+ " im Stringpool"); Ausgabe: b,d sind die gleichen Objekte im Stringpool d,e sind die gleichen Objekte im Stringpool

Effiziente Zeichenverwaltung mit der Klasse Stringbuffer

Die Klasse StringBuffer dient dem effizienten Handhaben von Zeichenketten. Ihre wesentlichen Eigenschaften sind:

• "Threadsave" beim parallelen Ausführen von Threads in einem Javaprogramm werden Zeichenketten nicht versehentlich zerstört. Die Klasse ist hiermit sicher jedoch langsamer als eine nicht threadsichere Klasse (aber immer noch schneller als die Klasse String!)
• Die Zeichenketten sind veränderbar

Wichtige Methoden Methoden der Klasse Stringbuffer sind:

• append(beliebiger Typ): Fügt einen beliebigen Typ in Form einer Zeichenkette am Ende an
• insert(offset, beliebiger Typ): Fügt einen beliebigen Typ an der Stelle offset ein.

Die Klasse StringBuffer verfügt über viele weitere Methoden zur Manipulation von Zeichenketten die in der API Dokumentation beschrieben werden.

Tipp: Seit JDK 5.0 steht die Klasse StringBuilder für Anwendungen die extreme Leistung benötigen zur Verfügung. Sie bietet jedoch keine Synchronisation zwischen Threads.

7.7 Übungen

Hauptprogramm mit folgenden Eigenschaften: Eingabe von n Generationen Eingabe ob explizite GC erfolgen soll Anlegen einer Person p1 mit n Generationen Anstoßen einer Garbage Collection falls gewünscht Anlegen einer neuen Person auf p1 mit n Generationen

Testen des Programms mit den Optionen -Xms -Xmx -XX:+PrintGC

Beispiel: java -Xms64m -Xmx256m -XX:+PrintGC block7.gc.Main

Die bewirkt das Starten einer Javaanwendung mit

• 64 Megabyte initialem Freispeicher (-Xms64m)
• 256 Megabyte initialem Freispeicher (-Xmx256m)
• protokollieren auftretender Garbagecollections (-XX:+PrintGC)

Allgemeine Überlegungen:

• Wie kann man erzwingen das die erste Person und Ihre Vorfahren zum Löschen freigegeben werden?
• Fügen die unten aufgeführte Kontrollmethode zum Auslesen der Speicherdaten an interessanten Stellen aus.

Tipp: Benutzen die folgende Beispielmethode zum Auslesen des Speicherverbrauchs.

Aufgaben

Variieren Sie den initialen, maximalen Speicher sowie die Anzahl der Generationen um

• Implizite GCs zu provozieren, zu vermeiden
• Eine OutOfMemory Ausnahme zu provozieren
• Erhöhen Sie Ihren Speicherverbrauch bis Sie an die Grenzen Ihres Systems kommen. Vorsicht! Nähern Sie sich Ihren Systemgrenzen in kleinen Schritten. Ihr System kann für eine gewisse Zeit durch Überlastung unbenutzbar werden!

Ein Testprogramm

Anbei ein einfaches Testprogramm welches eine Person ohne Vorfahren erzeugt und dann in einer Schleife neue Personen mit immer mehr Vorfahren erzeugt.

Die Konstante mit den Generationen kann bis zu einem Wert von etwa 20 erhöht werden.

package block7.gc;
public class Test {
    /**
     * Zu erzeugende Generationen
     */
    public static int generationen = 3; // Initial testen
    //public static int generationen = 19; // mit -XX:+printGC
    //public static int generationen = 22; // mit -Xmx500m -XX:+printGC
    //public static int generationen = 23; // mit -Xms500m -Xmx1024m -XX:+printGC
    public static void main(String[] args) { 
        Person p;       
        systemStatus();
        for (int i=0; i<= generationen; i++) {
            System.out.println("*** Erzeuge " + i + " Generationen ***");
            // Der alte Personenbaum wird implizit dereferenziert
            p = new Person(i);
            // Verlängern der Laufzeit. Dies erlaubt eine bessere Beobachtung mit jonsole
            // Der alte Vorfahrenbaum wird durch die Zuweisung dereferenziert
            //p = new Person(i);
            //p = new Person(i);
            systemStatus();
            System.out.println("*** Ende. Erzeuge " + i + " Generationen ***");       
        }
    }
    public static void systemStatus(){
        Runtime r = Runtime.getRuntime();
        System.out.println("*** Systemstatus ***");
        System.out.println("* Prozessoren :       " + r.availableProcessors());
        System.out.println("* Freier Speicher:    " + r.freeMemory());
        System.out.println("* Maximaler Speicher: " + r.maxMemory());
        System.out.println("* Gesamter Speicher:  " + r.totalMemory());
        System.out.println("***  Ende Systemstatus ***");
    }
}

7.7.2 Tiefes Kopieren

Benutzen Sie den Quellcode der vorhergehenden Übung.

Schreiben Sie eine Klasse mir dem Namen Adresse und den folgenden Eigenschaften

• öffentliche Attribute ort, plz, strasse, hausnummer
• einen öffentlichen Konstruktor der alle Attribute erfasst
• einen "Copy Constructor" für die Klasse

Erweitern Sie die Klasse Person wie folgt:

• Attribut wohnort vom Typ Adresse
• "Copy Constructor" für die Klasse

Wenden Sie den "Copy Constructor" im Hauptprogramm an.

Optional

Schreiben Sie einen "Copy Constructor" der maximal n Generationen kopiert.

7.7.3 Tiefes Vergleichen

Erweitern Sie die Klassen aus den vorgehenden Beispielen wie folgt:

Klasse Person

• Fügen Sie einen Konstruktor hinzu der Name und alle vier Parameter für einen Geburtsort erfasst
• Implementieren eine equals() Methode die den Vergleich basierend auf Namen und den Inhalten des Geburtsort ausführt

Klasse Adresse

• Implementieren Sie eine  equals() Methode die auf alle Attribute der Klasse prüft

Hauptprogramm

• Entwickeln Sie Testroutinen die die unterschiedlichen möglichen Fälle abprüfen

Tipp Die equals() Methode muss aus Typisierungsgründen ein Objekt vom Typ Object übernehmen. Mit dem unten aufgeführten Codestück kann man testen ob der EIngabeparameter vom gleichen Typ wie das aktuelle Objekt ist. Ist dies nicht der Fall so können die Objekte nicht gleich sein.

public boolean equals(Object obj) {
         ...
         if (this.getClass() == obj.getClass() )

7.7.4 "Walkthrough" Beispiel

Die hier gezeigte Übung wird interaktiv in der Vorlesung entwickelt. Die Arbeitsanweisungen sind im Quellcode enthalten.

Der Ausgangspunkt ist die Klasse Ware und die Klasse Lager die als Hauptprogramm dient:

Ziel ist es eine Lösung zu entwickeln in der die Klasse Ware mit einem Lager verwendet werden kann:

Klasse Ware

package block7;
/**
 * Dies ist die Dokumentation der Klasse Ware. Ware dient zum Verwalten von Gütern
 * mit Preisen und Namen in einem Lager. 
 * @author  Stefan Schneider 
 * @version 1.1
 * @see     Lager
 */
public class Ware {
    /*
     * 7. Anlegen eine Copy Constructor
     * 7.1 Alle Werte des Objekts werden kopiert
     * 7.2 Es wird bei Bedarf eine neue Empfehlung angelegt
     */
    /**
     * Der aktuelle Mehrwertsteuersatz 2010.
     * Er liegt zur Zeit bei {@value}.
     * @since 1.0
     * @version 1.0
     */
    public static final double mws = 0.19;
    private double nettoPreis; //Deklaration
    public boolean halbeMws;
    private String name;
    public Ware empfehlung;
    /**
     * Konstruktor fuer die Klasse Ware
     * @param n der Name der Ware
     * @param np der Nettorpreis
     * @param hmws halber Mehrwertsteuersatz für Ware gueltig
     */
    public Ware(String n, double np, boolean hmws) {
        name = n;
        nettoPreis = np;
        halbeMws = hmws;
    }
    /**
     * Liefert den Namen einer Ware zurueck.
     * @return    Name der Ware
     */
    public String get_name() {
        return name;    }
    /**     * Setzen eines neuen Nettopreis
     * @param npr   der neue Nettopreis
     */
    public void set_nettoPreis(double npr) {
        nettoPreis = npr;
    }
    /**
     * Ausdrucken aller Werte auf der Konsole
     */
    public void drucken() { drucken(0); }
    /**
     * Ausdrucken aller Werte auf der Konsole mit vorgebener Einrueckung
     * für Empfehlungen
     * @param einruecken eingerueckte Stellen für Empfehlungen
     */    
    private void drucken(int einruecken) {
        String leerStellen = "";
        for (int i = 0; i < einruecken; i++) {
            leerStellen = leerStellen + " ";
        }
        System.out.println(leerStellen + "Name: " + name);
        System.out.println(leerStellen + "netto: " + nettoPreis);
        System.out.println(leerStellen + "Brutto: " + bruttoPreis());
        System.out.println(leerStellen + "Halbe Mws:" + halbeMws);
        if (empfehlung != null) { // Empfohlene Bücher werden eingerückt
            empfehlung.drucken(einruecken + 2);
        }
    }
    /**
     * Ausgabe des Nettopreis
     * @return der Nettopreis
     */
    public double nettoPreis() {
        return nettoPreis;    }
    /**
     * Ausgabe des Bruttopreis
     * @return der Bruttopreis
     */
    public double bruttoPreis() {
        double bp; //temporaere Variable; keine Klassenvariable
        if (halbeMws) {
            bp = Math.round(nettoPreis * (mws / 2 + 1) * 100) / 100;
        } else {
            bp = Math.round(nettoPreis * (mws + 1) * 100) / 100;
        }
        return bp;
    }
}

Klasse Lager 

package block7;
/** * Die Klasse Lager verwaltet eine bestimmte Anzahl von Waren 
 * @author sschneid
 */
public class Lager {
    /*     * Aufgaben
     * 1. Verwalten von n Waren in einem Feld
     * 1.1 Deklarieren eines privaten Feldes
     * 1.2 Zugriffsmethoden zum Setzen und Auslesen des Feldes
     * 2. Implementieren eines Konstruktors der das Lager
     *           für n Waren initialisiert
     * 3. Anlegen einer Methode die zu einem existierenden Buch
     *       n verkettete Empfehlungen erzeugt
     * 4. Erzeugung eines Singletons zum Erzeugen genau eines Lagers
     * 5. Anlegen einer neuen Klasse MainLager
     * 5.1 Umkopieren der main() Methode aus der Klasse Lager in die Klasse
     *      MainLager.main()
     * 8. Testen des Copy Constructors
     * 8.1 Belegen Sie die ersten 500 Lagerpositionen mit Waren
     * 8.2 Klonen Sie die ersten 500 Lagerpositionen und belegen Sie die
     *     folgenden 500 Lagerpositionen mit Ihnen
     * 8.3 Löschen Sie Ihr Lager indem Sie alle Postionen mit null belegen
     * 8.4 Implementieren Sie eine Schleife die einige Minuten läuft
     *      und testen Sie den Speicherverbrauch mit jconsole oder
     */
     public static void main(String[] args) {
        Ware ware1 = new Ware("Zeitung",12.12,true);
        System.out.println("Ware1 ohne Empfehlung:");
        ware1.drucken();
        double p = ware1.nettoPreis();
        Ware ware2 = new Ware("Potter Bd1",31.12,false);
        Ware ersterBand = ware2;
        ware1.empfehlung= ware2;
        System.out.println("Ware1 mit Empfehlung:");
        ware1.drucken();
        // Erzeugen einer Ware mit 7 verketteten Empfehlungen
        Ware ware3;
        Ware hp1=ware2; 
        for (int i=2; i<= 7; i++) {
            ware3 = new Ware("Potter Bd" + i,31.25+i,false);
            ware2.empfehlung = ware3;
            ware2 = ware3;
        }
        System.out.println("Alle Harry Potter Baende drucken");
        hp1.drucken();
 }
}

Klasse MainLager

package block7;
/**
 * * Eine Hilfsklasse zur Implementierung eines Hauptprogramms
 *
 * @author sschneid
 * @version 1.0
 */
public class MainLager {
    /*
     * 6. Testen der Klasse Main 
     * 6.1 Aufruf des Singleton der Klasse Lager 
     * 6.2 Einfügen zweier Waren 
     * 6.3 Drucken zweier Waren
     */
    public static void main(String[] args) {
        Ware ware1 = new Ware("Zeitung", 12.12, true);
        ware1.drucken();
        double p = ware1.nettoPreis();
        Ware ware2 = new Ware("Potter Band 1", 31.12, false);
        Ware ersterBand = ware2;
        Ware ware3;
        for (int i = 2; i <= 7; i++) {
            ware3 = new Ware("Potter Band" + i, 31.12, false);
            ware2.empfehlung = ware3;
            ware2 = ware3;
        }
    }
}

7.8 Lösungen

7.8.1 Referenzieren, Derefenzieren und GC

Klasse Main

Das folgende Programm wird wie folgt gestartet

java block7.gc.Main 3 gc

Es erwartet zwei Kommandozeilenargumente. Das erste Argument beschreibt die Anzahl der zu erzeugenden Generationen.

Das zweite Argument is optional. Steht hier GC wird eine System Garbarge Collection angestoßen

package block7.gc;

public class Main {

    /**
    * Auslesen von Systemparametern
    */
    public static void systemStatus(){
        Runtime r = Runtime.getRuntime();
        System.out.println("*** System Status ***");
        System.out.println("Prozessoren :       " + r.availableProcessors());
        System.out.println("Freier Speicher:    " + r.freeMemory());
        System.out.println("Maximaler Speicher: " + r.maxMemory());
        System.out.println("Gesamter Speicher:  " + r.totalMemory());
        System.out.println("***  ***");
    }

    public static void main(String[] args) {
        int vorfahren = 0;
        boolean systemCollection=false;
        Person p1;

        systemStatus();
        // Parsen des ersten Arguments
        // Diese Zeichenkette enthält die ANzahl der Generationen
        if (args.length > 0 ) { // Gibt es ein erstes Argument?
        try { vorfahren = Integer.parseInt(args[0]);}
        catch (NumberFormatException e) {
            System.err.println("Argument muss Ganzzahl sein");
            System.exit(1);
            }
        }
        // Auslesen des zweiten Arguments
        // Steht hier die Zeichenkette GC in Klein- oder Grossschreibung
        if (args.length > 1 ) // Gibt es ein zweites Argument
            systemCollection = ((args[1].equalsIgnoreCase("gc"));

        p1 = new Person(vorfahren);
        //p1 = null;
        System.out.println();
        System.out.println("Erster Schritt erledigt: " + Person.zaehler +
                " Instanzen erzeugt");
        systemStatus();
        if (systemCollection)  {
            System.out.println("Starte System GC");
            System.gc();
        }
        p1 = new Person(vorfahren);
        System.out.println();
        System.out.println("Zweiter Schritt erledigt: " + Person.zaehler +
                " Instanzen erzeugt");
        systemStatus();
    }

}

Klasse Person

package block7.gc;
public class Person {
    Person vater;
    Person mutter;
    static int zaehler=0;

    public Person (int vorfahren)
    {
        if ( vorfahren>0) {
            vater = new Person(vorfahren-1);
            mutter = new Person(vorfahren-1);
        }
        zaehler++;
        if (zaehler%1000 == 0) System.out.print(".");

    }
}

7.8.2 "Copy Constructor" Klasse

Klasse Main

package block7.gc;

public class Main {

    public static void systemStatus(){
        Runtime r = Runtime.getRuntime();
        System.out.println("*** System Status ***");
        System.out.println("Prozessoren :       " + r.availableProcessors());
        System.out.println("Freier Speicher:    " + r.freeMemory());
        System.out.println("Maximaler Speicher: " + r.maxMemory());
        System.out.println("Gesamter Speicher:  " + r.totalMemory());
        System.out.println("***  ***");
    }

    public static void main(String[] args) {
        int vorfahren = 0;
        boolean systemCollection=false;
        Person p1;

        systemStatus();
        if (args.length > 0 ) {
        try { vorfahren   = Integer.parseInt(args[0]);}
        catch (NumberFormatException e) {
            System.err.println("Argument muss Ganzzahl sein");
            System.exit(1);
            }
        }
        if (args.length > 1 )
            systemCollection = (args[1].equalsIgnoreCase("gc"));

        p1 = new Person(vorfahren);
        //p1 = null;
        System.out.println();
        System.out.println("Erster Schritt erledigt: " + Person.zaehler +
                " Instanzen erzeugt");
        systemStatus();
        if (systemCollection)  {
            System.out.println("Starte System GC");
            System.gc();
        }
        p1 = new Person(p1);
        System.out.println();
        System.out.println("Zweiter Schritt erledigt: " + Person.zaehler +
                " Instanzen erzeugt");
        systemStatus();
    }

}

Klasse Adresse

package block7.gc;

public class Adresse {
    public String ort;
    public String plz;
    public String strasse;
    public String hausnr;

    public Adresse (String o, String p, String s, String h){
        ort     = o;
        plz     = p;
        strasse = s;
        hausnr  = h;
    }

    public Adresse (Adresse orig) {
        ort     = orig.ort;
        plz     = orig.plz;
        strasse = orig.strasse;
        hausnr  = orig.hausnr;
    }
}

Klasse Person

package block7.gc;
public class Person {
    Person vater;
    Person mutter;
    String name;
    Adresse wohnort;
    static int zaehler=0;

    public Person (int vorfahren)
    {
        if ( vorfahren>0) {
            vater  = new Person(vorfahren-1);
            mutter = new Person(vorfahren-1);
        }
        wohnort = new Adresse("Berlin", "10117","Platz der Republik","1");
        name = "John Doe";
        zaehler++;
        if (zaehler%1000 == 0) System.out.print(".");
    }

    public Person (Person orig) {
         if (orig.vater != null) vater  = new Person(orig.vater);
         if (orig.mutter != null) mutter = new Person(orig.mutter);
         if (orig.wohnort != null) wohnort = new Adresse(orig.wohnort);
         name   = orig.name;
         zaehler++;
         if (zaehler%1000 == 0) System.out.print(".");
    }
}

Optional: "Copy Constructor mit begrenzter Kopiertiefe

    public Person (Person orig, int vorfahren) {
        if (vorfahren > 0) {
            if (orig.vater != null)
                vater  = new Person(orig.vater,  vorfahren-1);
            if (orig.mutter != null)
                mutter = new Person(orig.mutter, vorfahren-1);
            }
        if (orig.wohnort != null) wohnort = new Adresse(orig.wohnort);
        name   = orig.name;
        zaehler++;
        if (zaehler%1000 == 0) System.out.print(".");
    }

7.8.3 Tiefes Vergleichen Klasse Person

Klasse Person

class Person {
...
    public Person (String name1, String gort, String gplz,
            String gstrasse, String gnr){
        name = name1;
        geburtsort = new Adresse(gort,gplz,gstrasse,gnr);
        zaehler++;
        if (zaehler%1000 == 0) System.out.print(".");
   }
...
 public boolean equals(Object obj) {
         Person target;
         // Type checking is optional for this level of skills
         if (this.getClass() == obj.getClass() ) {
            target = (Person) obj;                
            return (name.equals(target.name) && 
                      (geburtsort.equals(target.geburtsort)));
            }
         else return false;
     }
...
}

Klasse Adresse

public boolean equals(Object obj) {
         Adresse target;
         // Type checking is optional for this level of skills
         if (this.getClass() == obj.getClass() ) {
            target = (Adresse) obj;                
            return (ort.equals(target.ort) && 
                plz.equals(target.plz) &&
                strasse.equals(target.strasse) &&
                hausnr.equals(target.hausnr));
            }
         else return false;
}

7.8.4 Ware/Lager Beispiel

Klasse MainLager

package block7;
/**
 * * Eine Hilfsklasse zur Implementierung eines Hauptprogramms
 *
 * @author sschneid
 * @version 1.1
 */
public class MainLager {
    /*
     * 5. Anlegen einer neuen Klasse MainLager 
     * 5.1 Umkopieren der main() Methode
     * aus der Klasse Lager in die Klasse MainLager.main()
     */
    /*
     * 8. Testen des Copy Constructors 
     * 8.1 Belegen Sie die ersten 500
     * Lagerpositionen mit Waren 
     * 8.2 Klonen Sie die ersten 500 Lagerpositionen und belegen Sie die 
     *      folgenden 500 Lagerpositionen mit Ihnen 
     * 8.3 Löschen Sie Ihr Lager indem Sie alle Postionen mit null belegen 
     * 8.4 Implementieren Sie eine Schleife die einige Minuten läuft und testen Sie
     *      den Speicherverbrauch mit jconsole und jps
     */
public static void main(String[] args) {
        Lager lager1 = Lager.dasLager();
        int position;
        for (int j = 0; j < 100000; j++) {
            for (int i = 0; i < 500; i++) {
                position = lager1.einlagern(new Ware("Buch der Zahl " + i, 2 * i, false));
                //System.out.println("Ware auf Position" + position + " eingelagert");
            }
            for (int i = 0; i < 500; i++) {
                position = lager1.einlagern(new Ware(lager1.holen(i)));
                //System.out.println("Ware auf Position" + position + " eingelagert");
            }
            lager1.ausraeumen();
System.out.println("Schleife " + j + " von 100000");
        }
    }
}

Klasse Ware

package block7.loesung;
/**
 * Dies ist die Dokumentation der Klasse Ware. Ware dient zum Verwalten von Gütern
 * mit Preisen und Namen in einem Lager. 
 * @author  Stefan Schneider 
 * @version 1.1
 * @see     Lager
 */
public class Ware {
    /**
     * Der aktuelle Mehrwertsteuersatz 2010.
     * Er liegt zur Zeit bei {@value}.
     */    
    public static final double mws = 0.19;
    private double nettoPreis; //Deklaration
    public boolean halbeMws;
    private String name;
    public Ware empfehlung;
    /**
     * Konstruktor fuer die Klasse Ware
     * @param n der Name der Ware
     * @param np der Nettorpreis
     * @param hmws halber Mehrwertsteuersatz für Ware gueltig
     */
    public Ware(String n, double np, boolean hmws) {
        name = n;
        nettoPreis = np;
        halbeMws = hmws;
    }
    /*
     * 7. Anlegen eine Copy Constructor
     * 7.1 Alle Werte des Objekts werden kopiert
     * 7.2 Es wird bei Bedarf eine neue Empfehlung angelegt
     */
    /**
     * Copy-Konstruktor fuer die Klasse Ware
     * @param w die zu klonende Ware
     */
    public Ware(Ware w) {
        name = w.name;
        nettoPreis = w.nettoPreis;
        halbeMws = w.halbeMws;
        if (w.empfehlung != null)
            empfehlung = new Ware(w.empfehlung);
    }
    /**
     * Liefert den Namen einer Ware zurueck.
     * @return    Name der Ware
     */    public String get_name() {
        return name;    }
    /**     * Setzen eines neuen Nettopreis
     * @param npr   der neue Nettopreis
     */
    public void set_nettoPreis(double npr) {
        nettoPreis = npr;
    }
    /**
     * Ausdrucken aller Werte auf der Konsole
     */
    public void drucken() {
        System.out.println("Name: " + name);
        System.out.println("netto: " + nettoPreis);
        System.out.println("Brutto: " + bruttoPreis());
        System.out.println("Halbe Mws:" + halbeMws);
        if (empfehlung != null) {
            empfehlung.drucken(2);
        }
    }
    /**
     * Ausdrucken aller Werte auf der Konsole mit vorgebener Einrueckung
     * für Empfehlungen
     * @param einruecken eingerueckte Stellen für Empfehlungen
     */    public void drucken(int einruecken) {
        String leerStellen = "";
        for (int i = 0; i < einruecken; i++) {
            leerStellen = leerStellen + " ";
        }
        System.out.println(leerStellen + "Name: " + name);
        System.out.println(leerStellen + "netto: " + nettoPreis);
        System.out.println(leerStellen + "Brutto: " + bruttoPreis());
        System.out.println(leerStellen + "Halbe Mws:" + halbeMws);
        if (empfehlung != null) {
            empfehlung.drucken(einruecken + 2);
        }
    }
    /**
     * Ausgabe des Nettopreis
     * @return der Nettopreis
     */    public double nettoPreis() {
        return nettoPreis;    }
    /**
     * Ausgabe des Bruttopreis
     * @return der Bruttopreis
     */    public double bruttoPreis() {
        double bp; //temporaere Variable; keine Klassenvariable
        if (halbeMws) {
            bp = Math.round(nettoPreis * (mws / 2 + 1) * 100) / 100;
        } else {
            bp = Math.round(nettoPreis * (mws + 1) * 100) / 100;
        }
        return bp;
    }
}

Klasse Lager

package block7;
/** * Die Klasse Lager verwaltet eine bestimmte Anzahl von Waren 
 * @author sschneid
 * @version 1.1
 */
public class Lager {
    /*     
     * Aufgaben
     * 1. Verwalten von n Waren in einem Feld
     * 1.1 Deklarieren eines privaten Feldes
     */
         private int lagerGroesse = 1000;
         private Ware[] warenLager;
         
     // 1.2 Zugriffsmethoden zum Setzen und Auslesen des Feldes
      public Ware holen(int i) {
          if ((i<0) || (i>=lagerGroesse)) return null;
          else return warenLager[i];
          }
 
      public int einlagern(Ware w) {
          int i=0;
          while ((i<lagerGroesse) && (warenLager[i] != null)) i++;
          if (i<lagerGroesse) {
              warenLager[i] = w;
              return i;
          }
          else return -1;
      }
// 1.3 Methode zum Ausräumen des Lagers
    public void ausraeumen() {
        for (int i=0; i<lagerGroesse; i++) warenLager[i]=null;
    }
   
     /* 
     * 2. Implementieren eines Konstruktors der das Lager
     *           für n Waren initialisiert
     */
    private Lager() {
        // Es wird ein Feld von Referenzen auf Waren angelegt
        // Es werden keine Waren angelegt!
        warenLager = new Ware[lagerGroesse];
    }
     /*
     * 3. Anlegen einer Methode die zu einem existierenden Buch
     *       n verkettete Empfehlungen erzeugt
     * 4. Erzeugung eines Singletons zum Erzeugen genau eines Lagers
     */
    private static Lager meinLager;  // Eine Objektvariable die auf das Lager zeigt
    static public Lager dasLager() {
        if (meinLager== null) meinLager= new Lager();
        return meinLager;
        }
     /*
     * 5. Anlegen einer neuen Klasse MainLager
     * 5.1 Umkopieren der main() Methode aus der Klasse Lager in die Klasse
     *      MainLager.main()
     * 8. Testen des Copy Constructors
     * 8.1 Belegen Sie die ersten 500 Lagerpositionen mit Waren
     * 8.2 Klonen Sie die ersten 500 Lagerpositionen und belegen Sie die
     *     folgenden 500 Lagerpositionen mit Ihnen
     * 8.3 Löschen Sie Ihr Lager indem Sie alle Postionen mit null belegen
     * 8.4 Implementieren Sie eine Schleife die einige Minuten läuft
     *      und testen Sie den Speicherverbrauch mit jconsole oder
     */
     public static void main(String[] args) {
        Ware ware1 = new Ware("Zeitung",12.12,true);
        System.out.println("Ware1 ohne Empfehlung:");
        ware1.drucken();
        double p = ware1.nettoPreis();
        Ware ware2 = new Ware("Potter Bd1",31.12,false);
        Ware ersterBand = ware2;
        ware1.empfehlung= ware2;
        System.out.println("Ware1 mit Empfehlung:");
        ware1.drucken();
        // Erzeugen einer Ware mit 10 verketteten Empfehlungen
        Ware ware3;
        Ware hp1=ware2; 
        for (int i=2; i<= 7; i++) {
            ware3 = new Ware("Potter Bd" + i,31.25+i,false);
            ware2.empfehlung = ware3;
            ware2 = ware3;
        }
        System.out.println("Alle Harry Potter Baende drucken");
        hp1.drucken();
        // ersterBand.drucken(); 
    }
 }