Java Programma Che Tramite Le Classi Simuli Una Calcolatrice

Creare una calcolatrice in Java utilizzando il paradigma della programmazione orientata agli oggetti (OOP) è un esercizio fondamentale per comprendere i principi di incapsulamento, ereditarietà, polimorfismo e astrazione. Questa guida dettagliata ti condurrà attraverso tutti i passaggi necessari per implementare una calcolatrice funzionale, estendibile e ben strutturata.

1. Introduzione ai Concetti OOP per una Calcolatrice

Prima di immergerci nel codice, è essenziale comprendere come i principi OOP possano essere applicati a una calcolatrice:

• Incapsulamento: Nascondere i dettagli implementativi e esporre solo i metodi necessari (es: add(), subtract()).
• Ereditarietà: Creare una gerarchia di classi (es: BasicCalculator → ScientificCalculator).
• Polimorfismo: Utilizzare lo stesso metodo (es: calculate()) con implementazioni diverse.
• Astrazione: Definire un’interfaccia Calculator con metodi astratti.

2. Struttura del Progetto

Una buona struttura del progetto è fondamentale. Ecco come organizzare i file:

// Struttura consigliata
src/
├── main/
│ ├── java/
│ │ ├── com/
│ │ │ ├── example/
│ │ │ │ ├── calculator/
│ │ │ │ │ ├── Calculator.java (Interfaccia)
│ │ │ │ │ ├── BasicCalculator.java
│ │ │ │ │ ├── ScientificCalculator.java
│ │ │ │ │ └── Main.java
│ │ │ │ └── exception/
│ │ │ │ └── DivisionByZeroException.java
│ └── resources/
└── test/
├── java/
│ └── com/example/calculator/
│ ├── BasicCalculatorTest.java
│ └── ScientificCalculatorTest.java

3. Implementazione Passo-Passo

3.1 Interfaccia Calculator

Definiamo un’interfaccia che dichiara i metodi comuni a tutte le calcolatrici:

public interface Calculator {
  double add(double a, double b);
  double subtract(double a, double b);
  double multiply(double a, double b);
  double divide(double a, double b) throws DivisionByZeroException;
  double calculate(double a, double b, String operation) throws DivisionByZeroException;
}

3.2 Classe BasicCalculator

Implementazione concreta dell’interfaccia con operazioni di base:

public class BasicCalculator implements Calculator {
  @Override
  public double add(double a, double b) {
    return a + b;
  }

  @Override
  public double subtract(double a, double b) {
    return a – b;
  }
  // … (altri metodi)

  @Override
  public double calculate(double a, double b, String operation) throws DivisionByZeroException {
    switch(operation) {
      case “add”: return add(a, b);
      case “subtract”: return subtract(a, b);
      // …
      default: throw new IllegalArgumentException(“Operazione non valida”);
    }
  }
}

3.3 Classe ScientificCalculator (Ereditarietà)

Estendiamo BasicCalculator aggiungendo funzionalità scientifiche:

public class ScientificCalculator extends BasicCalculator {
  public double power(double base, double exponent) {
    return Math.pow(base, exponent);
  }

  public double modulus(double a, double b) {
    return a % b;
  }

  @Override
  public double calculate(double a, double b, String operation) throws DivisionByZeroException {
    switch(operation) {
      case “power”: return power(a, b);
      case “modulus”: return modulus(a, b);
      default: return super.calculate(a, b, operation);
    }
  }
}

3.4 Gestione delle Eccezioni

Creiamo un’eccezione personalizzata per la divisione per zero:

public class DivisionByZeroException extends Exception {
  public DivisionByZeroException() {
    super(“Divisione per zero non permessa”);
  }
}

3.5 Classe Main (Demo)

Esempio di utilizzo con input utente:

public class Main {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    Calculator calculator = new ScientificCalculator();

    System.out.print(“Inserisci primo numero: “);
    double a = scanner.nextDouble();

    System.out.print(“Inserisci operazione (add/subtract/…): “);
    String op = scanner.next();

    try {
      double result = calculator.calculate(a, b, op);
      System.out.printf(“Risultato: %.2f%n”, result);
    } catch (DivisionByZeroException e) {
      System.err.println(“Errore: ” + e.getMessage());
    }
  }
}

4. Test Unitari con JUnit 5

I test sono essenziali per garantire l’affidabilità del codice:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class BasicCalculatorTest {
  private final Calculator calculator = new BasicCalculator();

  @Test
  void testAdd() {
    assertEquals(5, calculator.add(2, 3));
    assertEquals(0, calculator.add(-2, 2));
  }

  @Test
  void testDivideByZero() {
    assertThrows(DivisionByZeroException.class, () -> {
      calculator.divide(5, 0);
    });
  }
}

5. Confronto tra Approcci

Analizziamo le differenze tra un’implementazione procedurale e OOP:

Criterio	Approccio Procedurale	Approccio OOP
Estendibilità	Difficile (richiede modifiche al codice esistente)	Facile (basta estendere la classe)
Manutenibilità	Bassa (codice monolitico)	Alta (moduli separati)
Riusabilità	Limitata	Elevata (ereditarietà e polimorfismo)
Gestione errori	Basica (return codes)	Avanzata (eccezioni personalizzate)
Performance	Leggermente migliore (meno overhead)	Leggermente inferiore (ma trascurabile)

6. Ottimizzazioni Avanzate

6.1 Pattern Strategy per Operazioni

Possiamo migliorare ulteriormente l’estendibilità usando il pattern Strategy:

public interface OperationStrategy {
  double execute(double a, double b);
}

public class AddOperation implements OperationStrategy {
  @Override
  public double execute(double a, double b) {
    return a + b;
  }
}

6.2 Uso di Enum per le Operazioni

Gli enum possono rendere il codice più leggibile e type-safe:

public enum Operation {
  ADD(“+”) {
    @Override
    public double apply(double a, double b) { return a + b; }
  },
  SUBTRACT(“-“) {
    @Override
    public double apply(double a, double b) { return a – b; }
  };

  public abstract double apply(double a, double b);
  private final String symbol;

  Operation(String symbol) {
    this.symbol = symbol;
  }
}

7. Integrazione con Interfacce Grafiche

Per creare un’interfaccia utente, possiamo usare JavaFX o Swing. Ecco un esempio minimale con JavaFX:

public class CalculatorGUI extends Application {
  private Calculator calculator = new ScientificCalculator();

  @Override
  public void start(Stage stage) {
    TextField display = new TextField();
    display.setEditable(false);

    Button addButton = new Button(“+”);
    addButton.setOnAction(e -> {
      // Logica per l’addizione
    });

    VBox layout = new VBox(10, display, addButton /*, altri bottoni */);
    Scene scene = new Scene(layout, 300, 400);
    stage.setScene(scene);
    stage.show();
  }
}

8. Best Practices e Consigli

• Usa sempre final per variabili che non devono essere modificate.
• Preferisci la composizione all’ereditarietà quando possibile (principio “favor composition over inheritance”).
• Documenta il codice con JavaDoc per tutte le classi e metodi pubblici.
• Usa BigDecimal invece di double per calcoli finanziari che richiedono precisione assoluta.
• Implementa l’interfaccia Serializable se vuoi salvare lo stato della calcolatrice.
• Considera l’uso di annotazioni come @FunctionalInterface per le strategie.
• Per progetti complessi, usa un framework di dependency injection come Spring.

9. Risorse Esterne Autorevoli

Per approfondire i concetti OOP in Java:

• Documentazione Ufficiale Oracle su OOP in Java
• Guida GeeksforGeeks su OOP in Java
• The Art and Science of Java (Stanford University)

10. Statistiche sull’Uso di Java

Java rimane uno dei linguaggi più popolari per l’insegnamento della programmazione orientata agli oggetti:

Metrica	Valore (2023)	Fonte
Popolarità tra linguaggi di programmazione	3° posto (dopo Python e JavaScript)	TIOBE Index
Percentuale di progetti accademici che usano Java per insegnare OOP	62%	IEEE Spectrum
Numero di domande su Stack Overflow con tag [java] e [oop]	~120,000	Stack Overflow Trends
Percentuale di sviluppatori che considerano Java “essenziale” per la carriera	78%	JetBrains State of Developer Ecosystem 2023

11. Esempio Completo con Design Pattern

Ecco come potresti strutturare il progetto usando il pattern Factory:

public class CalculatorFactory {
  public static Calculator createCalculator(String type) {
    switch(type.toLowerCase()) {
      case “basic”: return new BasicCalculator();
      case “scientific”: return new ScientificCalculator();
      default: throw new IllegalArgumentException(“Tipo di calcolatrice non valido”);
    }
  }
}

public class Main {
  public static void main(String[] args) {
    Calculator calc = CalculatorFactory.createCalculator(“scientific”);
    // Utilizzo della calcolatrice
  }
}

12. Domande Frequenti

12.1 Qual è la differenza tra una classe astratta e un’interfaccia in questo contesto?

In questo progetto, un’interfaccia (Calculator) è più appropriata perché:

• Definisce un contratto (cosa deve fare) senza implementazione.
• Permette l’implementazione multipla (una classe può implementare più interfacce).
• È più flessibile per future estensioni.

Una classe astratta sarebbe utile se avessimo del codice comune da condividere tra le implementazioni.

12.2 Come gestire operazioni con più di due operandi?

Puoi estendere l’interfaccia Calculator:

public interface AdvancedCalculator extends Calculator {
  double sum(double… operands);
  double average(double… operands);
}

12.3 È possibile implementare questa calcolatrice in modo thread-safe?

Sì, puoi:

• Usare synchronized sui metodi.
• Rendere la classe immutable (senza stato interno modificabile).
• Usare ThreadLocal per variabili specifiche del thread.

13. Conclusione

Implementare una calcolatrice in Java usando le classi e i principi OOP è un esercizio estremamente formativo che ti prepara a affrontare progetti software più complessi. Questo approccio:

• Migliora la manutenibilità del codice.
• Facilita l’estendibilità per future funzionalità.
• Insegna a gestire correttamente eccezioni e errori.
• Prepara all’uso di design pattern avanzati.

Ricorda che la chiave per diventare un buon programmatore Java è la pratica costante e lo studio dei principi di design del software. Inizia con questo progetto, poi prova ad aggiungere nuove funzionalità come:

• Supporto per numeri complessi.
• Storico delle operazioni (pattern Command).
• Interfaccia grafica avanzata con JavaFX.
• Integrazione con un database per salvare i calcoli.