Ziemlich genau das gleiche Problem wurde hier schonmal diskutiert undzwar in http://www.java-forum.org/java-basi...835-variablen-fremden-objekten-zugreifen.html
Da ich allerdings nach einer Eigenen Lösung suche und nicht ganz dem dort gegebenen Quelltext folgen kann folgende Frage also gegeben ist selbige Aufgabenstellung mit dem nicht zu verändernden Quelltext:
Nun habe ich soweit die Klassen Nand und Signal geschrieben, mir fehlt allerdings das Wissen um den Status des Signals in Nand zu bekommen.
Nand:
Signal:
Ich weis das da noch ein paar andere Fehler drin sind, mir gehts allerdings Hauptsächlich nur um dieses Problem...waere cool wenn jemand da nen Ansatz hätte.
Gruß
Da ich allerdings nach einer Eigenen Lösung suche und nicht ganz dem dort gegebenen Quelltext folgen kann folgende Frage also gegeben ist selbige Aufgabenstellung mit dem nicht zu verändernden Quelltext:
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();
}
}Nun habe ich soweit die Klassen Nand und Signal geschrieben, mir fehlt allerdings das Wissen um den Status des Signals in Nand zu bekommen.
Nand:
Java:
import java.util.ArrayList;
import java.util.Iterator;
public class Nand
{
private ArrayList<Signal> inputspeicher;
private int anzahl, eingangnummer;
private boolean wert, a, b, c, d, ergebnis;
private int[] eingangsnummerSpeicher;
private String[] signalnameSpeicher;
//lege die Größe der ArrayList anhand der eingänge fest
public Nand(int eingaenge)
{
inputspeicher = new ArrayList(eingaenge);
}
//übernahme der gesendeten Werte, soll verbindeNameSignal zuspielen
public void setInput(int eingangsnummer, Signal name)
{
inputspeicher.add(eingangsnummer, name);
}
// Ordne dem Signal mit Name "name" ein boolean zu
public void verbindeNameSignal()
{
}
// test ob letztes Gatter
public void folgtGatter()
{
if (Signal.getName == s1 || Signal.getName== s0)
{
system.out.println( Signal.getName + ">" + Signal.getAktuellerstatus);
}
}
//verknüpfe die wahrheitswerte logisch und gebe ergebnis zurück
public boolean setOutput(boolean ausgangswert)
{
ergebnis = !(a&&b&&c&&d);
return ergebnis;
}
}Signal:
Java:
import java.util.ArrayList;
public class Signal
{
private String name;
private boolean neuerwert, aktuellerstatus;
//gib der Klasse den gesendeten Namen "name"
public Signal(String sname)
{
name = sname;
}
//direkter Zugriff aus FunctionalSimulator um Startwerte festzulegen
public void setValue(boolean wert)
{
neuerwert = wert;
}
//aktuellen Wahrheitswert für Nand auslesen
public boolean getAktuellerstatus()
{
aktuellerstatus = neuerwert;
return aktuellerstatus;
}
//Name des Signals für Nand auslesen
public String getName()
{
return name;
}
//output aus Nand in Signal aufnehmen
public void neuerWahrheitswert(boolean output)
{
neuerwert = output;
}
}Ich weis das da noch ein paar andere Fehler drin sind, mir gehts allerdings Hauptsächlich nur um dieses Problem...waere cool wenn jemand da nen Ansatz hätte.
Gruß
