Concetti di base di Java: polimorfismo
In questo quinto post, sarà discusso il polimorfismo, uno dei più importanti
concetti di base di Java.
Il polimorfismo è uno dei concetti la cui definizione è di facile
comprensione, ma per capire completamente il concetto e sopratutto per
applicarlo correttamente, è necessario del tempo.
Ecco una definizione tratta da Wikipedia:
In informatica, il termine polimorfismo (dal greco πολυμορφοσ composto dai
termini πολυ molto e μορφή forma quindi “avere molte forme”) viene usato in
senso generico per riferirsi a espressioni che possono rappresentare valori
di diversi tipi (dette espressioni polimorfiche). In un linguaggio non
tipizzato, tutte le espressioni sono intrinsecamente polimorfiche.
Vantaggi
Il polimorfismo per inclusione permette al programma di fare uso di oggetti
che espongono una stessa interfaccia, ma implementazioni diverse. Infatti,
l’interfaccia del tipo base definisce un contratto generale che sottoclassi
diverse possono soddisfare in modi diversi – ma tutti conformi alla specifica
comune stabilita dal tipo base. Di conseguenza, la parte del programma che
fruisce di questa interfaccia – chiamata in gergo client – tratta in modo
omogeneo tutti gli oggetti che forniscono un dato insieme di servizi, a
prescindere dalle loro implementazioni interne (presumibilmente diverse tra
loro) definite dalle rispettive classi. In virtù di questa possibilità, si
può utilizzare lo stesso codice personalizzandone o modificandone anche
radicalmente il comportamento, senza doverlo riscrivere, ma semplicemente
fornendogli in inputuna differente implementazione del tipo base o dei tipi
base.
Se usato bene, il polimorfismo permette di avere una struttura ad oggetti
estensibile, in quanto si può indurre il client ad invocare nuovi metodi
personalizzati includendoli in una classe apposita;
resistente, perché eventuali esigenze future nel programma o nella
scrittura del codice potranno essere implementate fornendo ad
un client già scritto una nuova classe scritta ad hoc.
Da queste righe di introduzione del concetto di polimorfismo è intuibile
quanto detto in precedenza, riguardo alla difficoltà di comprendere
correttamente il suo utilizzo. Si può dire che questo aspetto di Java,
permette di rendere più robusto il codice e sopratutto sarà più semplice
aggiungere funzionalità aggiuntive.
Vediamo un primo esempio:
Fattoria
package utils;
public interface Animale {
public void emetteVerso();
}
Con questa struttura di codice è possibile aggiungere qualsiasi tipo di
animale, basterà che implementi la sua interfaccia e quindi dovrà emettere un
verso !
Disegnabile
package utils;
import java.awt.Graphics;
public interface Disegnabile {
public void disegna(Graphics graphics);
}
/**
* Questa classe ha la responsabilità di disegnare tutti gli elementi
* in un pannello
* @author Giacomo
*/
package utils;
import java.awt.Graphics;
import java.util.ArrayList;
import javax.swing.JPanel;
public class Pannello extends JPanel {
private static final long serialVersionUID = 1L;
private ArrayList<Disegnabile> disegnabili = new ArrayList<>();
public void aggiungiDisegnabile(Disegnabile disegnabile){
disegnabili.add(disegnabile);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
for (int i = 0; i < disegnabili.size(); i++) {
disegnabili.get(i).disegna(g);
}
}
}
Attraverso l’interfaccia disegnabile, sarà possibile aggiungere al pannello
qualsiasi figura geometria, come ad esempio un rombo, quadrato etc…
Conclusione
Far dipendere i componenti del proprio progetto da Interfaccia, permette di
dare robustezza al nostro software e lo rende facilmente gestibile sia per
nuove implementazioni, sia per refactoring.
I codici presenti in questo post, come del resto tutti quelli delle lezioni
precedenti, sono scaricabili dalla repo di Github, all’indirizzo
https://github.com/jackbell16/JavaCode
