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

 

ismanettoneblog