- 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 software 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;
  . . .
}

. . .
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);
    . . .

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.