第二十二条：优先考虑静态成员类

一、嵌套类的种类

1、静态成员类(在类内部的类)

public class MyClass{
  \\...
  public static class MyMember{
     \\...
  }
}

2、成员类（静态与非静态的区别在于static）

public class MyClass{
  \\...
  public class MyMember{
     \\...
  }
}

3、局部类（在方法内的类）

public class MyClass {
	//...
	public void myMethod(){
		//...
		class Memeber{
			//...
		}
	}
}

4、匿名类（在调用方法内的类）

	mBtn.setOnClickListener{
		new OnClickListener(){
			@Override
			public void onClick(){
				//...
			}
		}
	};

二、静态成员类与非静态成员的区别

①、持有外部类的引用

非静态成员类隐含持有外部类的引用，通过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;
		}
	}
}

②、静态成员类能够脱离外围实例独立存在。

就是说：不用创建外围类，就可以创建静态成员类。但是普通成员类就必须先创建外围实例。

静态成员类：

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

三、静态与非静态成员类的实例

静态成员类：(作为枚举类)

public class Main {
	private Fruit mFruit = Fruit.APPLE;
	
	public void setFruit(Fruit fruit){
		mFruit = fruit;
	}
	
	public enum Fruit{
		APPLE,
		ORANGE,
		BANANA
	}
}

非静态成员类：（作为容器的迭代器）

public class MyList <E> extends AbstractList<E>{

	@Override
	public E get(int index) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		return 0;
	}
	
	@Override
	public Iterator<E> iterator() {
		// TODO Auto-generated method stub
		return new MyIterator<E>();
	}
	
	private class MyIterator<T> implements Iterator<T>{
		private int current;
		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			//设定一个计时器，与List的数量比较
			if (current < size()){
				return true;
			}
			return false;
		}

		@Override
		public T next() {
			// TODO Auto-generated method stub
			return null;
		}
		
	}
}

四、何时使用静态成员与非静态成员类

当成员类不要求访问外围成员的时候，就需要将嵌套类设置成静态成员类。

因为非静态成员类会持有外围类的引用，这样会导致，当外围类可以被垃圾回收机制回收的时候，由于非静态成员持有外围实例，导致外围类无法释放，占用内存。