总结篇：将内部类进行到底

核心提示：总结了一下内部类的一下特性和轻易出错的地方，给大家看看～～ 有什么错误，总结篇：将内部类进行到底，望指正～～～ （一） java1.1以后版本添加了嵌套类（Inner Class，嵌套类、内部类）， 假如成员变量也定义成 static ,那么外围类可以直接通过类名来访问， （2）定义 static 的 内部类，嵌套类定

　　总结了一下内部类的一下特性和轻易出错的地方，给大家看看～～
　　有什么错误，望指正～～～
　　
　　（一）
　　java1.1以后版本添加了嵌套类（Inner Class，嵌套类、内部类）。嵌套类定义在类（外部类）里面。
　　嵌套类可以体现逻辑上的从属关系。同时对于其他类可以控制内部类不可见等。
　　外部类的成员变量作用域是整个外部类，包括嵌套类。但外部类不能访问嵌套类的PRivate成员。例子：
　　public class Outer {
　　 private int size;
　　 public class Inner{
　　 private int counter = 10;
　　 public void doStuff(){ size++; }
　　 }
　　 public static void main(String args[]){
　　 Inner inner= new Inner();
　　 inner.doStuff();
　　 System.out.println(size);
　　 System.out.println(inner.counter);
　　 System.out.println(counter); //编译错
　　 }
　　}
　　
　　（二）下面演示了如何在外部类之外实例出一个public Inner类对象。
　　
　　类名前加上外部类类名，new语句前加上外部类的引用变量。这很类似package的使用。
　　例子：
　　public class Outer {
　　 private int size;
　　 public class Inner{
　　 public void doStuff(){ size++; }
　　 }
　　}
　　
　　public class TestInner{
　　 public static void main(String args[]){
　　 Outer outer = new Outer();
　　 Outer.Inner inner = outer.new Inner();
　　 inner.doStuff();
　　 }
　　}
　　（三）当内部类与外部类有同名变量时，缺省指本类中的变量。
　　例子：public class Outer {
　　 private int size;
　　 public class Inner{
　　 private size;
　　 public void doStuff(int size){
　　 size++; this.size++;
　　 Outer.this.size++; // 错误，Outer.size++因为size不是静态变量
　　 }
　　 }
　　 public static void main(String args[]){
　　 this.size++; //错误，静态方法使用非静态变量this
　　 }
　　}
　　（四）在方法中定义一个嵌套类，注重嵌套类不可以访问方法的局部变量。
　　因为方法的局部变量只存在与方法作用期间，故localvalue不可访问。而final变量的生命周期超出了方法，所以fianlvalue可用。
　　public class Outer {
　　 private int size =5;
　　 public Object makeTheInner(int localvalue){
　　 final int finalvalue = 6;
　　 class Inner{
　　 public String toString(){return (“Inner is”+size+localvalue+finalvalue);}
　　 }
　　 return new Inner();
　　 }
　　
　　 public static void main(String args[]){
　　 Outer outer = new Outer();
　　 Object obj = outer.makeTheInner(47);
　　 System.out.println(“The object is” + obj);
　　 }
　　}
　　（五）
　　 嵌套类的类名必须与包装它的外部类区别，且嵌套类的类名仅仅可以作用于定义范围中。方法中定义类，其类名名就只能出现在方法中。
　　 定义在方法中的嵌套类只能使用定义为final的局部变量，不可以使用方法中的非静态变量。
　　嵌套类可以使用的变量种类包括：类变量、实例变量、final局部变量。
　　嵌套类同样具有所有的访问控制权限。高级类属性：
　　嵌套类可以是abstract类
　　嵌套类可以是接口，被其它嵌套类实现。
　　定义为static的内部类将成为顶级类(top-level)。它们不依靠于外部类的对象而生成，所以不可以访问外部类的对象成员。
　　非static内部类不能定义static成员
　　当外部类编译时，内部类也会编译，生成的类文件格式为:
　　OuterClass$InnerClass，如Outer$Inner.class
　　
　　例子：
　　class Outer {
　　 private int size =5;
　　 static class Inner{
　　 int value=5;
　　 public void doStuff(){ size+=value; }// 错误，不能访问非static 外部类程序
　　 }
　　}
　　
　　public class TestInner{
　　 public static void main(String args[]){
　　 Outer outer = new Outer();
　　 Inner inner = new Inner();// 这种实例也不对
　　应该 Out.Inner innner=new Outer.Inner() ;
　　 }
　　}
　　
　　在总结的第（五）里面，
　　非static内部类不能定义static成员 ，
　　（1）定义 static 的 内部类， 假如成员变量也定义成 static ,那么外围类可以直接通过类名来访问。
　　（2）定义 static 的 内部类， 假如成员变量不是 static ,那么外围类需要生成内部类的对象才能访问，否则直接访问导致编译出错！！