# Logische Schaltungen nachbauen.



## Mikeeesch (18. Apr 2012)

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 (18. Apr 2012)

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 (18. Apr 2012)

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 (18. Apr 2012)

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 (18. Apr 2012)

Klick mich


----------



## diggaa1984 (18. Apr 2012)

Java-Star hat gesagt.:


> 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 (18. Apr 2012)

Java-Star hat gesagt.:


> 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:
> 
> ...



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 (18. Apr 2012)

AquaBall hat gesagt.:


> ```
> AND:  return (bEingang1 && bEingang2);
> OR:   return (bEingang1 || bEingang2);
> XOR:  return (bEingang1 != bEingang2);
> ...


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 (18. Apr 2012)

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 (18. Apr 2012)

AquaBall hat gesagt.:


> 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 (18. Apr 2012)

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


----------



## diggaa1984 (18. Apr 2012)

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


----------



## irgendjemand (18. Apr 2012)

diggaa1984 hat gesagt.:


> Nun hat ja doch einer alles verraten (mit Ausnahme vom NAND) ^^
> 
> der Vollständigkeit halber:
> 
> ...



"^" 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 (18. Apr 2012)

diggaa1984 hat gesagt.:


> 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 (18. Apr 2012)

diggaa1984 hat gesagt.:


> 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 (18. Apr 2012)

irgendjemand hat gesagt.:


> "^" 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);
	}
}
```



irgendjemand hat gesagt.:


> 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 (18. Apr 2012)

diggaa1984 hat gesagt.:


> Die Insel sagt:
> 
> 
> ```
> ...



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 (18. Apr 2012)

irgendjemand hat gesagt.:


> 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 (18. Apr 2012)

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 (18. Apr 2012)

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:


----------

