1
|
2 |
3 |
4
4 - Unità didattica 5.4)
Elenco delle pagine di "Il
linguaggio Java: lez.6"
Introduzione e Unità didattica 5.1) - Pagina 1
Introduzione e Unità didattica 5.2) - Pagina 2
Unità didattica 5.3) - Pagina 3
Unità didattica 5.4) - Pagina 4
Unità didattica 5.5) - Pagina 5
Unità didattica 5.6) - Pagina 6
- Quando utilizzare
l’incapsulamento
Se volessimo essere brevi, la
risposta alla domanda del titolo di quest’unità didattica, dovrebbe
essere "sempre". Una qualsiasi classe di una qualsiasi applicazione
dovrebbe essere sviluppata utilizzando l’incapsulamento. Anche se
all’inizio di un progetto può sembrarci che su determinate
classi usufruire dell’incapsulamento sia superfluo, l’esperienza
c’insegna che è preferibile l’applicazione in ogni situazione.
Facciamo un esempio banale. Abbiamo già accennato al fatto, peraltro
scontato, che per realizzare un’applicazione a qualsiasi livello
(sempre che non sia veramente banale), bisogna apportare a questa,
modifiche incrementali. Un lettore con un minimo d’esperienza di
programmazione non potrà che confermare l’ultima affermazione.
Supponiamo di voler scrivere una semplice applicazione che assegnati
due punti, disegni il segmento che li unisce. Supponiamo inoltre che
questa utilizzi la seguente classe non incapsulata Punto, già
incontrata nel modulo 2:
class Punto
{
public int x, y;
. . .
}
l’applicazione, in un primo momento, istanzierà ed inizializzerà due
punti con il seguente frammento di codice:
. . .
2) Punto p1=new Punto();
Punto p2=new Punto();
p1.x=5;
p1.y=6;
p2.x=10;
p2.y=20;
. . .
Supponiamo che l’evolversi della
nostra applicazione renda necessario che i due punti non debbano
trovarsi al di fuori di un certo area piana ben delimitata. Ecco
risultare evidente che la soluzione migliore sia quella di
implementare l’incapsulamento all’interno della classe Punto in
questo modo;
class Punto
{
private int x, y;
private final int valoreMassimoPerX=10 ;
private final int valoreMinimoPerX=10 ;
private final int valoreMassimoPerY=10 ;
private final int valoreMinimoPerY=10 ;
public void setX(int a)
{
if (a <= valoreMassimoPerX &&
a >= valoreMinimoPerX)
{
x=a;
System.out.println("X è OK!");
}
else
{
System.out.println("X non valida");
}
}
public void setY(int a)
{
if (a <= valoreMassimoPerY &&
a >= valoreMinimoPerY)
{
y=a;
System.out.println("Y è OK!");
}
else
{
System.out.println("Y non valida");
}
}
. . .
}
Purtroppo però, dopo aver
apportato queste modifiche alla classe Punto, saremo costretti a
modificare anche il frammento di codice 2) dell’applicazione nel
modo seguente:
3) Punto p1=new Punto();
Punto p2=new Punto();
p1.setX(5);
p1.setY(6);
p2.setX(10);
p2.setY(20);
. . .
Saremmo partiti meglio con la classe Punto
forzatamente incapsulata in questo modo:
class Punto
{
private int x, y;
public void setX(int a)
{
x=a;
}
public void setY(int a)
{
y=a;
}
. . .
}
dal momento che avremmo modificato solo il codice all’interno dei
metodi di accesso, e saremmo stati costretti al codice 3)
all’interno dell’applicazione che utilizza Punto.
Arriviamo alla conclusione che l’incapsulamento è prassi ed obbligo
in Java. Un linguaggio orientato agli oggetti "puro", infatti, non
permetterebbe la dichiarazione di attributi pubblici. Java però,
vuole essere un linguaggio semplice da apprendere, ed in questo
modo, non costringe l’aspirante programmatore ad imparare
prematuramente, un concetto ad ogni modo complesso quale
l’incapsulamento. In particolare, nei primi tempi, non se ne
apprezzerebbe completamente l’utilizzo, dovendo comunque approcciare
con troppi concetti nuovi contemporaneamente.
Tuttavia, non bisognerebbe mai permettere di sacrificare
l’incapsulamento per risparmiare qualche secondo di programmazione,
le conseguenze sono ormai note al lettore.
Elenco delle pagine di "Il linguaggio Java: lez.6"
Introduzione e Unità didattica 5.1) - Pagina 1
Introduzione e Unità didattica 5.2) - Pagina 2
Unità didattica 5.3) - Pagina 3
Unità didattica 5.4) - Pagina 4
Unità didattica 5.5) - Pagina 5
Unità didattica 5.6) - Pagina 6