Si puedo crear un programa que simule las puertas lógicas en Java usando el módulo de clase, ¿cómo será el comienzo?

Answer 1

La pregunta estaba redactada cuando respondí: si puedo crear un programa que simule las puertas lógicas en Java utilizando el módulo de clase, ¿cómo será el comienzo?

En una demostración de buena fe, voy a asumir que su idioma principal no es el inglés, y elegiré otra redacción que creo que es equivalente a lo que usted quiso decir. Si le gusta esta redacción, siéntase libre de editar su pregunta y pegarla (de lo contrario, no dude en avisarme si le he entendido mal):

¿Cómo debo comenzar a escribir clases Java que simulen puertas lógicas?

Si esto es lo que quiso decir, entonces lo primero que debe hacer es observar cuáles son las puertas lógicas:

• Y (A y B): Evalúa a verdadero si A y B son ambos verdaderos .
• OR (A OR B): Evalúa a verdadero si A o B es verdadero .
• NOT (NOT A): se evalúa como verdadero si A es falso.
• EOR (A EOR B): Evalúa a verdadero si A o B es verdadero , pero falso si AMBOS A y B son verdaderos . (EOR = OR exclusivo, y también se conoce como XOR).

También hay compuertas “NAND”, “NOR” y “ENOR”, que son básicamente negaciones de las compuertas básicas de arriba, y generalmente se logran simplemente tachonando una compuerta NOT frente a la otra compuerta correspondiente.

El segundo paso sería desarrollar lo que se llama una “tabla de verdad” para cada puerta. Esto le indica cuál será el resultado de la puerta con las diferentes entradas posibles. Como no sé cómo escribir tablas en Quora, esta será una lista con viñetas, pero le dará el concepto:

• A = falso, B = falso: AND = falso, OR = falso, EOR = falso
• A = verdadero, B = falso: AND = falso, OR = verdadero, EOR = verdadero
• A = falso, B = verdadero: AND = falso, OR = verdadero, EOR = verdadero
• A = verdadero, B = verdadero: AND = verdadero, OR = verdadero, EOR = falso

Nota: La puerta NOT solo toma una entrada:

• A = verdadero: NO = falso
• A = falso: NO = verdadero

Sabiendo cómo NO funciona, puede crear las tablas de verdad para NAND, NOR y ENOR:

• A = falso, B = falso: NAND = verdadero, NOR = verdadero, ENOR = verdadero
• A = verdadero, B = falso: NAND = verdadero, NOR = falso, ENOR = falso
• A = falso, B = verdadero: NAND = verdadero, NOR = falso, ENOR = falso
• A = verdadero, B = verdadero: NAND = falso, NOR = falso, ENOR = verdadero

Bien, ahora que tiene la tabla de verdad completa para todas las puertas lógicas, podría escribir clases Java que realicen cada uno de estos comportamientos. La clave está en la descripción de cada puerta. Pero antes de entrar en eso, realmente no puedo hacer esto sin mencionar que Java ya tiene operadores integrados para AND, OR y NOT:

• AND = && (a && b): dos símbolos de unión entre a y b
• OR = || (a || b) – dos tuberías verticales entre a y b
• NO =! (! a) – signo de exclamación antes de lo que se evalúa como verdadero o falso.
• EOR / XOR = ^ (a ^ b) – un símbolo de intercalación entre a y b

Dado que el operador EOR / XOR es más complicado de describir, así es como funciona usando solo AND, OR y NOT:

(a || b) &&! (a && b) // A o B es verdadero, y NO A y B son verdaderos.

Sin embargo, en un examen minucioso, hay una manera mucho más simple de escribir esto:

a! = b // A es diferente de B

Eso es “a no es igual a b”. Si tanto A como B son falsos O verdaderos, entonces la expresión se evalúa como falsa. Si son valores diferentes (no importa cuál sea verdadero), entonces esta expresión se evalúa como verdadera.

Entonces, la pregunta para usted es: “simulando puertas lógicas”, ¿quiere decir que simplemente quiere saber cómo realizar estas operaciones booleanas en Java? Si es así, no necesita escribir sus propias clases para hacer esto. Sin embargo, si es que está escribiendo un programa que le permite construir diagramas de circuitos eléctricos o algo similar, donde necesita un módulo “enchufable” que literalmente representa una puerta lógica, entonces recomendaría algo como lo siguiente:

• Defina una clase base llamada LogicGate , que por sí sola no necesita hacer nada, pero puede tener algunas propiedades que su UI usa (por ejemplo, su posición en la pantalla, a qué más está conectada, etc.).

clase abstracta pública LogicGate {
}

• Defina dos interfaces: UnaryGate y BinaryGate . Estas interfaces definen métodos que las clases que las implementan deben implementar. UnaryGate es para la puerta NOT, que solo toma una entrada, y BinaryGate es para todas las otras puertas, que toman dos entradas.

interfaz pública UnaryGate {
evaluación booleana (valor booleano);
}

interfaz pública BinaryGate {
evaluación booleana (booleana a, booleana b);
}

• Implementa tus puertas. Extienda LogicGate para que cada clase sea un tipo de LogicGate e implemente UnaryGate o BinaryGate . Por ejemplo, implementemos la puerta XOR:

La clase pública XorGate extiende LogicGate implementa BinaryGate {
@Anular
evaluación pública booleana (booleana a, booleana b) {
devuelve a! = b;
}
}

Ahora, si me ha seguido toda esta respuesta, acaba de leer cómo un ingeniero de software aborda un problema de diseño. 🙂

(Un agradecimiento especial a Quora User por corregirme en el operador XOR: solía ser que el operador “^” solo funcionaba como un operador bit a bit, y hay algunos temas de StackExchange sobre este tema. Sin embargo, parece que Oracle desde entonces cambié esto, y simplemente no me di cuenta.)