Come posso impedire la modifica di un campo privato in una classe?

Immagina di avere questa classe:

public class Test
{
  private String[] arr = new String[]{"1","2"};    

  public String[] getArr() 
  {
    return arr;
  }
}

Ora, ho un'altra classe che utilizza la classe sopra:

Test test = new Test();
test.getArr()[0] ="some value!"; //!!!

Quindi questo è il problema: ho avuto accesso a un campo privato di una classe dall'esterno! Come posso impedirlo? Voglio dire, come posso rendere questo array immutabile? Questo significa che con ogni metodo getter puoi salire di livello per accedere al campo privato? (Non voglio biblioteche come Guava. Devo solo conoscere il modo giusto per farlo).

È necessario restituire una copia dell'array.

public String[] getArr() {
  return arr == null ? null : Arrays.copyOf(arr, arr.length);
}

Se è possibile utilizzare un Elenco anziché un array, Collezioni fornisce un elenco non modificabile :

public List<String> getList() {
    return Collections.unmodifiableList(list);
}

Il modificatore privateprotegge solo il campo stesso dall'accesso da altre classi, ma non i riferimenti agli oggetti da questo campo. Se devi proteggere un oggetto referenziato, non darlo. Modificare

public String [] getArr ()
{
    return arr;
}

per:

public String [] getArr ()
{
    return arr.clone ();
}

o a

public int getArrLength ()
{
    return arr.length;
}

public String getArrElementAt (int index)
{
    return arr [index];
}

Il Collections.unmodifiableListè già stato menzionato - il Arrays.asList()stranamente no! La mia soluzione sarebbe anche quella di utilizzare l'elenco dall'esterno e avvolgere l'array come segue:

String[] arr = new String[]{"1", "2"}; 
public List<String> getList() {
    return Collections.unmodifiableList(Arrays.asList(arr));
}

Il problema con la copia dell'array è: se lo fai ogni volta che accedi al codice e l'array è grande, creerai sicuramente molto lavoro per il Garbage Collector. Quindi la copia è un approccio semplice ma davvero pessimo - direi "economico", ma costoso per la memoria! Soprattutto quando hai più di 2 soli elementi.

Se guardi il codice sorgente di Arrays.asListe in Collections.unmodifiableListrealtà non c'è molto da creare. Il primo avvolge l'array senza copiarlo, il secondo avvolge semplicemente l'elenco, rendendolo non disponibile.

Puoi anche usare ImmutableListquale dovrebbe essere migliore dello standard unmodifiableList. La classe fa parte di Guava librerie create da Google.

Ecco la descrizione:

A differenza di Collections.unmodifiableList (java.util.List), che è una vista di una raccolta separata che può ancora cambiare, un'istanza di ImmutableList contiene i propri dati privati ​​e non cambierà mai

Ecco un semplice esempio di come usarlo:

public class Test
{
  private String[] arr = new String[]{"1","2"};    

  public ImmutableList<String> getArr() 
  {
    return ImmutableList.copyOf(arr);
  }
}

a questo punto di vista dovresti usare la copia dell'array di sistema:

public String[] getArr() {
   if (arr != null) {
      String[] arrcpy = new String[arr.length];
      System.arraycopy(arr, 0, arrcpy, 0, arr.length);
      return arrcpy;
   } else
      return null;
   }
}

È possibile restituire una copia dei dati. Il chiamante che sceglie di modificare i dati cambierà solo la copia

public class Test {
    private static String[] arr = new String[] { "1", "2" };

    public String[] getArr() {

        String[] b = new String[arr.length];

        System.arraycopy(arr, 0, b, 0, arr.length);

        return b;
    }
}

Il nocciolo del problema è che stai restituendo un puntatore a un oggetto mutabile. Ops. O si rende l'oggetto immutabile (la soluzione dell'elenco non modificabile) o si restituisce una copia dell'oggetto.

In generale, la finalità degli oggetti non protegge gli oggetti dal cambiamento se sono mutabili. Questi due problemi sono "baciare i cugini".

Restituire un elenco non modificabile è una buona idea. Ma un elenco reso non modificabile durante la chiamata al metodo getter può ancora essere modificato dalla classe o dalle classi derivate dalla classe.

Invece dovresti chiarire a chiunque estenda la classe che l'elenco non dovrebbe essere modificato.

Quindi nel tuo esempio potrebbe portare al seguente codice:

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test {
    public static final List<String> STRINGS =
        Collections.unmodifiableList(
            Arrays.asList("1", "2"));

    public final List<String> getStrings() {
        return STRINGS;
    }
}

Nell'esempio sopra ho realizzato il STRINGS pubblico campo, in linea di principio potresti eliminare la chiamata al metodo, poiché i valori sono già noti.

È inoltre possibile assegnare le stringhe a un private final List<String>campo reso non modificabile durante la costruzione dell'istanza di classe. L'uso di una costante o argomenti di istanza (del costruttore) dipende dal design della classe.

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Test {
    private final List<String> strings;

    public Test(final String ... strings) {
        this.strings = Collections.unmodifiableList(Arrays
                .asList(strings));
    }

    public final List<String> getStrings() {
        return strings;
    }
}

Sì, è necessario restituire una copia dell'array:

 public String[] getArr()
 {
    return Arrays.copyOf(arr);
 }