Um mich auf die bevorstehende JAVA Klausur vorzubereiten, hab ich versucht mal die etwas älteren Prüfungen durch zuarbeiten und lasse euch am Ergebnis teilhaben.
Welche Ausgaben auf dem Bildschirm erzeugt folgende Klasse beim Ausführen?
package aufg1;
public class Aufg1 {
public static void main(String[] args) {
int i = Integer.MAX_VALUE; // entspricht Wert 2147483647
System.out.println("A:" + ((i+1) + i));
float f = Float.MAX_VALUE; // entspricht Wert 3.4028235E38
System.out.println("B:" + ( 2*f - f));
i = 1;
System.out.println("C:" + (i<<=2) + " " + i);
i = 7;
System.out.println("D:" + (i & 0xFF));
System.out.println("E:" + (i | 0xFF));
i = 4;
System.out.print("F:");
while (i-- > 0) {
System.out.print("+");
}
System.out.println();
String first = new String("Hallo");
String second = new String("Hallo");
System.out.println("G:" + (first==second));
System.out.println("H:" + (first.equals(second)));
}
}
Ergebnis: A:-1 B:Infinity C:4 4 D:7 E:255 F:++++ G:false H:true
Es sei folgende rekursive Methode gegeben:
package aufg2;
public class Aufg2a {
public static void main(String[] args) {
printRec(5);
}
public static void printRec(int n) {
if (n == 0)
return;
for (int j = 1; j <= n; j++)
System.out.print(j);
System.out.println();
printRec(n - 1);
}
}
a) Welches Muster erzeugt der Aufruf printRec(5) auf dem Bildschirm?
12345 1234 123 12 112345
b) Was passiert, wenn Sie versuchen, einen Aufruf der Form printRec(3.14) zu tätigen?
1. Compiler wird einen Fehler ausgeben 2. Die rekursive Methode erwartet einen Integer Wert, es wird allerdings ein Double übergeben
c) Was erfolgt, wenn die Methode printRec() mit einer negativen ganzen Zahl als aktuellem Parameter aufgerufen wird? Wie würden Sie die Implementierung der Methode verändern, um diesen Effekt zu verhindern?
Die Methode bricht nicht mehr ab, d.h. sie wird unendlich lange laufen bis der minimale Integer Wert erreicht wird und dann weiter laufen bis sie endlich bei 0 ankommt.
package aufg2;
public class Aufg2c {
public static void main(String[] args) {
printRec(-1);
}
public static void printRec(int n) {
if (n == 0 || n <= 0)
return;
for (int j = 1; j <= n; j++)
System.out.print(j);
System.out.println();
printRec(n - 1);
}
}
d) Wandeln Sie die rekursive Implementierung von printRec() unter dem nachfolgenden Methodenkopf in eine iterative Implementierung um.
package aufg2;
public class Aufg2d {
public static void main(String[] args) {
printIt(9);
}
public static void printIt(int n) {
if (n == 0 || n <= 0)
return;
for (int i = 1-n; i <= n; i++) {
for (int j = 1; j <= n; j++) {
System.out.print(j);
}
n = n-1;
System.out.println();
}
}
}
e) Modifizieren Sie die Implementierung von printRec() unter Benutzung des nachfolgenden Rahmens so, dass in dem erzeugten Muster nur noch Kleinbuchstaben statt Ziffern erscheinen, und zwar ein a an Stelle von 1, b an Stelle von 2, …. (Es kann dabei davon ausgegangen werden, dass die Methode nur für einstellig Zahlen 0, …, 9 als aktueller Parameter aufgerufen wird).
package aufg2;
public class Aufg2e {
public static void main(String[] args) {
printRec(9);
}
public static void printRec(int n) {
if (n == 0 || n <= 0)
return;
char c = 'a';
for (int j = 1; j <= n; j++) {
System.out.print(((char)c));
c++;
}
System.out.println();
printRec(n - 1);
}
}
Auf Pythagoras geht der Begriff der vollkommenen Zahl (perfect number) zurück. Eine vollkommene Zahl ist eine positive ganze Zahl, deren Wert gleich der Summe seiner Teiler ist. Die kleinste vollkommene Zahl ist 6 (
Schreiben Sie eine Methode (Klassen- oder Objektmethode?), die als Parameter eine ganze Zahl übergeben bekommt und als Wahrheitswert zurückliefert, ob die übergebene Zahl eine vollkommene Zahl ist.
public static boolean perfectNumber(int n) {
boolean perfNum = false;
int sumSoFar = 0, sumOfDivisors, i;
for (i = 1; i < n; i = i + 1) {
if (n%i == 0) {
sumSoFar = sumSoFar + i;
}
}
sumOfDivisors = sumSoFar;
if (n == sumOfDivisors) {
System.out.println( "The value " + n + " is PERFECT" );
perfNum = true;
} else {
System.out.println( "The value " + n + " is NOT PERFECT" );
}
return perfNum;
}
Es soll der Speiseplan eines Restaurants in Java-Code abgebildet werden. Das nachfolgende Klassendiagramm enthält fragmentarisch den zugehörigen Entwurf.
>a) Definieren Sie die Java-Klasse Gericht. Es soll die Attribute erhalten, die in obigem Klassendiagramm angegeben sind. Das Attribut preis speichert den Preis des Gerichts in Cent. Sein Wert soll über eine get()-Methode abgefragt und über eine set()-Methode verändert werden können. Die Werte der restlichen Attribute sollen unveränderlich sein. Die Werte des Attributs typ sollen wie im Diagramm durch ein auch zu definierendes enum Essenstyp abgedeckt werden (oder, falls Sie damit nichts anfangen können, ersatzweise über symbolische Konstanten in einer eigenen Klasse Essenstyp).
Ergänzen Sie die Klasse Gericht durch einen entsprechenden Konstruktor und überschreiben Sie die toString()-Methode der Klasse Object geeignet, so dass dadurch alle Attributwerte wiedergegeben werden können.
package aufg4;
public class Gericht {
public final String name;
public final Essenstyp typ;
public final boolean fleischlos;
private int preis;
public Gericht(String name, Essenstyp typ, boolean fleischlos, int preis) {
this.name = name;
this.typ = typ;
this.fleischlos = fleischlos;
this.preis = preis;
}
public void setPreis(int preis) {
this.preis = preis;
}
public int getPreis() {
return preis;
}
public String toString() {
String s = "Name: " + name + "\nEssenstyp: " + typ.toString() +
"\nFleischlos: " + fleischlos + "\nPreis: " + preis + "cent";
return s;
}
}
package aufg4;
public enum Essenstyp {
VORSPEISE, HAUPTGERICHT, NACHSPEISE;
}
b) Realisieren Sie nun die Klasse Speisekarte. Die Assoziation gerichte im Klassendiagramm soll über ein Array fester Länge abgedeckt werden (Die Länge wird im Konstruktor übergeben). Realisieren Sie diesen Konstruktor sowie die Methoden addGericht() (fügt ein Gericht zur Speisekarte hinzu) sowie getBilligstes() (sucht das billigste Gericht vom übergebenen Typ heraus).
package aufg4;
public class Speisekarte {
private Gericht[] gerichte;
private int z = 0;
public Speisekarte(int n) {
gerichte = new Gericht[n];
}
public void addGericht(Gericht gericht) {
for (int i = 0; i < gerichte.length -1; i++) {
if (gerichte[i] == null) {
gerichte[i] = gericht;
}
if (z < gerichte.length) {
gerichte[z++] = gericht;
}
}
}
public Gericht getBilligstes(Essenstyp typ) {
Gericht bG = null, aG;
for (int i = 0; i < z; i++) {
if (gerichte[i].typ != typ)
continue;
aG = gerichte[i];
if (bG == null) {
bG = aG;
continue;
}
if (aG.getPreis() < bG.getPreis()) {
bG = aG;
}
}
return bG;
}
}
c) Definieren Sie eine Test-Methode, in der eine Speisekarte und zwei Gerichte von gleichem Typ aber unterschiedlichem Preis instanziert und die Gerichte zur Speisekarte hinzugefügt werden. Anschließend soll die Speisekarte auf das billigste Gericht dieses Typs abgefragt werden und dessen Daten auf die Konsole ausgegeben werden.
package aufg4;
public class Test {
public static void main(String[] args) {
Speisekarte sk = new Speisekarte(2);
Gericht knoedel = new Gericht("Knödel", Essenstyp.HAUPTGERICHT, true, 50);
Gericht wurst = new Gericht("Wurst", Essenstyp.HAUPTGERICHT, false, 40);
sk.addGericht(knoedel);
sk.addGericht(wurst);
System.out.println(sk.getBilligstes(knoedel.typ).toString());
}
}