effective java（22） 之优先考虑静态成员类

effective java 之优先考虑静态成员类

1、 嵌套类（nested class）是指被定义在另一个类的内部的类。嵌套类存在的目的应该是为它的外围类（enclosing class）提供服务。
如果嵌套类将来可能会用于其他的某个环境中，它就应该是顶层类（top-level class）。
嵌套类有四种：静态成员类（static member class）、非静态成员类（nonstatic member class）、匿名类（anonymous class）和局部类（local class）。
除了第一种之外，其他三种都被称为内部类（inner class）。


2、静态成员类是最简单的一种嵌套类。
最好把它看作是普通的类，只是碰巧被声明在另一个类的内部而已，它可以访问外围类的所有成员，包括那些声明为私有的成员。
静态成员类是外围类的一个静态成员，与其他的静态成员一样，也遵守同样的可访问性规则。如果它被声明为私有的，它就只能在外围类的内部才可以被访问，等等。
public class MyClass{  
 \\...  
 public static class MyMember{  
\\...  
 }  
}

如果一个类要被声明为static的，只有一种情况，就是静态内部类。如果在外部类声明为static，程序会编译都不会过。

	public class Outer {
		private String name;
		private int age;


		public static class Builder {
			private String name;
			private int age;


			public Builder(int age) {
				this.age = age;
			}


			public Builder withName(String name) {
				this.name = name;
				return this;
			}


			public Builder withAge(int age) {
				this.age = age;
				return this;
			}


			public Outer build() {
				return new Outer(this);
			}
		}


		private Outer(Builder b) {
			this.age = b.age;
			this.name = b.name;
		}
	}

3、 静态成员类的一种常见用是作为公有的辅助类，仅当与它的外部类一起使用时才有意义。


4、从语法上讲，静态成员类和非静态成员类之间唯一的区别是，静态成员类的声明中包含了修饰符static。
尽管他们的语法非常的相似，但是这两种嵌套类有很大的不同。非静态成员类的每个实例都隐含着与外围类的一个外围实例（enclosing instance）相关联。
在非静态成员类的实例方法内部，可以调用外围实例上的方法，或者利用修饰过的this构造获得外围实例的引用。
如果嵌套类的实例可以在外围类的实例之外独立存在，这个嵌套类就必须是静态成员类：在没有外围实例的情况下，要想创建非静态成员类的实例是不可能的。
public class MyClass{  
 \\...  
 public class MyMember{  
\\...  
 }  
}  

5、当非静态成员类的实例被创建的时候，它和外围实例之间的关联关系也随之建立起来；而且，这种关联关系以后也不能被修改。
通常情况下，当在外围类的某个实例方法的内部调用了非静态成员类的构造器时，这种管理就自动建立起来。
使用表达式enclosingInstance.new MemberClass(args)来手工建立这种关系也是有可能的，但是很少使用。
正如你预料的那样，这种关联需要消耗非静态成员类的实例空间，并且增加了构造的时间开销。


6、非静态成员类常见用法是定义一个Adapter，它允许外部类的实例被看作是另一个不相关的类的实例。
例如，Map接口的实现往往使用非静态成员类来实现它们的集合视图（collection view），这些集合视图是由Map的keySet、entrySet和Values方法返回的。
同样地，诸如Set和List这种集合接口的实现往往也是用非静态成员类来实现他们的迭代器（iterator）：

	public class MySet<E> extends AbstractSet<E>  
	{  
		public Iterator<E> iterator()  
		{  
			return new MyIterator();  
		}  
		  
		private class MyIterator implements Iterator<E>  
		{  
			  
		}  
	}  

7、如果声明成员类不要求访问外围实例，就要始终把static修饰符放在它的生命中，使它成为静态成员类，而不是非静态成员类。
如果省略了static修饰符，则每个实例都将包含一个额外的指向外围对象的引用。保存这份引用要消耗时间和空间，并且会导致外围实例在符合垃圾回收时仍然得以保留。
如果没有外围实例的情况下，也需要分配实例，就不能使用非静态成员类，因为非静态成员类的实例必须要有一个外围实例。


8、 私有静态成员类的一种常见用法用来代表外围类所代表的对象的组件。


9、匿名类不同于Java程序设计语言中的其他任何语法单元。
正如你所想象的，匿名类没有名字。它不是外围类的一个成员。它并不与其他的成员一起被声明，而是在使用的同时被声明和实例化。
匿名类可以出现在代码中任何允许存在表达式的地方。当且仅当匿名类出现在非静态的环境中时，它才有外围实例。但是即使它们出现在静态的环境中，也不可能拥有任何静态成员。

10、匿名类的适用性受到诸多的限制。
除了在它们被声明的时候之外，是无法将它们实例化的，你不能执行instanceof测试，或者做任何需要命名类的其他事情。
你无法声明一个匿名类来实现多个接口，或者扩展一个类，并同时扩展类和实现接口。
匿名类的客户端无法调用任何成员，除了从它的超类型中继承得到之外。由于匿名类出现在表达式当中，它们必须保持简短——大约10行或者更少些——否则会影响程序的可读性。


11、匿名类的一种常见用法就是动态的创建函数对象（function object，见21条）。例如,第21条中Arrays.sort方法调用，利用匿名的Comparator实例，根据一组字符串的长度对它们进行排序。
匿名类的另一种常见的用法是创建过程对象（process object），比如Runnable、Thread或者TimerTask实例。
第三种常见的用法是在静态工厂内部（参见第18条中部分的intArrayAsList方法）。
Arrays.sort(stringArray, new Comparator<String>() {  
 public int compare(String s1, String s2) {  
 return s1.length() - s2.length();  
 }  
});

public static void runSomeThing(){
 Runnable runnable = new Runnable() {
 @Override
 public void run() {
 System.out.println("I am running");
 }
 };
 new Thread(runnable).start();
}


12、 局部类是四种嵌套类中用的最少的类。
在任何“可以声明局部变量”的地方，都可以声明局部类，并且局部类也遵守同样的作用域规则。
局部类与其他三种嵌套类中的每一种都有一些共同的属性。与成员类一样，局部类有名字，可以被重复使用。
与匿名类一样，只有当局部类实在非静态环境中定义的时候，才有外围实例，它们也不能包含静态成员。与匿名类一样，它们必须简短以便不会影响到可读性。
public class MyClass {  
//...  
public void myMethod(){  
//...  
class Memeber{  
//...  
}  
}  
} 

	public class outerTolocal {
		public String string;
		public int localInt;
		public void OtoLocal() {
		}
		public void localMthod(final int m, int n) {
			class local {
				// 此类为局部类
				// 局部类不需要加public 修饰符，因为这方法执行完 这类就消失了
				int methodInt = m;
				/**
				 * 局部类的变量如果要等于外部类的方法的变量， 此时外部类的方法变量必须用final 修饰符 如：
				 */
				// final int m;
				void localInner() {
					System.out.println("local method");
				}
			}
			new local().localInner();
			// 在另外的一个类的中不可以创建局部内部类的实例，只能在局部内部类中来创建。
		}
	}

13、简而言之，共有四种不同的嵌套类，每一种都有自己的用途。
如果一个嵌套类需要在单个方法之外仍然可见的，或者它太长了，不适合于放在方法内部，就应该使用成员类。
如果成员类的每个示例都需要一个指向外围实例的引用，就要把成员类做成非静态的；否则，就做成静态的。
假设这个嵌套类属于一个方法的内部，如果你只需要在一个地方创建实例，并且已经有了一个预置的类型可以说明这个类的特征，就要把它做成匿名类；否则，就做成局部类。


14、静态成员类与非静态成员的区别
1、持有外部类的引用
非静态成员类隐含持有外部类的引用，通过XXClass.this来获取外部类的引用。
也就是说能够获取外部类的所用成员变量与成员方法。

	public class MyType {
		private int firstData;
		private int secondData;


		private int getFirstData() {
			return firstData;
		}


		private int getSecondData() {
			return secondData;
		}


		public class Style {
			public void getStyle() {
				// 获取外围类成员变量
				int first = firstData;
				// 获取外围了的方法
				int second = getFirstData();
				// 获取外围了的引用
				MyType type = MyType.this;
			}
		}
	}

然而静态成员变量就无法持有外围类的引用。只能获取外围类的static的成员变量和方法。

	public class MyType {  
		private static int firstData;  
		private int secondData;  
		  
		private static int getFirstData(){  
			return firstData;  
		}  
		private int getSecondData(){  
			return secondData;  
		}  
		  
		public static class Style{  
			public void getStyle(){  
				int first = firstData;  
				int f = getFirstData();  
				//报错：int second = secondData;  
				// 报错：MyType myType = MyType.this;  
			}  
		}  
	} 

2、静态成员类能够脱离外围实例独立存在。
不用创建外围类，就可以创建静态成员类。但是普通成员类就必须先创建外围实例。
静态成员类：
public static void main(String[] args) {  
// TODO Auto-generated method stub  
//不用创建MyType就能单独创建实例  
MyType.Style style = new MyType.Style();  
} 
普通成员类：
public static void main(String[] args) {  
// TODO Auto-generated method stub  
//必须要先创建MyType才能创建Style  
MyType.Style style = new MyType().new Style();  
}  

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