Skip to Content

2.4 Übungen

Duke als Boxer

(Lizenz)

2.4.1 Übung: Zuweisungen und Typen 

Erstellen Sie folgende Java-Applikation (Name "Calc"):
  • Deklarieren Sie in der main() Routine Variablen mit unterschiedlichen Datentypen (z.B. int, longshort, float).
  • Initialisieren Sie die Variablen mit geeigneten Werten.
  • Führen Sie mit den Variablen folgende arithmetischen Operationen aus:
    • Addition einer Konstanten zu einer int-Variablen,
    • Multiplikation einer int-Variablen mit einer Konstanten,
    • Subtraktion zweier Variablen unterschiedlichen Datentyps (int, short),
    • Division einer int-Variablen durch eine Konstante,
    • Multiplikation zweier Variablen (davon eine vom Typ "float").
Geben Sie die Variablenwerte jeweils aus.
Zu beantworten:
  • 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

Welche der folgenden Symbole sind gültige Variablennamen in Java?
Begründen Sie Ihre Antwort.
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

Gegeben seien folgende Variablendeklarationen in Java:
long a = 3;
int b = 4;
short c = 5;
byte d = 6;
Welche der folgenden Zuweisungen sind in Java erlaubt?
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

Schreiben Sie ein Java-Programm, das eine Anzahl von Sekunden einliest und in
die Anzahl von Stunden, Minuten und Sekunden umrechnet.
Testen Sie Ihr Programm mit vernünftigen Eingabewerten, z. B. mit 0, 59, 60,
100, 3600 und 4000.
 
Beispiel: Die Eingabe 1234 soll zur Ausgabe von 0 : 20 : 34 führen.

2.4.8 Übung: Polynomberechnung

Schreiben Sie ein Javaprogramm, das die Koeffizienten a, b, c, d sowie den Wert x des Polynoms
y = a * x3  + b * x2  + c * x + d
einliest und das Ergebnis y ausgibt.

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
Schreiben Sie ein Java-Progamm, das ∏ mit dieser Formel annähert.
Bemerkung: Die Reihe konvergiert nur seht langsam gegen ∏ .

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
analoge Uhr, initial Zustand Analoge Uhr als Lösung nit korrekten Zeigern

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:
  • Beachten Sie die Eingabe- und Ausgabeparameter der trigonometrischen Funktionen! Die Berechnungen erfolgen mit Fließkommazahlen. Das Ergebnis muss aber eine ganzzahlige Pixelposition sein.
  • Ganzzahloperation runden immer ab. Erwägen Sie die Benutzung einer Fließkommahilfsvariable
  • Benutzen nur double als Fließkommatyp. Die Operationen der Mathematikbibliothek beruhen auf dem Typ double. Sie vermeiden so unnötige Konvertierungen zu float Typen.

Klasse Uhr

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

 

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

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

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

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

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

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

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

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

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

Klasse Zeiger

Implementieren sie

import static java.lang.Math.*;

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

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

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

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

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

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

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

Hilfestellung

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

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

Die X-Koordinate eines Zeigers berechnet sich wie folgt

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

Die Y-Koordinate eines Zeigers berechnet sich wie folgt

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

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

2.4.12 Gruppenübung

Je eine Gruppe bearbeitet die folgenden Typen:

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

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

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

Zeitvorgaben

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

 2.4.13 Airline

Vorbereitung

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

Aufgabe:

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

Klasse Flugzeug

Im block2 anlegen!

package Airline.block2;

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

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

public String toString() {return kennzeichen;}

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

}

Klasse Flughafen

package Airline.block2;

package Airline.block2;

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

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

pad.name = "Paderborn";
pad.treibstoffLager = 1000000;

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

pad.gate1 = lh1;

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

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

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


}
}

 



book | by Dr. Radut