Ganz grob: Es wird Zahl mit einem int-Parameter aufgerufen. Es wird dann ein das boolean-Array zweierKomplement erzeugt. Wir sollen den Konstruktor und die Addiere-Methode schreiben. Im Code unten ist die Methode 'private boolean[] dualZahl(long positiveZahl)' schon vorgegeben, die sollen wir im Konstruktor auch benutzen.
Meine Fragen:
Warum der ganze Umstand mit dem boolean-Array in der Aufgabe, warum keine Einsen und Nullen? Nur zur allgemeinen Verwirrung? Die Methode dualZahl funktioniert ja nur bei positiven Zahlen. Für negative muss ich ja erstmal invertieren und plus eins rechnen. Dafür muss ich aus true und false ja erstmal wieder 1 und 0 machen (oder etwa nicht) und wenn ja, wo mache ich das am besten? Ich gehe davon aus, dass ich nur dort wo IHR CODE steht, auch Code schreiben soll.
Ich fange mal an:
Die Aufgabe:
Ausgabe soll etwa so sein:
Meine Fragen:
Warum der ganze Umstand mit dem boolean-Array in der Aufgabe, warum keine Einsen und Nullen? Nur zur allgemeinen Verwirrung? Die Methode dualZahl funktioniert ja nur bei positiven Zahlen. Für negative muss ich ja erstmal invertieren und plus eins rechnen. Dafür muss ich aus true und false ja erstmal wieder 1 und 0 machen (oder etwa nicht) und wenn ja, wo mache ich das am besten? Ich gehe davon aus, dass ich nur dort wo IHR CODE steht, auch Code schreiben soll.
Ich fange mal an:
Die Aufgabe:
Code:
public class Zahl {
/* Attribute */
private boolean[] zweierKomplement;
/* oeffentliche Methoden */
// Konstruktor
public Zahl(int wert) {
[COLOR="Red"]/* IHR CODE */[/COLOR]
}
// Getter
public boolean[] getZweierKomplement() {
return zweierKomplement;
}
// gibt zweierKomplement mit Einsen und Nullen als String zurueck
public String toString() {
String str = "";
for (int i=31; i>=0; i--)
if (zweierKomplement[i])
str += "1 ";
else
str += "0 ";
return str;
}
// addiert die Zahl andere zum Attribut zweierKomplement des Objekts,
// die resultierende Zahl wird in zweierKomplement gespeichert
public void addiere(Zahl andere) {
[COLOR="red"]/* IHR CODE */[/COLOR]
}
// berechnet fuer eine positive Zahl die entsprechende Dualzahl in 32 Bit
// der Parameter ist vom Typ long, damit auch 2^31 uebergeben werden kann,
// was keine int-Zahl ist
// Annahme: Parameter positiveZahl ist nichtnegativ.
private boolean[] dualZahl(long positiveZahl) {
// Array dual wird erzeugt und damit seine Elemente mit false
// initialisiert (Default-Wert von Boolean);
// (generell sollte man aber explizit initialisieren!)
boolean[] dual = new boolean[32]; // Typ int hat 32 Bit
int index = 0; // gibt die Stelle im Array an, die berechnet wird
// laufe durch alle Stellen gemaess der bekannten Umrechnung von
// Dezimalzahl in Basis 2
while (positiveZahl > 0){
// aktuelle Stelle im Dualsystem durch Modulo 2
if (positiveZahl % 2 == 1) {
dual[index] = true;
}
else {
dual[index] = false;
}
// neuen Wert durch Division mit 2
positiveZahl /= 2;
index++;
}
return dual;
}
}
Code:
public class TestZahl {
public static void main(String[] argumente) {
// Erzeuge Objekte der Klasse Zahl
// gebe die jeweiligen 2er Komplement-Darstellungen aus
// Verwende einige Male beispielhaft die addiere-Methode
Zahl z1 = new Zahl(-256);
Zahl z2 = new Zahl(512);
System.out.println("z1: " + z1); // verwendet z1.toString()
System.out.println("z2: " + z2);
System.out.println("Addiere z1 zu z2");
z2.addiere(z1);
System.out.println("z2: " + z2);
System.out.println();
Zahl z3 = new Zahl((int) (-Math.pow(2,31)));
System.out.println("z3: " + z3);
System.out.println("Addiere -1 zu z3");
z3.addiere(new Zahl(-1));
System.out.println("z3: " + z3);
System.out.println();
Zahl z4 = new Zahl((int) (Math.pow(2,31)-1));
System.out.println("z4: " + z4);
System.out.println("Addiere 1 zu z4");
z4.addiere(new Zahl(1));
System.out.println("z4: " + z4);
}
}Ausgabe soll etwa so sein:
Code:
z1: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
z2: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
Addiere z1 zu z2
z2: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
z3: 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Addiere -1 zu z3
Warnung: Unterlauf
z3: 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
z4: 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
Addiere 1 zu z4
Warnung: Ueberlauf
z4: 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
