[Jujiro]

Hallo,

auch ich werde von der Uni genötigt, Aufgaben mit Java zu lösen...

In diesem Falle sollen wir eine Klasse Bit erstellen, und diesen "hocharbeiten", bis wir mit der Klasse einen VierBitAddierer haben.

Beim ausführen von TestAddierer, der uns vorgegeben wurde, funktioniert alles vom Halbaddierer, dann kommt es zu folgender Fehlermeldung:

Exception in thread "main" java.lang.NullPointerException
at Volladdierer.add(Voladdierer.java:10)
at TestAddierer.printVolladdierer(TestAddierer.java:6 5)
at TestAddierer.main(TestAddierer.java:11)

Ich habe mich schon erkundigt, weiß aber nach wie vor nicht, wo mein Fehler liegt und hoffe hier auf Hilfe.

Meine Programme sehen so aus(Ich hoffe, es verschreckt niemanden

public class Bit
{
// Private variablen 
 private boolean gesetzt; 

public Bit(boolean gesetzt)
    {
    this.gesetzt=gesetzt;
    }

public Bit(int gesetzt)
    {
    if(gesetzt==1)
    this.gesetzt=true;
    else
    this.gesetzt=false;
    }
 
//gibt zuruck, ob das Bit gesetzt ist
 public boolean istGesetzt()
    {
     return this.gesetzt;
    }
//gibt 1 zuruck, wenn das Bit gesetzt ist, andernfalls 0
 public int getValue()
    {
    int a=0;
     if (gesetzt)
        a= 1;
     return a;
     }
 
}

public class Gatter
{

 static Bit AND(Bit x, Bit y)
    {
    boolean a=false;
    int b = (x.getValue() * y.getValue());
    if(b==1)
        {
        a=true;
        }
    Bit z = new Bit(a);
     return z;
     }
static Bit OR(Bit x, Bit y)
    {
    boolean a=false;
    int b=(x.getValue() + y.getValue());
    if(b>=1)
        {
        a=true;
        }
    Bit z = new Bit(a);
     return z;
     }
 static Bit XOR(Bit x, Bit y)
    {
    boolean a=false;
    int b=(x.getValue() + y.getValue());
    if(b==1)
        {
        a=true;
        }
    Bit z = new Bit(a);
     return z;
     }
 
}

public class Halbaddierer
{
private Bit uebertrag;

    public Bit add(Bit x, Bit y)
    {
        uebertrag= Gatter.AND(x,y);
        return (Gatter.XOR(x,y));
    }

    public Bit getUebertrag()
    {
    return uebertrag;
    }    
    
}

public class Volladdierer
{
    private Halbaddierer ha1;
    private Halbaddierer ha2;
    private Bit uebertrag;

    public Bit add(Bit x, Bit y, Bit c_in)
    {
        Bit a = (Gatter.OR(ha1.add(x,y),ha2.add(ha1.getUebertrag(), c_in)));
        return a;
    }
    public Bit getUebertrag()
    {
        return uebertrag;
    }
    
}

public class VierBitAddierer
{
    private Volladdierer va1;
    private Volladdierer va2;
    private Volladdierer va3;
    private Volladdierer va4;

    public Bit[] add(Bit[] bits1, Bit[] bits2)
    {
        Bit[] a = new Bit[4];
        Bit z = new Bit(false);
        a[0]=va1.add(bits1[0],bits2[0],z);
        a[0]=va2.add(bits1[1],bits2[1],va1.getUebertrag());
        a[0]=va3.add(bits1[2],bits2[2],va2.getUebertrag());
        a[0]=va4.add(bits1[3],bits2[3],va3.getUebertrag());
        return a;
    }
}

Und als letztes die besagte vorgegebene Datei:

public class TestAddierer {
    
    public static void main(String[] args) {
        System.out.println("Wahrheitstabelle Halbaddierer:");
        printHalbaddierer();
        System.out.println();
        
        System.out.println("Wahrheitstabelle Volladdierer:");
        printVolladdierer();
        System.out.println();
        
        System.out.println("Additionen mit dem 4-Bit-Addierer:");
        Bit[] bits1 = {new Bit(0), new Bit(1), new Bit(1), new Bit(0)}; //0110
        Bit[] bits2 = {new Bit(0), new Bit(0), new Bit(1), new Bit(1)}; //0011
        
        printVierBitAddierer(bits1, bits2);
        printVierBitAddierer(bits1, bits1);
        printVierBitAddierer(bits2, bits2);
        //Addieren Sie weitere Zahlen...
    }
    
    
    
    /**
     * Diese Methode benutzt den von Ihnen implementierten Halbaddierer und 
     * gibt die entsprechende Wahrheitstabelle auf dem Bildschirm aus.
     */
    public static void printHalbaddierer() {
        int wht[][] =  {{0, 0},
                        {0, 1},
                        {1, 0}, 
                        {1, 1}};
        
        Halbaddierer h = new Halbaddierer();
        System.out.println("  a__b__|__s__cout");
        for (int i = 0; i < wht.length; i++) {
            Bit s     = h.add(new Bit(wht[i][0]), new Bit(wht[i][1]));
            Bit carry = h.getUebertrag();
            System.out.println("  " + wht[i][0] + "  " + wht[i][1] + "  |  " 
                    + s.getValue() + "   " + carry.getValue());
        }
    }
    
    
    
    /**
     * Diese Methode benutzt den von Ihnen implementierten Volladdierer und 
     * gibt die entsprechende Wahrheitstabelle auf dem Bildschirm aus.
     */
    public static void printVolladdierer() {
        int wht[][] =  {{0, 0, 0},
                        {0, 0, 1},
                        {0, 1, 0}, 
                        {0, 1, 1},
                        {1, 0, 0},
                        {1, 0, 1},
                        {1, 1, 0}, 
                        {1, 1, 1}};
        
        Volladdierer v = new Volladdierer();
        System.out.println("  a__b_cin_|__s__cout");
        for (int i = 0; i < wht.length; i++) {
            Bit s     = v.add(new Bit(wht[i][0]), new Bit(wht[i][1]), new Bit(wht[i][2]));
            Bit carry = v.getUebertrag();
            System.out.println("  " + wht[i][0] + "  " + wht[i][1] + "  " + wht[i][2] + "  |  " 
                    + s.getValue() + "   " + carry.getValue());
        }
    }
    
    
    
    /**
     * Diese Methode benutzt den von Ihnen implementierten VierBitAddierer, um 
     * die uebergebenen Binaerzahlen zahl1 und zahl2 zu addieren und gibt das 
     * Ergebnis auf dem Bildschirm aus.
     */
    public static void printVierBitAddierer(Bit[] zahl1, Bit[] zahl2) {
        VierBitAddierer v4 = new VierBitAddierer();
        System.out.print("  ");
        for (int i = 0; i < zahl1.length; i++) {
            System.out.print(zahl1[i].getValue());
        }
        System.out.print(" + ");
        for (int i = 0; i < zahl2.length; i++) {
            System.out.print(zahl2[i].getValue());
        }
        System.out.print(" = ");
        
        Bit[] res = v4.add(zahl1, zahl2);
        for (int i = 0; i < res.length; i++) {
            System.out.print(res[i].getValue());
        }
        System.out.println();
    }

    
}

[Sekundentakt]

Hallo und willkommen im Forum!

Ich habe Deinen Code gerade ein wenig überflogen, konnte aber auf Anhieb nichts entdecken.
Ich schätze, dass es das Beste wäre, wenn Du deinen eigenen Code besser auskommentieren würdest, damit auch Fremde durchblicken, was Du da treibst. ;)

Meine Empfehlung:
Kopiere den Code deiner Main-Methode und speicher ihn mal irgendwo ab.
Anschließend schmeißt Du bei Deiner jetzigen Main-Methode alles raus, was nichts mit dem Volladdierer zutun hat.

Womit entwickelst Du? Befinden sich die Dateien im selben Package?

[Jujiro]

Danke für die freundliche Begrüßung :)

Stimmt...Kommentare habe ich völlig vergessen, werde ich gleich nachholen :)

Ich schreib alles im Texteditor und kompiliere durch den befehl "javac" in der Eingabeaufforderung...von allem Anderen wurde uns abgeraten

Die Dateien sind alle im selben Package.

P.S.: kommentierter Code kommt gleich^^

[Sekundentakt]

Hast Du denn irgendwelche Codezeilen am Anfang der Datei weggelassen?

Ich vermisse nämlich den Aufruf von "package" in deinen Dateien.

[Jujiro]

Also die Dateien sind im selben Ordner...das hat bislang immer für die Aufgaben gereicht...

Belehrst du mich eines Besseren? :)

[Sekundentakt]

Es gehört m.E. auf jeden Fall zu jeder sauberen Klasse. :)
Dadurch wird die Zusammengehörigkeit dieser Klassen ausgedrückt - das hätte eine Entwicklungsumgebung - nebenbei bemerkt - schon längst angeprangert!
Wenn Du die Grundlagen drauf hast, ist entwickeln ohne IDE ein Krampf ;).

Umgekehrt gilt allerdings das Gleiche: Lernst Du von Anfang an mit einer IDE, sind die Basics meist gar nicht erst erlernt.

[Jujiro]

edit: Ich kann sonst auch mal die Aufgabenstellung mit anhängen, falls gewünscht ;)

Also...beim Kommentare-Schreiben ist mir schon ein Fehler aufgefallen(habe einmal den Übertrag nicht beachtet...)...aber das Problem besteht weiterhin.

Zur Aufgabe:

Es sollen zwei vier bit lange Dualzahlen miteinander addiert werden

0011+
1001=
1100

So zum Beispiel
Dafür sollen wir halt "von rechts nach links" addieren, wie man halt schriftlich addiert.

Ich entschuldige die schlechten/unnötigen Kommentare. Anderen Leuten meine Programme verständlich zu machen war noch nie meine Stärke, aber bin auch kein Informatikstudent

kommentierte Programmcodes:

public class Bit
{
// Private variablen 
 private boolean gesetzt; 

// Konstruktor, falls der Bit "via" Boolean erzeugt wird
public Bit(boolean gesetzt)
    {
    this.gesetzt=gesetzt;
    }

// Konstruktor, falls der Bit "via" Integer(0 oder 1) erzeugt wird
public Bit(int gesetzt)
    {
    if(gesetzt==1)
    this.gesetzt=true;
    else
    this.gesetzt=false;
    }
 
//gibt zuruck, ob das Bit gesetzt ist
 public boolean istGesetzt()
    {
     return this.gesetzt;
    }
//gibt 1 zuruck, wenn das Bit gesetzt ist, andernfalls 0
 public int getValue()
    {
    int a=0;
     if (gesetzt)
        a= 1;
     return a;
     }
 
}

public class Gatter
{

// Wenn Bit x UND y gesetzt sind, wird ein Bit zurückgegeben, der auch gesetzt ist
// Andernfalls wird ein Bit zurückgegeben, der nicht gesetzt ist
 static Bit AND(Bit x, Bit y)
    {
    boolean a=false;
    int b = (x.getValue() * y.getValue());
    if(b==1)
        {
        a=true;
        }
    Bit z = new Bit(a);
     return z;
     }

//Gibt gesetzten Bit zurück, falls Bit x ODER y gesetzt ist(oder beide)
static Bit OR(Bit x, Bit y)
    {
    boolean a=false;
    int b=(x.getValue() + y.getValue());
    if(b>=1)
        {
        a=true;
        }
    Bit z = new Bit(a);
     return z;
     }

//Gibt gesetzten Bit zurück, falls entweder Bit x ODER y gesetzt ist(genau einer)
 static Bit XOR(Bit x, Bit y)
    {
    boolean a=false;
    int b=(x.getValue() + y.getValue());
    if(b==1)
        {
        a=true;
        }
    Bit z = new Bit(a);
     return z;
     }
 
}

public class Halbaddierer
{
// Da es nur einen Rückgabewert gibt, wird der Übertrag einfach als Variable gespeichert
private Bit uebertrag;

//Addiert 2 Bits und speichert den Übertrag
    public Bit add(Bit x, Bit y)
    {
//Ein Übertrag existiert(ist gesetzt), falls x UND y gesetzt sind
        uebertrag= Gatter.AND(x,y);
//Bei der schriftlichen Addition wäre die Summer der Ziffer, die unter den beiden Dualzahlen stehen würde gleich 1, wenn ENTWEDER x ODER y gesetzt ist(der Übertrag wird ja extra gespeichert)
        return (Gatter.XOR(x,y));
    }

//Gibt den Übertrag zurück
    public Bit getUebertrag()
    {
    return uebertrag;
    }    
    
}

public class Volladdierer
{

//Ein Volladdierer besteht aus 2 Halbaddierern
    private Halbaddierer ha1;
    private Halbaddierer ha2;
//Und wieder der Extra-Übertrag
    private Bit uebertrag;


//Addiert unter der berücksichtigung, dass bereits ein Übertrag vorhanden sein könnte
    public Bit add(Bit x, Bit y, Bit c_in)
    {
        uebertrag = Gatter.OR(Gatter.OR(Gatter.AND(x,y),Gatter.AND(x,c_in)),Gatter.AND(y,c_in));
        Bit a = (Gatter.OR(ha1.add(x,y),ha2.add(ha1.getUebertrag(), c_in)));
        return a;
    }

//Gibt den Übertrag als Bit zurück
    public Bit getUebertrag()
    {
        return uebertrag;
    }
    
}

public class TestAddierer {
    
    public static void main(String[] args) {
        System.out.println("Wahrheitstabelle Halbaddierer:");
        printHalbaddierer();
        System.out.println();
        
        System.out.println("Wahrheitstabelle Volladdierer:");
        printVolladdierer();
        System.out.println();
        
        System.out.println("Additionen mit dem 4-Bit-Addierer:");
        Bit[] bits1 = {new Bit(0), new Bit(1), new Bit(1), new Bit(0)}; //0110
        Bit[] bits2 = {new Bit(0), new Bit(0), new Bit(1), new Bit(1)}; //0011
        
        printVierBitAddierer(bits1, bits2);
        printVierBitAddierer(bits1, bits1);
        printVierBitAddierer(bits2, bits2);
        //Addieren Sie weitere Zahlen...
    }
    
    
    
    /**
     * Diese Methode benutzt den von Ihnen implementierten Halbaddierer und 
     * gibt die entsprechende Wahrheitstabelle auf dem Bildschirm aus.
     */
    public static void printHalbaddierer() {
        int wht[][] =  {{0, 0},
                        {0, 1},
                        {1, 0}, 
                        {1, 1}};
        
        Halbaddierer h = new Halbaddierer();
        System.out.println("  a__b__|__s__cout");
        for (int i = 0; i < wht.length; i++) {
            Bit s     = h.add(new Bit(wht[i][0]), new Bit(wht[i][1]));
            Bit carry = h.getUebertrag();
            System.out.println("  " + wht[i][0] + "  " + wht[i][1] + "  |  " 
                    + s.getValue() + "   " + carry.getValue());
        }
    }
    
    
    
    /**
     * Diese Methode benutzt den von Ihnen implementierten Volladdierer und 
     * gibt die entsprechende Wahrheitstabelle auf dem Bildschirm aus.
     */
    public static void printVolladdierer() {
        int wht[][] =  {{0, 0, 0},
                        {0, 0, 1},
                        {0, 1, 0}, 
                        {0, 1, 1},
                        {1, 0, 0},
                        {1, 0, 1},
                        {1, 1, 0}, 
                        {1, 1, 1}};
        
        Volladdierer v = new Volladdierer();
        System.out.println("  a__b_cin_|__s__cout");
        for (int i = 0; i < wht.length; i++) {
            Bit s     = v.add(new Bit(wht[i][0]), new Bit(wht[i][1]), new Bit(wht[i][2]));
            Bit carry = v.getUebertrag();
            System.out.println("  " + wht[i][0] + "  " + wht[i][1] + "  " + wht[i][2] + "  |  " 
                    + s.getValue() + "   " + carry.getValue());
        }
    }
    
    
    
    /**
     * Diese Methode benutzt den von Ihnen implementierten VierBitAddierer, um 
     * die uebergebenen Binaerzahlen zahl1 und zahl2 zu addieren und gibt das 
     * Ergebnis auf dem Bildschirm aus.
     */
    public static void printVierBitAddierer(Bit[] zahl1, Bit[] zahl2) {
        VierBitAddierer v4 = new VierBitAddierer();
        System.out.print("  ");
        for (int i = 0; i < zahl1.length; i++) {
            System.out.print(zahl1[i].getValue());
        }
        System.out.print(" + ");
        for (int i = 0; i < zahl2.length; i++) {
            System.out.print(zahl2[i].getValue());
        }
        System.out.print(" = ");
        
        Bit[] res = v4.add(zahl1, zahl2);
        for (int i = 0; i < res.length; i++) {
            System.out.print(res[i].getValue());
        }
        System.out.println();
    }

    
}

[Xean]

Eine NullPointerException heißt ja, dass es zwar eine Variable gibt, diese aber 'null' ist, bzw. noch nicht initialisiert wurde.

Wenn du dir die Zeile anschaust, in der der Fehler geworfen wurde:

        Bit a = Gatter.OR(
                           ha1.add(x,y),
                           ha2.add(ha1.getUebertrag(),
                           c_in)
                  );

dann sieht man da einen statischen Aufruf einer Methode mit den Rückgabewerten anderer Methoden als Parameter.

Wenn du in deinem Source-Code den Aufruf genau so schreibst, wie ich (mit den Zeilenumbrüchen), dann wird die Exception in der zweiten und dritten Zeile fliegen.

Du musst jetzt nurnoch herrausfinden, was null ist, und warum.

Viel erfolg!
Xean

[Jujiro]

Danke für den Tipp.

Ich habe das jetzt so geschrieben:

Bit a1 = ha1.add(x,y);
        Bit a2 = ha2.add(ha1.getUebertrag(),c_in);
        Bit a = Gatter.OR(a1,a2);
        return a;

Er meckert bei der ersten Zeile...nur weiß ich trotzdem nicht warum...

[Sekundentakt]

Du suchst an der falschen Stelle.

Was ist null?
null, in der Informatik, ist nicht 0, sondern null.
Null ist nichts. Nichts ist wertlos. 0 ist ein Wert, null nicht.

MeineKlasse x;

Damit sagst Du, dass x mal eine Instanz von MeineKlasse werden soll. Es ist allerdings Fakt, dass x im Augenblick eine Instanz von gar nichts ist. x ist noch nicht initialisiert - d.h. die Variable x wurde zwar schon deklariert, aber noch nicht erzeugt. Deklariert heißt, dass ihr ein Namensraum gegeben wurde und auch schon näher bestimmt wurde, was x denn werden soll. Das heißt, im Moment ist x noch nichts und nichts ist null.

x = new MeineKlasse();

Jetzt ist x eine Instanz von MeineKlasse und besitzt alle Fähigkeiten, die diese Klasse x zur Verfügung stellt.

Ich hoffe, dass das beim Verständnis der Problematik hilft.
Schau Dir noch mal die komplette Volladdiererklasse an.

[Jujiro]

Erleuchtung :)

Vielen vielen Dank...nur ist jetzt wieder ein neues Problem...

Zunächst habe ich die Volladdierer.java und die VierBitAddierer.java wie folgt geändert:

...
    public Bit add(Bit x, Bit y, Bit c_in)
    {
        ha1=new Halbaddierer();
        ha2=new Halbaddierer();
        uebertrag = Gatter.OR(
...

und

...
    public Bit[] add(Bit[] bits1, Bit[] bits2)
    {
        va1=new Volladdierer();
        va2=new Volladdierer();
        va3=new Volladdierer();
        va4=new Volladdierer();
        Bit[] a = new Bit[4];
...

An dieser Stelle nochmal Danke für die tolle Erklärung :)

Nun sagt er:

Expection in thread "main" java.lang.NullPointer.Exception
at TestAddierer.printVierBitAddierer(TestAddierer.jav a:91)
at TestAddierer.main(TestAddierer.java:16)

Kann das jetzt noch was mit meinen Klassen zu tun haben?
Ich hab mir die Stellen (mit meinen neuem Wissen) angeguckt und nichts gefunden....

[Jujiro]

Oh man...hab mein Problem gefunden..böööses Copy&Paste -.-
Beim VierBitAddierer habe ich immer den gleichen Bit geändert...
Richtig müsste es also so heißen:

        a[0]=va1.add(bits1[0],bits2[0],z);
        a[1]=va2.add(bits1[1],bits2[1],va1.getUebertrag());
        a[2]=va3.add(bits1[2],bits2[2],va2.getUebertrag());
        a[3]=va4.add(bits1[3],bits2[3],va3.getUebertrag());
        return a;

Nochmals Danke Wenn ich wieder Probleme habe(und das wird kommen...) kann ich hoffentlich auf euere Hilfe zählen. Ich werde mich bemühen euch vll auch helfen zu können

[SoPhi]

Hi, ich versuch auch gerade dein Programm zu verstehen.Könntest du es jetzt in der Fertigen Version nochmal Posten? Dankeschön! SoPhi