¿Cómo evito la modificación de un campo privado en una clase?

Imagina que tengo esta clase:

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

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

Ahora, tengo otra clase que usa la clase anterior:

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

Este es el problema: ¡he accedido a un campo privado de una clase desde afuera! ¿Cómo puedo prevenir esto? Quiero decir, ¿cómo puedo hacer que esta matriz sea inmutable? ¿Significa esto que con cada método getter puedes avanzar para acceder al campo privado? (No quiero ninguna biblioteca como Guava. Solo necesito saber la forma correcta de hacerlo).

Debes devolver un copia de su matriz.

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

Si puede usar una Lista en lugar de una matriz, Colecciones proporciona una lista no modificable :

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

El modificador privateprotege solo el campo mismo del acceso desde otras clases, pero no las referencias a objetos de este campo. Si necesita proteger el objeto referenciado, simplemente no lo entregue. Cambio

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

a:

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

o para

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

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

El Collections.unmodifiableListya ha sido mencionado, ¡ Arrays.asList()curiosamente no! Mi solución también sería usar la lista desde el exterior y envolver la matriz de la siguiente manera:

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

El problema con la copia de la matriz es: si lo hace cada vez que accede al código y la matriz es grande, seguramente creará mucho trabajo para el recolector de basura. Por lo tanto, la copia es un enfoque simple pero realmente malo: yo diría "barato", ¡pero costoso para la memoria! Especialmente cuando tienes más de 2 elementos.

Si nos fijamos en el código fuente de Arrays.asListy en Collections.unmodifiableListrealidad no hay mucho creado. El primero simplemente envuelve la matriz sin copiarla, el segundo simplemente envuelve la lista, haciendo que los cambios no estén disponibles.

También puede usar ImmutableListcuál debería ser mejor que el estándar unmodifiableList. La clase es parte de las bibliotecas de guayaba que fue creada por Google.

Aquí está la descripción:

A diferencia de Collections.unmodifiableList (java.util.List), que es una vista de una colección separada que aún puede cambiar, una instancia de ImmutableList contiene sus propios datos privados y nunca cambiará

Aquí hay un ejemplo simple de cómo usarlo:

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

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

en este punto de vista, debe usar la copia de la matriz del 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;
   }
}

Puede devolver una copia de los datos. La persona que llama que elige cambiar los datos solo cambiará 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;
    }
}

El meollo del problema es que está devolviendo un puntero a un objeto mutable. Ups O representa el objeto inmutable (la solución de lista no modificable) o devuelve una copia del objeto.

Como cuestión general, la finalidad de los objetos no protege a los objetos de ser cambiados si son mutables. Estos dos problemas son "besar primos".

Devolver una lista no modificable es una buena idea. Pero una lista que no se puede modificar durante la llamada al método getter puede ser cambiada por la clase o las clases derivadas de la clase.

En su lugar, debe dejar en claro a cualquiera que extienda la clase que la lista no debe modificarse.

Entonces, en su ejemplo, podría conducir al siguiente código:

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

En el ejemplo anterior, hice STRINGSpúblico el campo, en principio, podría eliminar la llamada al método, ya que los valores ya se conocen.

También puede asignar las cadenas a un private final List<String>campo que no se puede modificar durante la construcción de la instancia de clase. El uso de argumentos constantes o de instanciación (del constructor) depende del diseño de la clase.

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í, debe devolver una copia de la matriz:

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