Java中getter的访问安全

Question

因此，我们创建了一个包含一些私有类成员的简单类，并自动为其生成getter。但getter实际上返回了对该成员的引用，从而获得了对私有成员的完全访问权。这样可以吗？下面是一个类的代码：

public class User {

    private ArrayList<String> strings = new ArrayList(){ {
            add("String1");
            add("String2");
        } };

    public User() {
    }

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

    public void setStrings(ArrayList<String> strings) {
        this.strings = strings;
    }
}

主要方法代码：

    public class Main {
    public static void main(String[] args){
        User user = new User();

        System.out.println(user.getStrings());
        user.getStrings().add("String3");
        System.out.println(user.getStrings());
    }
}

和输出：

[字符串1，字符串2]

[字符串1、字符串2、字符串3]

我已经将getter更改为这个：

public ArrayList<String> getStrings() {
    return (ArrayList<String>)strings.clone();
}

但问题仍然是，如果不是为了安全，吸气剂的作用是什么？什么是正确的书写方式？

Answer 1

在我看来，getter通常应该有两个目的：

• 首先，他们应该保护实施细节

如果您的示例违反了这些原则，则取决于上下文：

1. 如果您的类应该拥有这些字符串，那么可能每个人都应该与容器对象交互以修改列表，而不是列表本身。要公开集合（例如，在需要集合的方法中进行处理），可以使用集合。unmodifiableList（）。另一方面，如果类只拥有字符串列表，那么拥有列表不是实现细节
2. 使用getter而不是直接访问字段，可以轻松添加数据对话、跟踪工具和其他内容，而无需更改字段的所有使用位置

Answer 2

不，这不好，因为它破坏了封装，因此类无法维护自己的不变量。与施工人员相同。

但问题不在于getter/setter，而是自动生成它们的代码。

长话短说：不要盲目使用自动生成的访问器，如果它们处理的是可变结构，那么就制作防御性拷贝（或不可变的等价物）。

顺便说一句，我不会使用带有返回类型的数组列表的getter，即使它只是一个副本。您返回什么样的列表通常与客户无关，因此我的getter如下所示：

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

或使用不可变视图：

public List<String> getStrings() {
    return Collections.unmodifiableList(strings);
}

或者使用Guava的ImMutableList类：

public List<String> getStrings() {
    return ImmutableList.copyOf(strings);
}

这三种解决方案之间存在细微的差异，因此哪一种最好可能会有所不同。一般来说，我更喜欢返回不可变的结构，因为这清楚地表明，对结构所做的更改不会被反映出来，即，<代码>用户。getStrings（）。添加（“X”） 将失败并出现异常。

您向我们展示的代码的另一个微妙问题是双大括号的初始化。想象这样一个类：

public class Foo {
   private List<String> strings = new ArrayList() {{ add("bar");}};
   private Object veryLargeField; //the object stored here consumes a lot of memory

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

现在想象一下我们正在这样做：

private class Bar {
   private List<String> fooStrings;

   public Bar() {
     this.fooStrings = new Foo().getStrings();
   }
}

Bar会消耗多少内存（或者使用准确的术语：保留）？好吧，事实证明这相当多，因为您使用双括号初始化所做的是创建一个匿名内部类，它将包含对其外部类（Foo）的引用，因此当返回的列表可访问时，Foo的所有其他字段都将不符合垃圾回收机制的条件。