如何防止在班级中修改私有字段？

想象一下我有这堂课：

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

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

现在，我有另一个使用上述类的类：

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

这就是问题所在：我已经从外部访问了班级的私有领域！我该如何预防？我的意思是如何使该数组不可变？这是否意味着您可以使用每种获取方法来逐步访问私有字段？（我不需要像Guava这样的任何库。我只需要知道执行此操作的正确方法）。

您必须返回阵列的副本。

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

如果可以使用列表而不是数组，则Collections提供一个不可修改的列表：

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

修饰符private仅保护字段本身不被其他类访问，而不能保护此字段引用的对象。如果您需要保护引用的对象，请不要将其分发出去。更改

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

至：

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

或者

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

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

在Collections.unmodifiableList已经提到-的Arrays.asList()奇怪不是！我的解决方案还将是从外部使用列表，并将数组包装如下：

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

复制数组的问题是：如果每次访问代码时都这样做，并且数组很大，那么肯定会为垃圾收集器创建很多工作。因此，复制是一种简单但非常糟糕的方法-我会说“便宜”，但内存昂贵！特别是当您有两个以上元素时。

如果你看一下源代码Arrays.asList和Collections.unmodifiableList有其实不多创建。第一个只包装数组而不复制它，第二个只包装列表，使对它的更改不可用。

您也可以使用ImmutableList哪个应该比标准更好unmodifiableList。该类是Google创建的Guava库的一部分。

说明如下：

与Collections.unmodifiableList（java.util.List）（它是仍可以更改的单独集合的视图）不同，ImmutableList实例包含其自己的私有数据，并且永远不会更改

这是一个简单的用法示例：

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

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

在这种情况下，您应该使用系统阵列副本：

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

您可以返回数据的副本。选择更改数据的呼叫者只会更改副本

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

问题的根源在于您正在返回一个指向可变对象的指针。哎呀。您要么使对象变得不可变（不可修改的列表解决方案），要么返回对象的副本。

通常，如果对象是可变的，则对象的终结性不能保护它们不被更改。这两个问题是“亲吻表亲”。

返回一个不可修改的列表是一个好主意。但是，在调用getter方法期间无法修改的列表仍可以由该类或从该类派生的类来更改。

相反，您应该向扩展类的任何人明确表示不应该修改列表。

因此，在您的示例中，它可能导致以下代码：

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

在上面的示例中，我将 STRINGS字段公开，原则上您可以取消方法调用，因为这些值是已知的。

您也可以将字符串分配给private final List<String>在构造类实例期间不可修改的字段。使用（构造函数的）常量或实例化参数取决于类的设计。

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

是的，您应该返回数组的一个副本：

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