Este documento presenta un análisis y resumen de los programas desarrollados para la evaluación de respuestas y la simulación de circuitos eléctricos domésticos, centrándose en la evolución del diseño de software y los desafíos técnicos encontrados.

Programa de Evaluación de Respuestas

Este sistema simula una prueba, procesando información de preguntas, exámenes, estudiantes y respuestas. El diseño se basa en clases abstractas como Question para manejar diferentes tipos de preguntas (estándar, opción múltiple, completar).

// Clase base para preguntas
class QuestionBase {
    protected int identifier;
    protected String questionText;
    protected String correctAnswer;
    protected int status; // 0: incorrecto, 1: parcial, 2: correcto
    protected boolean removed;

    public QuestionBase(int id, String text, String answer) {
        this.identifier = id;
        this.questionText = text;
        this.correctAnswer = answer;
        this.removed = false;
        this.status = 0;
    }

    public void evaluateAnswer(String userAnswer) {
        if (this.correctAnswer.equals(userAnswer)) {
            this.status = 2;
        } else {
            this.status = 0;
        }
    }

    public void displayResult(String userAnswer) {
        System.out.print(this.questionText + "~" + userAnswer + "~");
        switch (this.status) {
            case 0: System.out.println("false"); break;
            case 1: System.out.println("partially correct"); break;
            case 2: System.out.println("true"); break;
        }
    }
}

// Subclase para preguntas de opción múltiple
class MultipleChoiceQuestion extends QuestionBase {
    public MultipleChoiceQuestion(int id, String text, String answer) {
        super(id, text, answer);
    }

    @Override
    public void evaluateAnswer(String userAnswer) {
        if (userAnswer == null || userAnswer.isEmpty()) {
            this.status = 0;
            return;
        }
        String[] required = this.correctAnswer.split("\\s+");
        String[] provided = userAnswer.split("\\s+");
        boolean allPresent = true;
        boolean anyIncorrect = false;
        // Lógica para verificar inclusión y exactitud
        // ... Implementación de verificación ...
        if (anyIncorrect) {
            this.status = 0;
        } else if (allPresent && provided.length == required.length) {
            this.status = 2;
        } else {
            this.status = 1; // Parcialmente correcto
        }
    }
}

Simulación de Circuitos Eléctricos Domésticos - Fase 1

Este programa modela un circuito en serie simple con dispositivos de control (interruptores, reguladores de velocidad) y dispositivos controlados (lámparas, ventiladores). El objetivo es calcular el estado final de cada dispositivo.

// Clase abstracta para todos los dispositivos
abstract class ElectricalDevice {
    protected String deviceId;
    protected double inputVoltage;
    protected double outputVoltage;

    public ElectricalDevice(String id) {
        this.deviceId = id;
    }

    // Método para conectar terminal y establecer voltaje
    public abstract void setVoltageFromPin(int pinNumber, double voltage);

    // Método para obtener el voltaje de salida
    public abstract double getOutputVoltage();

    // Método para operar el dispositivo (calcular parámetro final)
    public abstract void operate();
}

// Dispositivo de control: Interruptor
class SwitchDevice extends ElectricalDevice {
    private boolean state; // false: abierto (0), true: cerrado (1)
    // Implementación con lógica que, si está abierto, corta el circuito (salida 0V)
    // ...
}

// Dispositivo controlado: Lámpara Incandescente
class IncandescentLamp extends ElectricalDevice {
    private int luminosity; // Salida calculada
    // Implementación que calcula luminosidad basada en la diferencia de potencial
    // Ejemplo: if (voltageDifference < 10) luminosity = 0; else luminosity = proportional...
    // ...
}

Simulación de Circuitos Eléctricos Domésticos - Fase 2

Esta iteración introduce circuitos paralelos, nuevos tipos de ventiladores (suelo) y consideraciones de resistencia eléctrica, haciendo el modelo más realista y complejo.

// Representa una rama del circuito en serie
class SeriesBranch extends ElectricalDevice {
    private List<ElectricalDevice> components;

    public SeriesBranch(String id) {
        super(id);
        this.components = new ArrayList<>();
    }

    public void addComponent(ElectricalDevice device) {
        this.components.add(device);
    }

    @Override
    public void setVoltageFromPin(int pinNumber, double voltage) {
        // Propagar voltaje a través de la cadena de componentes
        // Lógica simplificada para el primer componente
        if (!components.isEmpty()) {
            components.get(0).setVoltageFromPin(pinNumber, voltage);
        }
    }

    // ... cálculo de resistencia total y corriente ...
}

Reflexiones sobre el Diseño y la Implementación

El desarrollo de estos programas enfatizó la importancia de un buen diseño orientado a objetos. La utilización de clases abstractas y herencia permitió una estructura modular y extensible, donde añadir un nuevo tipo de dispositivo o circuito requiere crear una subclase e implementar métodos específicos, sin alterar el código existente que los utiliza polimórficamente.

Desafíos comunes incluyeron el manejo preciso de formatos de entrada complejos y el modelado de la lógica de cálculo de circuitos, especialmente al introducir componentes en paralelo. La depuración de problemas de cálculo de voltaje requirió inspeccionar cuidadosamente la cadena de propagación de voltaje a través de los dispositivos conectados.

En resumen, estos ejercicios fortalecen el entendimiento de conceptos como la abstracción, la herencia, el polimorfismo y el diseño de parsers, que son fundamentales en el desarrollo de software de sistemas complejos.