Objekt referenzieren ohne variable

elagil

Mitglied
Hallo,

ich habe zum Einstieg gleich mal eine Frage. Im Rahmen eines Informatikprojektes muss ich einen Volladdierer simulieren. Dabei gibt es drei Klassen. Die Klasse "Nand" simuliert Nand-Gatter.

Aufbau: Der Addierer hat drei Eingänge (Signale). Diese werden über Nand Gatter wieder über Signale zu einer Reihe Nand-Gatter geschleust und am Ende am Endsignal ausgegeben. Seht am besten selbst, ich habe schon sehr umfangreich kommentiert:


Zunächst die Anfangs gegebene Klasse functional simulator. sie erzeugt nur objekte von den klassen und verbindet ein und ausgänge.
dabei haben nand gatter beliebig viele eingänge und nur einen ausgang.
Signale bekommen nur einen Namen zugewiesen.
Java:
/**
 * Klasse FunctionalSimulator ist ein einfacher Logiksimulator, der nur 
 * Nand-Gatter simulieren kann und keine Zeitverz�gerungen ber�cksichtigt.
 * Die zu simulierende Schaltung wird im Konstruktor der Klasse erzeugt.
 * Es handelt sich hierbei um einen einfachen Volladdierer.
 * Zum Testen Ihrer Klassen <CODE>Nand</CODE> und <CODE>Signal</CODE> m�ssen Sie
 * einfach nur eine Instanz dieser Klasse erzeugen und dann die Methode
 * <CODE>simulate()</CODE> aufrufen.
 * @author Christian Hochberger, TU Dresden
 * @version 1.0 Erste Fassung
 */
public class FunctionalSimulator {
    // Eing�nge (i1-i3) und Ausg�nge (s1,s0) der Schaltung
    Signal	i1,i2,i3,s1,s0;
    // Innere Signale, geben das invertierte Signal der Eing�nge an
    Signal	ni1,ni2,ni3;
    // Innere Signale, die bei der Berechnung der Summe ben�tigt werden
    Signal	t1,t2,t3,t4,t5,t6,t7;

    // Nand-Gatter zum Invertieren der Eing�nge
    Nand	inv1,inv2,inv3;
    // Nand-Gatter zur Berechnung der Summe
    Nand	n1,n2,n3,n4,n5,n6,n7,n8,n9;

    /**
     * Konstruktor, der die zu simulierende Schaltung aufbaut.
     * Simuliert wird ein einfache Volladdierer.
     */
    public FunctionalSimulator() {
	// Alle Signale anlegen
	// Der Konstruktor bekommt einen Signalnamen als Parameter
	i1=new Signal("i1");
	i2=new Signal("i2");
	i3=new Signal("i3");
	ni1=new Signal("ni1");
	ni2=new Signal("ni2");
	ni3=new Signal("ni3");
	s1=new Signal("s1");
	s0=new Signal("s0");
	t1=new Signal("t1");
	t2=new Signal("t2");
	t3=new Signal("t3");
	t4=new Signal("t4");
	t5=new Signal("t5");
	t6=new Signal("t6");
	t7=new Signal("t7");

	// Alle Gatter anlegen
	// Parameter des Konstruktors ist die Anzahl von Eing�ngen
	// Die Inverter sind sozusagen entartete Nand-Gatter (1 Eingang)
	inv1=new Nand(1);
	inv2=new Nand(1);
	inv3=new Nand(1);
	n1=new Nand(3);
	n2=new Nand(3);
	n3=new Nand(3);
	n4=new Nand(3);
	n5=new Nand(3);
	n6=new Nand(3);
	n7=new Nand(3);

	n8=new Nand(4);
	n9=new Nand(4);

	// Inverter mit Ein- und Ausg�ngen verbinden.
	// Die Methode setInput() des Gatters bekommt die Nummer des Eingangs
	// und das Signal, mit dem dieser Eingang verbunden werden soll.
	inv1.setInput(0,i1);
	// Die Methode setOutput() bekommt nur ein Signal, welches durch diesen
	// Ausgang bestimmt wird
	inv1.setOutput(ni1);
	inv2.setInput(0,i2);
	inv2.setOutput(ni2);
	inv3.setInput(0,i3);
	inv3.setOutput(ni3);

	// Die Nand-Gatter zur Summenberechnung richtig verbinden
	n1.setInput(0,ni1);
	n1.setInput(1,ni2);
	n1.setInput(2,i3);
	n1.setOutput(t1);
	
	n2.setInput(0,ni1);
	n2.setInput(1,i2);
	n2.setInput(2,ni3);
	n2.setOutput(t2);
	
	n3.setInput(0,ni1);
	n3.setInput(1,i2);
	n3.setInput(2,i3);
	n3.setOutput(t3);
	
	n4.setInput(0,i1);
	n4.setInput(1,ni2);
	n4.setInput(2,ni3);
	n4.setOutput(t4);
	
	n5.setInput(0,i1);
	n5.setInput(1,ni2);
	n5.setInput(2,i3);
	n5.setOutput(t5);
	
	n6.setInput(0,i1);
	n6.setInput(1,i2);
	n6.setInput(2,ni3);
	n6.setOutput(t6);
	
	n7.setInput(0,i1);
	n7.setInput(1,i2);
	n7.setInput(2,i3);
	n7.setOutput(t7);

	// n8 und n9 berechnen die eigentlichen Ausg�nge
	n8.setInput(0,t1);
	n8.setInput(1,t2);
	n8.setInput(2,t4);
	n8.setInput(3,t7);
	n8.setOutput(s0);

	n9.setInput(0,t3);
	n9.setInput(1,t5);
	n9.setInput(2,t6);
	n9.setInput(3,t7);
	n9.setOutput(s1);

	// Die Signale s1 und s0 sind mit keinen weiteren Gattern verbunden.
	// Sorgen Sie daf�r, dass in diesem Fall eine Wert�nderung dieser
	// Signale ausgegeben wird.
    }

    /**
     * Diese Methode f�hrt die eigentliche Simulation durch. Dazu werden den
     * Eingangssignalen (i1,i2,i3) einfach nur neue Werte zugeordnet. Diese
     * Wert�nderungen propagieren sich dann durch die Schaltung bis zum Ausgang
     * und werden dort ausgegeben.
     */
    public void simulate() {
	// Zun�chst alle Eing�nge auf false setzen (ist zwar schon nach dem)
	// Erzeugen des Gatters so, aber durch ein erneutes Setzen werden
	// die inneren Signale der Schaltung vern�nftig berechnet)
	i1.setValue(false);
	i2.setValue(false);
	i3.setValue(false);

	// Eingang i1 auf true: Dadurch sollte als Summe s1=false und s0=true
	// herauskommen. Es ist aber normal, dass �nderungen an s1 und s0 mehrfach
	// ausgegeben werden, bevor das Endergebnis herauskommt.
	System.out.println("==== i1 -> true");
	i1.setValue(true);
	
	// Eingang i1 und i2 auf true: Dadurch sollte als Summe s1=true und
	// s0=false herauskommen.
	System.out.println("==== i2 -> true");
	i2.setValue(true);
	
	// Eingang i1,i2 und i3 auf true: Dadurch sollte als Summe s1=true und
	// s0=true herauskommen.
	System.out.println("==== i3 -> true");
	i3.setValue(true);
	
	// Eingang i1 und i3 auf true: Dadurch sollte als Summe s1=true und
	// s0=false herauskommen.
	System.out.println("==== i2 -> false");
	i2.setValue(false);
	
	// Eingang i3 auf true: Dadurch sollte als Summe s1=false und
	// s0=true herauskommen.
	System.out.println("==== i1 -> false");
	i1.setValue(false);
	
	// Eingang i2 und i3 auf true: Dadurch sollte als Summe s1=true und
	// s0=false herauskommen.
	System.out.println("==== i2 -> true");
	i2.setValue(true);
    }

    /**
     * Main Methode dieser Klasse. Sie m�ssen das im Moment noch nicht
     * verstehen. Diese Methode wird ben�tigt, wenn Sie den Simulator ohne
     * BlueJ laufen lassen wollen. Wenn Sie diese Klasse in BlueJ nutzen,
     * dann ignorieren Sie diese Methode einfach.
     */
    public static void main(String[] args) {
	FunctionalSimulator s=new FunctionalSimulator();

	s.simulate();
    }
}

Hier meine Implementierung der Klasse Nand:
Java:
public class Nand {
    // --------------- Datenfelder ---------------
    private Signal[] signale;                          // Array mit signalen
    private Signal ausgang;                            // Es existiert nur ein Ausgang.
    private boolean ausgangswert;                      // Hilfsgröße, die dann auf Signal "Ausgang" übertragen wird.

    
    // --------------- Konstruktor ---------------
    public Nand (int eingaenge) {             // Functional simulator ruft konstruktor auf
        signale = new Signal[eingaenge];      // Array für signale: eingangszahl = anzahl felder setzen
        this.ausgangswert = false;            // Ausgang zunächst mal auf false..
    }

    
    // --------------- Methoden ---------------
    public void setInput (int eingang, Signal signalname) { 
        signale[eingang] = signalname;       // Dem Nand Gatter wird am Eingang "eingangsnummer" das Signal "signalname" zugeordnet.
        signalname.nandName ( adresse dieses nands ) // Hier vielleicht der Versuch, dem Signal zu sagen, wie das Nand zu referenzieren ist..
    }
            
    public void setOutput(Signal ausgang){  
        this.ausgang = ausgang;             // Dem Nand Gatter wird ein Signal des Typs Signal an seinem (einzigen) Ausgang zugeordnet.
    }

    public void calcAusgang () {
        int trueeingaenge = 0;              // Methodenvariable: Zähler für die "true" geschalteten Eingänge

        for (Signal wert : signale) {
            if (wert.eingeschaltet() == true) {trueeingaenge++; // Zählt wahr geschaltete eingänge: dafür gibt es eine methode in "Signal", 
                                                                // damit NAND auch einen boolean Wert zurückbekommt
            };
        }

        if (trueeingaenge == 0) {this.ausgangswert = true;}   // Wenn alle eingänge falsch, ausgang wahr (nand.)
        else {this.ausgangswert = false;}                     // sonst nicht.
        
        ausgang.setValue (ausgangswert);    // Übertrage den Wert am Ausgang auf das richtige Signal. "ausgang" ist vom Typ Signal 
                                            // und ist ein Platzhalter für das Ausgangssignal. setValue setzt den Wert.
    }
}

und der Klasse Signal

Java:
public class Signal {
    // --------------- Datenfelder ---------------
    private String name;            // Name des Signals
    private boolean an;             // Ist das Signal an oder aus?

    
    // --------------- Konstruktor ---------------
    // Klasse Signal übernimmt Name als Parameter
    // Das Signal kann an oder aus sein (boolean wert), anfangs aus.
    public Signal (String name) {
        this.name = name;
        an = false;
    }

    
    // --------------- Methoden ---------------
    public boolean eingeschaltet () {   // gibt zurück ob signal an oder aus
        if (an == true) {return true;}
        else {return false;}
    }

    public void setValue (boolean an) {  // Zustand (an/aus) setzen
        if (an == this.an && this.name.startsWith("s")) { // nur summenänderungen zeigen. Summen starten mit "s".
            System.out.println(name + " -> " + an);
            //Ausgabe: aktualisierter zustand des ausgangs (!) "name"

            this.an = an; // neuen wert des signals setzen
        };        
    }
}

Problem nun: In meinen Augen habe ich die Aufgabe fast gelöst, nur muss ein Objekt der Klasse Signal dem Nand über die dafür eingerichtete Methode "calcAusgang" mitteilen, dass es nun neu rechnen solle!

Ich hoffe da steht nicht zu viel Code.. :)

Danke im Voraus,
Adrian
 

Cola_Colin

Top Contributor
Und das Problem liegt dann wo genau?
Zugegeben, ich habe nicht den ganzen Code gelesen.
Kannst du das Problem eventuell in einem kurzen Beispiel verdeutlichen?
 

elagil

Mitglied
Das steht ja eigentlich im letzten Abschnitt ;)

Das Problem nochmal:
Wie schon erwähnt gibt es besagte Gatter und Signale.
Man Verbindet etwa das Signal "i0" (i0 wird hierbei als Parameter an die Signalklasse übergeben und die Variable als "name" gespeichert.) mit dem Nand Gatter "inv1" (an das Gatter wird folgendes übergeben: Parameter "Eingangsanzahl" an den Konstruktor; später im Code: Parameter "Eingangsnummer" (int) -> "Signalname" (Typ Signal! damit kann ich die signale adressieren!))

Nun weiß das Nand bescheid über seine Eingänge (und Ausgänge, aber die sind nicht das Problem). Ich kann, wenn das Nand einen Ausgang neu berechnet, über die in einem Array gespeicherten Einträge zu den Eingängen (d.h. Eingangsnummer und Signal) iterieren, die Werte abfragen und am Ende das Ergebnis auf ein Signal am Ausgang des Nand übertragen.
Wichtig hier: das Nand bekommt vom Typ Signal die Namen der Signale! Ich kann auf diese Objekte zugreifen.

Das Nand soll nun seinen Ausgangswert neu berechnen, hierzu gibt es eine Methode. Diese Methode soll genau dann aufgerufen werden, wenn die Signale, die mit dem Nand verknüpft sind, ihren Wert "boolean an" ändern, bzw. dieser gesetzt wird. Gesetzt wird der Wert durch die Klasse "functional simulator" auf die ich keinen Einfluss habe.
Vgl. Klasse Nand: Die Klasse Signal bekommt die Variablen der Nand Gatter (Typ Nand) nicht!

Wie sagt nun das Signal dem Nand es soll die Methode zur Neuberechnung aufrufen?..

Gibt es vielleicht einen ganz anderen Weg?

Danke schonmal ;)
 
S

Spacerat

Gast
Wichtig hier: das Nand bekommt vom Typ Signal die Namen der Signale! Ich kann auf diese Objekte zugreifen.
Also in deinem Code steht was anderes. Laut diesem werden im Signal-Array der Nands nicht blos deren Namen gespeichert, sondern die Signalobjekte (Variablennamen sind Schall und Rauch).
Man könnte die Signale "observable" machen und evtl. Verbundene Nands dort als Observer eintragen. Wenn du nun ein Signalzustand änderst, informierst du diese Observer darüber, welche daraufhin ihre Ausgänge selbstständig neu berechnen können.
 

elagil

Mitglied
na gut... ich dachte die Objektnamen wären irgendwie eine Art Adresse (wohl eher Platzhalter/Verknüpfung zu den tatsächlichen Objekten)


Nun, solche Dinge haben wir nicht behandelt ;) Es sollte mit Vorlesungswissen machbar sein und das findet sich eigentlich vollständig in meinem Code wieder (außer anderen Schleifenformen und Listentypen [linked list...])

Ich nehme mal an eine Klassenmethode bringt nichts, weil sie ja auf ihre Instanzen genausowenig zugriff hat? Mir ist auch mit ansätzen geholfen, die mich zwingen, den code neu zu schreiben, solange es besser ist (oder sogar funktioniert :) )
 

Cola_Colin

Top Contributor
Du müsstest praktisch einem Signal sagen: Du gehörst zu diesem Gatter.
Wenn das Signal nun aktiviert wird, dann muss das Signal auf dem Gatter, das vorher zugeteilt wurde, eben die gewünschte Methode aufrufen.
Soll heißen: Erweitere Signal um die Möglichkeit ein gatter zu speichern und rufe auf diesem deine Methode zum neuberechnen auf, wenn das Signal auf true geschaltet wird.
 

elagil

Mitglied
Das klingt logisch, das habe ich aber auch schon versucht. Angenommen ich will dem Signal die Information mitgeben, wenn das Nand "erfährt", welchem Signal es zugehörig ist und umgekehrt:

Java:
// die Methode setInput in der Klasse Nand

setInput ( ... , Signal signalname) {
 ...
signalname.merkeNand ( --- Referenz --- ); 
}

Angenommen (und das ist ja schnell gebaut):

Java:
// Klasse Signal
...
Nand nandname;  // Variable
...

public void merkeNand ( Nand nandname ) {
this.nandname = nandname;
}

das Objekt Nand weiß aber nicht wie es heißt?!
 

Cola_Colin

Top Contributor
Ich dachte an sowas:

Java:
// Klasse Signal:
    public void setValue (boolean an) {  // Zustand (an/aus) setzen
        if (an == this.an && this.name.startsWith("s")) { // nur summenänderungen zeigen. Summen starten mit "s".
            System.out.println(name + " -> " + an);
            //Ausgabe: aktualisierter zustand des ausgangs (!) "name"
 
            this.an = an; // neuen wert des signals setzen
        };        
        if (this.an) {
          nandname.calcAusgang();
        }
    }

Das Signal wurde natürlich vorher zum nand hinzugefügt, so das es beim Aufruf von calcAusgang vom Nand dann beachtet wird.
 
S

Spacerat

Gast
Wie gesagt - Namen sind Schall und Rauch. Steht in einer Methode z.B. "setInput(int 0, Signal signal)", so wird immernoch eine Instanz des Typs Signal erwartet. Auf diese Instanz kannst du dann eine Instanzmethode "<Signal>.add(Nand nand)" aus einem Nand mit "signal.add(this)" aufrufen.
 

elagil

Mitglied
Java:
if (this.an) {
          nandname.calcAusgang();
        }

Nunja, wie schon gesagt, "nandname" ist ja noch nicht gesetzt und das Problem ist genau das, es zu setzen.

Das Signal wurde natürlich vorher zum nand hinzugefügt
das ist wohl wahr, das ist ja schon immer so, nur weiß das signal nichts davon.

so dass es beim Aufruf von calcAusgang vom Nand dann beachtet wird
wenn ich eine methode aufrufe, dann wird sie doch auch ausgeführt? Der Aufruf ist eben nicht machbar, wie mir scheint.. ich verzweifle schon daran ;)

____


oh gibt es sowas? :)
 
Zuletzt bearbeitet:

elagil

Mitglied
Vielen Dank, das ist sehr hilfreich :) nur funktioniert der code noch nicht...hm:

Neu geschrieben:

Nand:
Java:
public class Nand {
    // --------------- Datenfelder ---------------
    private Signal[] signale;                          // Array mit signalen
    private Signal ausgang;                            // Es existiert nur ein Ausgang.
    private boolean ausgangswert;                      // Hilfsgröße, die dann auf Signal "Ausgang" übertragen wird.

    // --------------- Konstruktor ---------------
    public Nand (int eingaenge) {             // Functional simulator ruft konstruktor auf
        signale = new Signal[eingaenge];      // Array für signale: eingangszahl = anzahl felder setzen
        this.ausgangswert = false;            // Ausgang zunächst mal auf false..
    }

    // --------------- Methoden ---------------
    public void setInput (int eingang, Signal signalname) { 
        signale[eingang] = signalname;       // Dem Nand Gatter wird am Eingang "eingangsnummer" das Signal "signalname" zugeordnet.
        signalname.merkeNand (this);         // sagt dem gatter, welches nand an ihm angeschlossen ist
    }

    public void setOutput(Signal ausgang){  
        this.ausgang = ausgang;             // Dem Nand Gatter wird ein Signal des Typs Signal an seinem (einzigen) Ausgang zugeordnet.
    }

    public void calcAusgang () {
        int falseeingaenge = 0;              // Methodenvariable: Zähler für die "true" geschalteten Eingänge

        for (Signal item: signale) {
            if (item.ausgeschaltet()) {falseeingaenge++; // Zählt wahr geschaltete eingänge: dafür gibt es eine methode in "Signal", 
                // damit NAND auch einen boolean Wert zurückbekommt
            };
        }

        if (falseeingaenge == 0) {this.ausgangswert = false;}   // Wenn alle eingänge falsch, ausgang wahr (nand)
        else {this.ausgangswert = true;}                     // sonst nicht.

        ausgang.setValue (ausgangswert);    // Übertrage den Wert am Ausgang auf das richtige Signal. "ausgang" ist vom Typ Signal 
        // und ist ein Platzhalter für das Ausgangssignal. setValue setzt den Wert.
    }
}

Signal:
Java:
public class Signal {
    // --------------- Datenfelder ---------------
    private String name;            // Name des Signals
    private boolean an;             // Ist das Signal an oder aus?
    private Nand nandname;

    // --------------- Konstruktor ---------------
    // Klasse Signal übernimmt Name als Parameter
    // Das Signal kann an oder aus sein (boolean wert), anfangs aus.
    public Signal (String name) {
        this.name = name;
        an = true;
    }

    // --------------- Methoden ---------------
    public void merkeNand ( Nand nandname ) {
        this.nandname = nandname;
    }

    public boolean ausgeschaltet () {   // gibt zurück ob signal an oder aus
        if (an == false) {return true;}
        else {return false;}
    }

    public void setValue (boolean an) {  // Zustand (an/aus) setzen
        if (an != this.an) { // nur summenänerungen zeigen
            this.an = an; // neuen wert des signals setzen
            nandname.calcAusgang ();
            if(this.name.startsWith("s")){
                System.out.println(name + " -> " + an);
                //Ausgabe: aktualisierter zustand des ausgangs (!) "name"           

            }
        }
    }
}

Es kommen aber seltsamerweise Fehler!
Eigentlich verweise ich nicht auf ein nicht vorhandenes Objekt. Die werden schon alle im Konstruktor von functional simulator gebaut.

java.lang.NullPointerException
at Signal.setValue(Signal.java:28)
at Nand.calcAusgang(Nand.java:35)
at Signal.setValue(Signal.java:28)
at Nand.calcAusgang(Nand.java:35)
at Signal.setValue(Signal.java:28)
at FunctionalSimulator.simulate(FunctionalSimulator.java:164)

adrian
 
S

Spacerat

Gast
Ich finde, du betreibst einen zu grossen Aufwand beim Setzen und Ermitteln von Variablen, deswegen verlierst du auch schnell die Übersicht wann welche Variable welchen Wert haben müsste.
Bei Booleans z.B. ist es unschön, wenn man schreibt
Java:
if(a != b) { // bei dir z.B. if(an != this.an)
  c = true;
}
Das passt nämlich wunderbar in eine Zeile
Java:
c = a ^ b; // ^ = Antivalenz, XOR bzw. Exclusiv Oder. Siehe boolsche Verknuepfungen
//fuer dich
this.an = an; // kurz und buendig. Hat den selben Effekt.
Dann noch das mit dem Ermitteln des Ausgang-Wertes. Über das Nand weis man, dass er true liefern muss, solange auch nur ein Eingang false ist. Was hindert einem also daran, das Iterieren über die Eingänge beim Auffinden des ersten false vorzeitig abzubrechen und den Ausgang entsprechend zu setzen (siehe folgenden Code)?
Meine Signal- bzw. Nand-Klassen sähen z.B. so aus:
Java:
import java.util.HashSet;
import java.util.Set;

class Signal {
	private final Set<Nand> nands = new HashSet<Nand>();
	private final String name;
	private boolean status;

	public Signal(String name) {
		if(name == null) {
			throw new NullPointerException();
		}
		this.name = name;
	}

	public void addListener(Nand nand) {
		if(nand != null) {
			synchronized(nands) {
				nands.add(nand);
			}
		}
	}

	public void removeListener(Nand nand) {
		if(nands.contains(nand)) {
			synchronized(nands) {
				nands.remove(nand);
			}
		}
	}

	public void setStatus(boolean status) {
		this.status = status;
		synchronized(nands) {
			for(Nand nand : nands) {
				nand.update();
			}
		}
	}

	public void toggleStatus() {
		setStatus(!status);
	}

	public boolean getStatus() {
		return status;
	}

	@Override
	public String toString() {
		return name + "=" + status;
	}
}

class Nand {
	private final Signal[] input;
	private final Signal output;

	public Nand(String name, Signal ... signals) {
		if(name == null) {
			throw new NullPointerException();
		}
		if(signals == null || signals.length < 2) {
			throw new IllegalArgumentException("invalid number of signals");
		}
		input = signals;
		for(int n = 0; n < signals.length; n++) {
			signals[n].addListener(this);
		}
		output = new Signal(name + "_out");
	}

	public void destroy() {
		for(int n = 0; n < input.length; n++) {
			input[n].removeListener(this);
		}
	}

	public void update() {
		for(int n = 0; n < input.length; n++) {
			if(!input[n].getStatus()) {
				output.setStatus(true);
				return;
			}
		}
		output.setStatus(false);
	}

	public boolean getStatus() {
		return output.getStatus();
	}

	@Override
	public String toString() {
		return output.toString();
	}
}
Na wer sagt's denn... nicht mal 100 Zeilen für beide. ;)
[EDIT]Shit... du bist ja doch kürzer... :oops: Naja, bei mir gibt's dafür aber bereits die Überprüfung auf illegale Werte, Thread-Sicherheit, Hinzufügen und Entfernen beliebig vieler Nands zu einem Signal sowie toString-Methoden. ;)[/EDIT]
 
Zuletzt bearbeitet von einem Moderator:

elagil

Mitglied
Java:
c = a ^ b

diese schreibweise war mir leider nicht bekannt ;) (funktionieren sollte es aber trotzdem..)

Java:
public Nand(String name, Signal ... signals) {
        if(name == null) {
            throw new NullPointerException();
        }

Wie kann denn ein String "null" werden..? Es war wohl der Typ Signal zur Variable name gemeint.
Jedenfalls werden alle Signale vor den Nands ins Leben gerufen, dieser Fehler tritt also nicht auf. Es gibt immer alle Signale, die man braucht.

Java:
if(signals == null || signals.length < 2) {
            throw new IllegalArgumentException("invalid number of signals");

Das ist kein Ausnahmefall, mit einem Nand mit einem Eingang wird ein Inverter simuliert :) Was in functional simulator an die klassen übergeben wird sollte soweit fehlerfrei sein.

Hinzufügen und Entfernen beliebig vieler Nands zu einem Signal
Ein Signal hat maximal ein Nand als Eingang und liegt an mehreren Nands. Ein Nand hat entsprechend nur einen Ausgang und mehrere Eingänge. Ich verstehe also nicht ganz was du damit meinst..

Nun fehlt mir das Verständnis für viele Codestückchen, die dort auftreten (Wir behandeln Java übrigens erst seit 8 Vorlesungen, ich habe auch keine Vorkenntnisse):

Java:
synchronized
Das kann ich nicht zuordnen. Ich habe ein bisschen nachgelesen und fand etwas zu synchronisierten Methoden, wenn mehrere Threads auf sie zugreifen..? In diesem Fall: Was sind Threads? Instanzen?

Java:
import java.util.Set
sets hatten wir nicht ;) wenn sie sich ähnlich wie hashsets verhalten, kann ich sie wohl noch einordnen.

...und noch ein paar andere, ich probiere aber erstmal :) danke soweit
 

elagil

Mitglied
Probleme gelöst, das Problem war ein logischer Denkfehler! (Ich habe angenommen, ein Signal läge nur an einem Gatter an, was nicht stimmt.) :)

Danke an alle!
 
S

Spacerat

Gast
Das mit den 8 Vorlesungen wusste ich nicht. Aber gut. Auch wenn's bereits erledigt ist, will ich's noch versuchen zu erklären.
Wie kann denn ein String "null" werden..? Es war wohl der Typ Signal zur Variable name gemeint.
Jedenfalls werden alle Signale vor den Nands ins Leben gerufen, dieser Fehler tritt also nicht auf. Es gibt immer alle Signale, die man braucht.
Nein, es sollte definitiv ein String sein, weil so ein Nand auch eine Bezeichnung haben sollte, selbst wenn diese nur vom Signal "output" verwendet wird. Kein anderer Baustein darf Zugriff auf das Outputsignal haben, deswegen ist's private und wird im Nand-Konstruktor instanziert. Ferner sollte dieses Signal zu Lebzeiten des Nands nicht neu zugewiesen werden dürfen, deswegen ist es final.
Java:
if(signals == null || signals.length < 2) {
            throw new IllegalArgumentException("invalid number of signals");

Das ist kein Ausnahmefall, mit einem Nand mit einem Eingang wird ein Inverter simuliert :) Was in functional simulator an die klassen übergeben wird sollte soweit fehlerfrei sein.
Ein Signal hat maximal ein Nand als Eingang und liegt an mehreren Nands. Ein Nand hat entsprechend nur einen Ausgang und mehrere Eingänge. Ich verstehe also nicht ganz was du damit meinst.
Für ein Nand ist es ein Ausnahmefall, Nands haben mindestens 2 Eingänge. Es ist zwar richtig, dass man ein Nand als Inverter verwenden kann, jedoch werden dann alle vorhandenen Eingänge mit ein und dem selben Signal beschaltet. Das entspräche diesem:
Java:
Signal a = new Signal("toInvert");
Nand inverter = new Nand("Inverter_1", a, a); // das geht bei meinem Nand nämlich auch
Warum das geht, musst du wahrscheinlich noch lernen. Es geht dabei um diese 3 Punkte ([c]Signal ... signals[/c]) im Nand-Konstruktor, welche man Array-Parameter nennt. Wie dem auch sei. Wollte man eine entsprechende Klasse mit nur einem Eingang, würde man sie als Inverter implementieren und ggf. sogar von Nand erben lassen.
Java:
class Inverter extends Nand {
  public Inverter(String name, Signal in) {
    super(name, in, in);
  }
}
Nun fehlt mir das Verständnis für viele Codestückchen, die dort auftreten (Wir behandeln Java übrigens erst seit 8 Vorlesungen, ich habe auch keine Vorkenntnisse):

Java:
synchronized
Das kann ich nicht zuordnen. Ich habe ein bisschen nachgelesen und fand etwas zu synchronisierten Methoden, wenn mehrere Threads auf sie zugreifen..? In diesem Fall: Was sind Threads? Instanzen?
Siehe Beitrag: SlaterB. Nach 8 Vorlesungen ist's auch keine Schande, diese Threads nicht zu kennen. Vergiss das erst mal, das kommt noch, viel Spass dabei. ;)
Java:
import java.util.Set
sets hatten wir nicht ;) wenn sie sich ähnlich wie hashsets verhalten, kann ich sie wohl noch einordnen.
Set ist nur eine Abstrahierung von der realen Implementation. Dieses Set hier verhält sich z.B. genau wie ein HashSet, weil dessen reale implementation halt eines ist. Aber erbende Klassen (z.B. Inverter) müssen ja nicht unbedingt die reale Klasse kennen und bekämen deswegen nur diese Abstrahierung zu sehen und das auch nur dann, wenn sie protected oder public wäre.
Ein Set habe ich deswegen verwendet, weil man ein Ausgangssignal durchaus an mehrere Eingänge also auch an mehrere Nands legen kann. Anders ist's bei Eingangssignalen, da darf jeweils nur ein Ausgang dran liegen, sonst schaltet man nämlich zwangsläufig Ausgang auf Ausgang und das Kracht. Diese Info hat aber mehr mit Elektro- bzw. Automatisierungstechnik zu tun, als mit Java.
 
Zuletzt bearbeitet von einem Moderator:
S

Spacerat

Gast
Let me google that for you 2. Hit
[OT]BTW.: VarArgs kenne ich auch. Damit ist afaik aber explizit [c](Object ... args)[/c] gemeint, weil nur so sind die Argumente (Parameter) in jeder hinsicht variabel. Ein Anwendungsfall dafür wäre z.B. die [c]execute()[/c]-Methode beim Command-Pattern. Kann aber auch sein, dass ich mich da irre.[/OT]
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
krgewb Über Objekt, das Objekte desselben Typs enthält iterieren Java Basics - Anfänger-Themen 5
M Ausgabe einer ArrayList ensteht nur als Hashcode, nicht als Objekt Java Basics - Anfänger-Themen 16
Rxiiz Objekt aus ComboBox entfernen Java Basics - Anfänger-Themen 4
I JSON in Objekt umwandeln Java Basics - Anfänger-Themen 3
P Objekt einer Methode eines anderen Objektes übergeben Java Basics - Anfänger-Themen 5
I Klassen von einem package laden, Statisches Feld auslesen und Objekt erstellen Java Basics - Anfänger-Themen 8
B Objekt aus generalisierter Liste entfernen Java Basics - Anfänger-Themen 11
Soranix Erste Schritte Struktur als Anfänger // Von einer Klasse auf ein Objekt einer anderen Klasse zugreifen. Java Basics - Anfänger-Themen 6
Say Objekt Java Basics - Anfänger-Themen 4
Say abstract class und Objekt erzeugen - Dringend Hilfe Java Basics - Anfänger-Themen 10
T Wie kann man es machen das ein Objekt nicht übermalt wird Java Basics - Anfänger-Themen 2
D OOP Array einem Objekt zuweisen Java Basics - Anfänger-Themen 2
I Entity Objekt nicht gefunden -> Webhook empfangen in der gleichen Methode (Transaktion) Java Basics - Anfänger-Themen 37
K warum kann ich das Objekt nicht erstellen ? Java Basics - Anfänger-Themen 2
K wie kann ich alle Attribute von dem Objekt(pagode) ausgeben lassen ? Java Basics - Anfänger-Themen 3
H Ein übergegebenes Objekt auf null setzen Java Basics - Anfänger-Themen 9
M BlueJ Objekt in Objektliste Java Basics - Anfänger-Themen 2
B Objekt in Klassendiagramm an fremdes Objekt weiterreichen? Java Basics - Anfänger-Themen 6
Fodoboo131 RegEx- Umwandlung von String in ausführbares Objekt/ Befehl Java Basics - Anfänger-Themen 9
frager2345 Aufgabe Hash Objekt Elemente ausgeben Java Basics - Anfänger-Themen 2
amelie123456 Objekt Farbe Quellcode Java Basics - Anfänger-Themen 4
M Objekt in einem Objekt speichern Java Basics - Anfänger-Themen 9
U Warum kann ich, auf private Variablen zugreifen, wenn ich ein Objekt in der Klasse, die private Variablen hat erstelle und dort drauf zugreifen will? Java Basics - Anfänger-Themen 7
missy72 Klassen Objekt Array NullPointerException Java Basics - Anfänger-Themen 3
J Hinzufügen eines Objektes in ein Objekt-Array Java Basics - Anfänger-Themen 62
O Warum bekommen wir nicht die Referenz vom zurückgegebenen Objekt? Java Basics - Anfänger-Themen 4
K Ein Objekt Auto kennt den Inhalt seines links und rechtsstehenden Autos, wie soll man das ermöglichen Java Basics - Anfänger-Themen 2
W Unterschiede bei Zugriff auf Objekt und Klassenvariablen über einen Getter? Java Basics - Anfänger-Themen 2
melaniemueller Fernseher als Objekt Java Basics - Anfänger-Themen 9
B Datentyp für Einzelnes Objekt oder Liste Java Basics - Anfänger-Themen 9
Nina Pohl Ein Vorgang bezog sich auf ein Objekt, das kein Socket ist Java Basics - Anfänger-Themen 6
B Objekt kopieren und sämtliche Referenzen von diesem Objekt? Java Basics - Anfänger-Themen 3
S JavaFX - Objekt an neue Stage übergeben Java Basics - Anfänger-Themen 12
T Verständnisfrage Objekt Getter Setter Java Basics - Anfänger-Themen 102
P Objekt in mehreren Methoden verwenden. Java Basics - Anfänger-Themen 3
S Aufzurufendes Objekt Java Basics - Anfänger-Themen 3
CptK Überprüfen ob übergebenes Objekt zu Generics passt Java Basics - Anfänger-Themen 2
C Konstruktor ab serialisiertem Objekt Java Basics - Anfänger-Themen 4
Kalibru Problem bei Ausgabe von Objekt Java Basics - Anfänger-Themen 1
P Wie rufe ich Methoden mit einer Referenz auf eine Klasse||Objekt auf Java Basics - Anfänger-Themen 4
J Input/Output Konstruktor ergänzen, der zur Datei mit einem Objekt passt Java Basics - Anfänger-Themen 0
P Ein Objekt nach einem String durchsuchen? Java Basics - Anfänger-Themen 7
S Objekt aus Arraylist in andere Arraylist kopieren? Java Basics - Anfänger-Themen 2
J Objekt-Array dynamischer Länge aus Benutzereingaben erstellen Java Basics - Anfänger-Themen 6
W Mehrfach das gleiche Attribut für ein Objekt erzeugen (mit verschiedenen Werten) Java Basics - Anfänger-Themen 2
C Arrays - deklarieren, initialisieren? Ist das ein Objekt? Java Basics - Anfänger-Themen 3
B Interface List - Objekt übergeben? Einzelnes Objekt geht, aber Liste nicht? Java Basics - Anfänger-Themen 4
B Objekt von EJB in Controller (CDI) - Klasse füllen? Java Basics - Anfänger-Themen 3
L Zufälliges Objekt aus der ArraylList ohne java.util.Random Java Basics - Anfänger-Themen 56
N LocalTime einem Objekt zuweisen Java Basics - Anfänger-Themen 2
N Länge eines Arrays in einem Objekt testen Java Basics - Anfänger-Themen 51
M Wie kann ich ein Objekt erstellen, wenn sich der Klassenname in einer Variablen befindet? Java Basics - Anfänger-Themen 10
R Zugriff auf den Index eines Arrays, welches ein Objekt ist. Java Basics - Anfänger-Themen 4
tom.j85 Doppelte Foreach Schleife: Am Ende wird immer das Gleiche Objekt eingefügt Java Basics - Anfänger-Themen 4
J RSA Verschlüsselung Testen / byte[] in Objekt umwandeln Java Basics - Anfänger-Themen 1
M ArrayList - Objekt kopieren und ändern Java Basics - Anfänger-Themen 11
L Objekt an Methode übergeben Java Basics - Anfänger-Themen 4
S Spiel-Programmieren. Wenn ein Objekt den anderen berührt. Java Basics - Anfänger-Themen 6
J Y-Koordinate von GUI-Objekt bestimmen Java Basics - Anfänger-Themen 2
M Auf erstelltes Objekt einer anderen Klasse zugreifen. Java Basics - Anfänger-Themen 5
H Referenz Objekt aufrufen Java Basics - Anfänger-Themen 12
M Objekt mit eindeutiger ID löschen, das nächste Objekt hat dann diese ID Java Basics - Anfänger-Themen 5
N Mit Objekt der Superklasse auf Methode der Subklasse zugreifen Java Basics - Anfänger-Themen 6
E Objekt durch Benutzer über Konsole erzeugen - Java Java Basics - Anfänger-Themen 3
J Objekt bei Auswahl in jList ändern Java Basics - Anfänger-Themen 6
Kirby.exe Generische Objekt Instanz erstellen Java Basics - Anfänger-Themen 14
H Objekt aus einem Array löschen Java Basics - Anfänger-Themen 1
H Objekt im Array speichern Java Basics - Anfänger-Themen 2
H Objekt mit Methode erstellen Java Basics - Anfänger-Themen 6
H Objekt als Attribut speichern Java Basics - Anfänger-Themen 11
E Was kommt in ein Objekt und was in die Main Methode? Java Basics - Anfänger-Themen 8
R Objekt in Konstruktor ist nicht zulässig Java Basics - Anfänger-Themen 5
W OOP Objekt Methode Java Basics - Anfänger-Themen 9
A Objekt in Arrayliste Java Basics - Anfänger-Themen 2
B Mit methode Objekt aus anderer Klasse erstellen Java Basics - Anfänger-Themen 6
I Object-Oriented Programming, Objekt erzeugen Java Basics - Anfänger-Themen 1
M Objekt einer Klasse speichert die Veränderung nicht Java Basics - Anfänger-Themen 1
K Konstruktor für ein Objekt mit Zugriffsmethoden Java Basics - Anfänger-Themen 7
S Variablen Klassenvariable über Objekt aufrufen Java Basics - Anfänger-Themen 16
A Zufälliges Objekt basierend auf Wahrscheinlichkeiten bekommen. Java Basics - Anfänger-Themen 4
R Value von einem JSON-Objekt ausgeben Java Basics - Anfänger-Themen 4
P Objekt aus String-Array erzeugen Java Basics - Anfänger-Themen 104
N Bewegtes Objekt soll sich um eine Parallele bewegen Java Basics - Anfänger-Themen 0
S Objekt-Attribute "variabel" gestalten Java Basics - Anfänger-Themen 10
J Datenbankstruktur als Objekt anlegen Java Basics - Anfänger-Themen 4
L Objekt aus Textdatei in ArrayList speichern Java Basics - Anfänger-Themen 4
B Objekt an neue Stage übergeben? Java Basics - Anfänger-Themen 9
scratchy1 Wie deklariert man eine Methode, die ein Objekt zurückgeben soll? Java Basics - Anfänger-Themen 22
B Klassen Zugriff auf ein Objekt einer Klasse aus einer Methode heraus Java Basics - Anfänger-Themen 4
J Objekt erste freie Stelle zuweisen Java Basics - Anfänger-Themen 3
S Zugriff auf Objekt Java Basics - Anfänger-Themen 5
C Objekt soll ein Array sein. Java Basics - Anfänger-Themen 15
H Vererbung Static Scanner Objekt verwenden - von StdIn in einer importierten Klasse lesen Java Basics - Anfänger-Themen 10
CptK Datentypen Objekt lässt sich nicht zu arraylist hinzufügen Java Basics - Anfänger-Themen 2
R Vererbung werte von einem Objekt aus ein anderes übertragen Java Basics - Anfänger-Themen 7
Z Objekt Array führt zum NullPointerException Java Basics - Anfänger-Themen 2
L Objekt Typ zur Laufzeit ermitteln Java Basics - Anfänger-Themen 1
F Referenz an ein Objekt in einer anderen Klasse erstellen(Nullpointer exception) Java Basics - Anfänger-Themen 6
M Methode Objekt als Parameterübergabe Java Basics - Anfänger-Themen 6
G Objekt der selben Klasse wie selbst mit Aufrufen des Konstruktors erzeugen Java Basics - Anfänger-Themen 14

Ähnliche Java Themen

Neue Themen


Oben