effective java（13） 之使类和成员的可访问性最小化

effective java 之使类和成员的可访问性最小化

1、区别设计良好的模块和设计不好的模块，最重要的因素在于，这个模块对于外部的其他模块而言，是否隐藏其内部数据和其他实现细节。
设计良好的模块会隐藏所有的实现细节，把它的API于它的实现清晰地隔离开来。

然后，模块之间通过它们的API进行通信，一个模块不需要知道其他模块的内部工作情况，这个概念称为信息隐藏或封装。

2、封装的重要性在于：可以有效地解除组成系统的各模块之间的耦合关系，使得这些模块可以独立地开发、测试、优化、使用、理解和修改。

封装本身不会带来更好的性能，但是它可以有效地调节性能：一旦完成一个系统，并通过剖析确定哪些模块影响了系统的性能，这部分模块就可以被进一步优化，而不影响其他模块的正确性，提高软件的可重用性。

3、对于顶层的（非嵌套的）类和接口，只有两种可能的访问级别，包级私有的和公有的。如果类或者接口可以被做成包级私有，就应该被做成包级私有，这样它实际上成了包的实现的一部分，
而不是该包导出的API的一部分，在以后的发行版本中，可以对它进行修改、替换、删除，而无需担心影响现有的客户端程序。如果被做成公有的，就有责任永远支持它，以保持兼容性。

如果一个包级私有的顶层的类（或者接口）只是在某一个类的内部可以被用到，就应该考虑使它成为唯一使用它的那个类的私有嵌套类。这样可以进一步缩小可访问范围。

4、对于成员（域、方法、嵌套类和嵌套接口）有四种可能的访问级别：
私有的（private）：只有在声明该成员的顶层类内部才可以访问这个成员。
包级私有的（package-private）：声明该成员的包内部的任何类都可以访问这个成员。如果没有为成员指定访问修饰符，就采用这个访问级别，“缺省”。
受保护的（protected）：声明该成员的子类可以访问这个成员（即使不在同一包），并且声明该成员的包内部任何类也可以访问这个成员。

公有的（public）：在任何地方都可以访问该成员。

5、有一条规则限制了降低方法的可访问性的能力，如果方法覆盖了超类的一个方法，子类的访问级别不允许低于超类中的访问级别。
这样可以确保任何可使用超类的实例的地方都可以使用子类的实例。

比如，如果一个类实现了一个接口，那么接口中所有的类方法在这个类中也都必须被声明为公有的（接口的所有方法隐含公有访问级别）。

6、实例域决不能是公有的。如果域是非final，或者是一个指向可变对象的final引用，那么一旦使这个域成为公有的，就放弃了对存储在这个域中的值进行限制的能力。

因此，包含公有可变域的类不是线程安全的。即使域是final的，并且引用不可变的对象，当把这个域变成公有的时候，也就放弃了“切换到一种新的内部数据表示法”的灵活性（因为公有的是导出API，必须始终坚持这种数据表示，保证兼容）。

7、常量，这种域的名称由大写字母组成，单词之间用下划线隔开，这些域要么包含基本类型，要么包含指向不可变对象的引用。

8、长度非零的数组总是可变的，所以，类具有公有的静态final数组域，或者返回这种域的访问方法，这几乎是错误的。这是安全漏洞的一个常见根源：

方式1：一般方式

	public class UnmodifiableArray {
	// 存在安全漏洞
	public static final String[] VALUES = { "1", "2" ,"3"};


	public static void main(String[] args) {
		UnmodifiableArray UF = new UnmodifiableArray();
		UF.VALUES[1] = "8";// 设置final数组成员
		for (int i = 0; i < VALUES.length; i++) {
			System.out.println(UF.VALUES[i]);
		}
		}
	}

1,8、3//成功修改一个不可变数组。

方式二：使用非常强大Guava，打印数组

	import com.google.common.base.Objects;
	public class UnmodifiableArray {
		// 存在安全漏洞
		public static final String[] VALUES = { "1", "2", "3" };
		public static void main(String[] args) {
			UnmodifiableArray UF = new UnmodifiableArray();
			// 修改final数组成员
			UF.VALUES[1] = "8";
			System.out.println(UF);
		}
		// 使用非常强大Guava，打印数组
		@Override
		public String toString() {
			return Objects.toStringHelper(this)
					.add("VALUES0", UnmodifiableArray.VALUES[0])
					.add("VALUES1", UnmodifiableArray.VALUES[1])
					.add("VALUES2", UnmodifiableArray.VALUES[2]).toString();
		}
	}

UnmodifiableArray{VALUES0=1, VALUES1=8, VALUES2=3}//成功修改一个不可变数组。

9、解决漏洞方案：
1.使公有数组变成私有的，并增加一个公有的不可变列表：

	import java.util.Arrays;
	import java.util.Collections;
	import java.util.List;
	import com.google.common.base.Objects;
	public class UnmodifiableArrayList {
		// 消除安全漏洞
		private static final String[] PRIVATE_VALUES = { "1", "2", "3" };
		public static final List<String> PVALUES = Collections
				.unmodifiableList(Arrays.asList(PRIVATE_VALUES));
		public static void main(String[] args) {
			UnmodifiableArrayList UF = new UnmodifiableArrayList();
			UF.PVALUES.add(1, "9");
			System.out.println(UF);
		}
		// 使用Guava
		@Override
		public String toString() {
			return Objects.toStringHelper(this)
					.add("PVALUES0", UnmodifiableArrayList.PVALUES.get(0))
					.add("PVALUES1", UnmodifiableArrayList.PVALUES.get(1))
					.add("PVALUES2", UnmodifiableArrayList.PVALUES.get(2))
					.toString();
		}
	}

异常：Exception in thread "main" java.lang.UnsupportedOperationException

构建一个不可变集合，Guava给出了更简洁的办法：
ImmutableList mmutableList = ImmutableList.of(PRIVATE_VALUES);

2.使公有数组变成私有的，并添加一个公有方法，返回私有数组的一个备份：
直接没有修改公有数组的机会。

	private static final Thing[] PRIVATE_VALUES = { ... };
	public static final Thing[] values() {
		return PRIVATE_VALUES.clone();
	}
	public class UnmodifiableArrayList2 {
		// 消除安全漏洞
		private static final String[] PRIVATE_VALUES = { "1", "2", "3" };
		public static final String[] values() {
			return PRIVATE_VALUES.clone();
		}
		public static void main(String[] args) {
			UnmodifiableArrayList2 UF1 = new UnmodifiableArrayList2();
			String[] UF = UF1.values();
			for (int j = 0; j < UF.length; j++) {
				System.out.println(UF[j]);
			}
		}
	}

每天努力一点，每天都在进步。