Logische Schaltungen nachbauen.

[Mikeeesch]

Hallo Zusammen,

zu erst: Ich hab die Regeln gelesen, gegoogelt und die Forensuche benutzt , jedoch wirklich nichts gefunden was mich persönlich weiterbringen könnte und hab gerätselt ob ich hier nun einen neuen Thread aufmachen soll oder nicht. 😀

Wie der Titel schon sagt, möchte ich die Logischen Schaltungen der Digitaltechnik programmieren und möchte euch bitte einen Blick darauf zu werfen und mir sagen ob alles soweit stimmt, oder ob ich an der einen oder anderen Stelle was ändern muss. 🙂

Da ich nicht sooo fit bin, brauche ich schon ziemlich lange um von dem Schlauch runter zu kommen, :lol:
daher bitte ich euch: Wenn ihr einen anderen Lösungsvorschlag habt wie man es schreiben kann, kann schreibt mir doch bitte das in einem kompletten Code. Mit normalen Sätzen hab ich da so meine Schwierigkeiten es zu verstehen. Ich hoffe der eine oder andere weiß, wie ich es meine. 🙁

Zu erst einmal will ich euch zeigen was ich schon mal habe! 🙂

1. Meine Oberklasse mit 2 Eingängen und der Methode "berechneAusgang();"

public abstract class Logik {
	
	public boolean bEingang1 = true;
	public boolean bEingang2 = false;
	
	public abstract boolean berechneAusgang();

}

2. AND-Gatter

public class UND extends Logik {

	@Override
	public boolean berechneAusgang() {
		// Methode und Eingänge werden aus der Oberklasse übernommen.
		
		if (bEingang1 == bEingang2)
		{
			return true;
		} 
		else 
		{
			return false;
		}
		
	}
	
}

3.OR-Gatter

public class OR extends Logik {
	
	@Override
	public boolean berechneAusgang() {
		// TODO Auto-generated method stub
		
		if ((bEingang1 || bEingang2) != true) {
			
			return true;
		}
		else {
			
			return false;
		}
	}

}

4. NOT-Gatter

public class NOT extends Logik {
	
	@Override
	public boolean berechneAusgang() {
		// Methode und Eingänge werden aus der Oberklasse übernommen.
		
		return !(bEingang1);
		}

}

5. NAND-Gatter (Im Gegensatz zu dem normalen AND-Gatter habe ich einfach das true und false vertauscht.)

public class NAND extends Logik {

	@Override
	public boolean berechneAusgang() {
		// TODO Auto-generated method stub
		
		if (bEingang1 == bEingang2)
		{
			return false;
		} 
		else 
		{
			return true;
		}
		
	}
	
}

Sooooooooo, die restlichen habe ich nicht weil ich nicht genau weiß wie ich diese schreiben soll, wäre aber schon recht zufrieden wenn das alles richtig wäre.:toll:

Zudem wollte ich noch fragen wie die Main()-Methode dazu aussehen würde?!

Danke im Voraus.

Mikeeesch

 

[diggaa1984]

Hi,

an sich grundlegend erstmal in Ordnung für Gatter mit 2 Eingängen.
Was du teilweise schon richtig machst ist das Verwenden der Java-Operatoren zur Auswertung deiner Gatter.

Aber manchmal haust da recht weit daneben ^^

UND: mit Hilfe von &&
ODER: ||
NOT: !
NAND: ! UND

Du brauchst da nun gar nicht auf true und false überprüfen, dass machst du ja durch die Kombination der logischen Java-Operatoren schon => UND entspricht: eingang1 && eingang2

Dein UND würde auch bei (false und false) = true zurückliefern, das ist schlichtweg falsch.

 

[Pippl]

Das AND-Gatter ist aber nicht richtig, im Fall das beide Eingänge 'false' sind bekommt man trotzdem 'true' zurück.

Beim OR-Gatter brauchst du das '!=true' nicht.

Desweiteren kannst du das gleich so schreiben

return bEingang1 == bEingang2;

 

[Java-Star]

Sorry,

aber ich bin ECHT kein guter Programmierer. Deshalb möchte ich wissen, was das genau ist, diese Logischen Schaltung der Digitaltechnik. Vielleicht kann ich dir ja weiterhelfen. :rtfm:

--------------------------------------
Ein noch nicht sehr guter Programmierer 😀

 

[Gast2]

Klick mich

 

[diggaa1984]

Sorry,

aber ich bin ECHT kein guter Programmierer. Deshalb möchte ich wissen, was das genau ist, diese Logischen Schaltung der Digitaltechnik. Vielleicht kann ich dir ja weiterhelfen. :rtfm:

Let me google that for you 😉 war wohl einer schneller 😀

 

[AquaBall]

Sorry,

aber ich bin ECHT kein guter Programmierer. Deshalb möchte ich wissen, was das genau ist, diese Logischen Schaltung der Digitaltechnik. Vielleicht kann ich dir ja weiterhelfen. :rtfm:

--------------------------------------
Ein noch nicht sehr guter Programmierer 😀

Wenn du weder programmieren kannst, noch Logik kennst, wie willst du dann helfen?:autsch:


alles andere wurde schon gesagt:

AND:  return (bEingang1 && bEingang2);
OR:   return (bEingang1 || bEingang2);
XOR:  return (bEingang1 != bEingang2);
EQU:  return (bEingang1 == bEingang2);
NOT:  return (!bEingang1);

 

[diggaa1984]

AND:  return (bEingang1 && bEingang2);
OR:   return (bEingang1 || bEingang2);
XOR:  return (bEingang1 != bEingang2);
EQU:  return (bEingang1 == bEingang2);
NOT:  return (!bEingang1);

Nun hat ja doch einer alles verraten (mit Ausnahme vom NAND) ^^

der Vollständigkeit halber:

XOR:  return (bEingang1 ^ bEingang2); //da hat Java auch nen extra Operator fuer

 

[AquaBall]

Was ist mit NOR und XNOR?

Ich hab die weggelassen, weil sie einfach NOTs sind.

Und um vollständig komplett zu werden gehört TRUE und FALSE auch noch dazu.

 

[diggaa1984]

Was ist mit NOR und XNOR?

Ich hab die weggelassen, weil sie einfach NOTs sind.

war ja kein vorwurf, von denen war ja auch im Eingangspost nix zu sehen (ok vom XOR auch net)

 

[Evil-Devil]

NAND, NOR und XNOR setzen sich doch aus 2 Einzelgattern zusammen. Wieso sollte man die außer zur Vereinfachung einbauen? 😉

 

[diggaa1984]

weil er dafür die Klasse anpassen müsste um ein Gatter aus Gattern aufzubauen ^^

 

[irgendjemand]

Nun hat ja doch einer alles verraten (mit Ausnahme vom NAND) ^^

der Vollständigkeit halber:

XOR:  return (bEingang1 ^ bEingang2); //da hat Java auch nen extra Operator fuer

"^" ist das BIT-WISE XOR ... bei bools macht das noch nicht so den unterschied ... und vielleicht auch noch nicht wenn man statt true/false eben 0/1 verwendet ...

es geht hier aber um "LOGIK" ... un da ist XOR nun mal als "true wenn A != B" definiert

 

[Evil-Devil]

weil er dafür die Klasse anpassen müsste um ein Gatter aus Gattern aufzubauen ^^

Kann er als nächstes implementieren. Schön mit Eingängen und Ausgängen und am Ende steht eine Ampel bzw. Ampel-Kreuzung 🙂

 

[AquaBall]

war ja kein vorwurf, von denen war ja auch im Eingangspost nix zu sehen (ok vom XOR auch net)

Fühl mich auch nicht vorgeworfen!
alles ok:toll:

 

[diggaa1984]

"^" ist das BIT-WISE XOR

Die Insel sagt:

^ Integral (Typ) = bitweises Xor
^ boolean (Typ) = logisches Xor

public class MainClass {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		System.out.println(false ^ true ^ false);
		System.out.println(true ^ false ^ false ^ true);
	}
}

es geht hier aber um "LOGIK"

Welche Werte nimmt die Logik denn an? In diesem Fall bool'sche, und genau dafür ist der Operator auch gedacht.

[EDIT]ah, hab verstanden worauf du hinaus möchtest .. die Realisierung der Gatter durch den Mindestsatz an Operatoren (wie zB. Negation, Gleichheit, true/false) .. korrekt?[/EDIT]

 

[irgendjemand]

Die Insel sagt:

public class MainClass {

	/**
	 * @param args
	 * @throws Exception 
	 * @throws BadAliasException 
	 */
	public static void main(String[] args) throws Exception {
		System.out.println(false ^ true ^ false);
		System.out.println(true ^ false ^ false ^ true);
	}
}

Welche Werte nimmt die Logik denn an? In diesem Fall bool'sche, und genau dafür ist der Operator auch gedacht.

schon mal dran gedacht was passieren würde wenn du das mit komplexen objekten und equals machen würdest ?
n bisschen zu sehr auf den "pseudo"-code fixiert ...

 

[diggaa1984]

schon mal dran gedacht was passieren würde wenn du das mit komplexen objekten und equals machen würdest ?

was wäre das denn für ne "Logik"?

 

[hüteüberhüte]

Dann würde ich noch Methoden (statische) mit Parametern für die Eingänge wählen:

    public static boolean buf(boolean a) {
        return a;
    }

    public static boolean not(boolean a) {
        return !a;
    }

    public static boolean and(boolean a, boolean b) {
        return a && b;
    }

    public static boolean or(boolean a, boolean b) {
        return a || b;
    }

    public static boolean nand(boolean a, boolean b) {
        return not(and(a, b)); // oder !a || !b
    }

    public static boolean nor(boolean a, boolean b) {
        return not(or(a, b)); // oder !a && !b
    }

    public static boolean xor(boolean a, boolean b) {
        return a != b; // oder a ^ b
    }

    public static boolean xnor(boolean a, boolean b) {
        return not(xor(a, b)); // oder a == b
    }

...verschieden Vorteile..

 

[Mikeeesch]

Danke für die vielen Antworten.

Ich bin hier um einiges schlauer geworden. 🙂
Ich hoffe das ich die kommenden Aufgaben was die Logische Schaltung betrifft meistern werde :lol: