Calcolatrice in Java: esempi di DP

Calcolatrice in Java: esempi di DP
In questo articolo vedremo come realizzare una piccola calcolatrice in Java,
che ci permetterà di mettere in evidenza alcuni design pattern molto utili
quando si programma.
java
L’idea di questa semplice calcolatrice in Java è quella di poter eseguire la
somma delle principali operazioni matematiche, ovvero somma, sottrazione,
moltiplicazione e divisione tra due numeri, interi oppure frazionari.
Una volta che si inseriscono i due numeri basterà selezionare l’operazione e
il button “Calculate” per poter effettuare l’operazione richiesta.
Design pattern presenti
In questa applicazione Java è possibile trovare i seguenti design pattern:
Proxy: serve per poter decidere a run-time il tipo di operazione
MVC: serve per separare il modello, il controllo e la vista
Strategy: serve per creare un algoritmo in grado di essere facilmente
aggiornabile (è possibile aggiungere una nuova operazione e instanziarla
in una sola classe)
Il principale elemento del codice è l’interfaccia IOperation che permette di
facilitare notevolmente la scrittura del codice. Infatti, se una ci pensa
qualche secondo, una qualsiasi operazione matematiche, ha in ingresso dei
numeri (double in questo caso) e restituisce un risultato.
package mathoperation;
public interface IOperation {
/**
* This method allows to calculate the result of the operation
* @param p1
* @param p2
*/
public void calculate(Double p1, Double p2);
/**
* This method let the user to retrive the result calculated
* @return
*/
public String getResut();
}
Ovviamente ogni operazione avrà un algoritmo diverso, ma questo viene tenuto
in considerazione nelle classi concrete che implementano l’interfaccia.
Tornando ai DP, perché è necessario usare un Proxy ? L’utilizzo del Proxy
serve per poter cambiare facilmente a run-time un oggetto che in questo caso
è la nostra operazione matematica. In sostanza, sarebbero richieste troppe
modifiche se l’interfaccia grafica dipendesse dalle singole operazione e non
dal proxy (se si dovessero aggiungere delle operazioni, sarebbe necessario
modificare le classi della grafica). In questo caso, il Proxy viene
“inglobato” nel DP MVC; in questo caso il modello è l’operazione matematica,
che viene sostituta dalla classe concreta Proxy (che sarebbe il delegato,
cioè quel componente a cui viene chiesto qualcosa, un’operazione).
E la strategy ? Un aspetto molto importante del codice è aggiungere
un’operazione matematica è davvero semplice, questo grazie all’utilizzo della
classe OperantionsAvaible:
package mathoperation;
import java.util.ArrayList;
import java.util.HashMap;
public class OperationsAvaible {
private static OperationsAvaible avaible = new OperationsAvaible();
private ArrayList<IOperation> operations = new ArrayList<>();
private HashMap<IOperation, String> symbolOperations = new
HashMap<>();
private OperationsAvaible(){
createList();
setSymbol();
}
public void createList(){
operations.add(new Sum());
operations.add(new Subtraction());
operations.add(new Multiplication());
operations.add(new Division());
}
public void setSymbol(){
String[] value = {"+","-","*","÷"};
for (int i = 0; i < operations.size(); i++) {
symbolOperations.put(operations.get(i), value[i]);
}
}
public ArrayList<IOperation> getOperations() {
return operations;
}
public static OperationsAvaible getAvaible() {
return avaible;
}
public HashMap<IOperation, String> getSymbolOperations() {
return symbolOperations;
}
}
Come si può intuire, per poter aggiungere un’operazione è necessario creare
la classe concreta che implementa l’interfaccia IOperation ed inserirla
nell’ArrayList della classe OperantionsAvaible.
Conclusione
Dal momento che l’idea del progetto è abbastanza semplice (creare una
semplice calcolatrice), è possibile imparare in maniera facile alcuni
importanti design pattern in Java, quali il Proxy e il MVC (Model View
Controller). Ci sono alcuni metodi importanti, che non sono stati analizzati
in profondità. Il più importante tra questi è il metodo public void update()
della classe ProxyOperation, che permette di aggiornare il pannello (View),
quando viene premuto il Button (del Controller). Il codice completo è
possibile scaricarlo da questa repo:
https://github.com/jackbell16/Calculator