JAVA 中的内部类

[size=large]内部类


[color=blue]private protected static 只能修饰内部类
对于同一个包中的其他类来说，内部类能够隐藏起来。[/color]


成员内部类:

[color=blue]一个内部类的对象能够访问创建它的对象的实现，包括私有数据。[/color][color=orange] (如果内部类和外部类成员的名字完全相同，在内部类方法中要访问外部类成员，则需要使用下面的方式来访问：外部类名.this.外部成员名.
Outer.this.j
如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量)[/color]

[color=blue]成员内部类中，不能定义静态成员[/color]
[color=orange]在Java中，为什么非静态内部类不能声明静态变量(可以调用)？？
因为静态变量是类在加载的时候就要分配内存空间的，你放在非静态内部类中，这个非静态内部类还没调用就给分配内存空间？这可能么？[/color]


[color=blue]外部类的非静态方法访问成员内部类[/color]
public void outer_f3(){
Inner inner = new Inner();
}
[color=blue]外部类的静态方法访问成员内部类[/color]
public static void outer_f4(){
//建立外部类对象
Outer out = new Outer();
//根据外部类对象建立内部类对象
Inner inner = out.new Inner();
}
[color=blue]其他类的非静态方法访问成员内部类[/color]
Outer out=new Outer();
Outer.Inner inner=out.new Inner();


成员内部类代码示例：[/size]

public class Outer {
	 private static int i = 1;
	 private int j = 10;
	 private int k = 20;
	 public static void outer_f1(){

	 }
	 public void outer_f2(){

	 }

	// 成员内部类中，不能定义静态成员
	// 成员内部类中，可以访问外部类的所有成员 
	 private class Inner{
	//  static int inner_i = 100;//内部类中不允许定义静态变量
	  private int j=100; //内部类和外部类的实例变量可以共存
	  int inner_i = 1;
	  void inner_f1(){
	   System.out.println(i);
	   System.out.println(j);//在内部类中访问内部类自

	//己的变量直接用变量名
	   System.out.println(this.j);//或者用this.变量名
	   System.out.println(Outer.this.j);//在内部类中
	   //System.out.println(j);
	//访问外部类中与内部类同名的实例变量用 外部类名.this.变量名
	   System.out.println(k);//如果内部类中没有与外部
	   System.out.println("-----------");
	//类同名的变量，则可以直接用变量名访问外部类变量
	   outer_f1();
	   outer_f2();

	  }
	 }
	// 外部类的非静态方法访问成员内部类
	 public void outer_f3(){
	  Inner inner = new Inner();
	  inner.inner_f1();
	 }

	 //外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样
	 public static void outer_f4(){ 
	//  step1 建立外部类对象
	  Outer out = new Outer();
	//  step2 根据外部类对象建立内部类对象
	    Inner inner = out.new Inner();
	//  step3 访问内部类的方法
	  inner.inner_f1();
	  System.out.println(inner.j);  
	 }	 
	 public static void main(String[] args) {
	  outer_f4();
	 }
}

[size=large]静态内部类:

静态内部类中可以定义[color=blue]静态[/color][color=orange]或者非静态[/color]的成员.
静态内部类只能访问外部类的静态成员,包括静态变量和静态方法.
[color=orange] (如果内部类和外部类（静态）成员的名字完全相同，在内部类方法中要访问外部类成员，则需要使用下面的方式来访问：外部类名.外部成员名.
Outer.j
如果内部类中没有与外部类同名的（静态）变量，则可以直接用变量名访问外部类变量)[/color]
外部类访问内部类的[color=orange]静态成员[/color]：内部类.静态成员.
外部类访问内部类的[color=orange]非静态成员[/color]:实例化内部类即可
public void outer_f3(){
Inner inner = new Inner();
}
[color=blue]其他类的访问静态成员内部类[/color]
Outer.Inner.inner_f1();
Outer.Inner.i=6;
[/size]

      public class Outer {
	private static int i = 1;
	private static int k = 1;
	 private int j = 10;
	 public static void outer_f1(){
		 Inner.inner_f1();
	 }
	 public void outer_f2(){

	 }



	// 静态内部类可以用public,protected,private修饰
	// 静态内部类中可以定义静态或者非静态的成员
	 static class Inner{
	  static int inner_i = 100;
	  int inner_j = 200;
	  static int i=5;
	  Inner(){
		  inner_i=5;
	  }
	  static void inner_f1(){
	 System.out.println("Outer.i"+k);//静态内部类只能访问外部类的静态成员
	 System.out.println("Outer.i"+i);
	 System.out.println("Outer.i"+Outer.i);//当重名时	   
            outer_f1();//包括静态变量和静态方法
	  }
	  void inner_f2(){
	//   System.out.println("Outer.i"+j);//静态内部类不

	//能访问外部类的非静态成员
	//   outer_f2();//包括非静态变量和非静态方法
	  }


	 }

	 public void outer_f3(){
	//  外部类访问内部类的静态成员：内部类.静态成员
	  System.out.println(Inner.inner_i);
	  Inner.inner_f1();
	//  外部类访问内部类的非静态成员:实例化内部类即可
	  Inner inner = new Inner();
	  inner.inner_f2();

	 }
	 public static void main(String[] args) {
	  Outer.Inner.i=6;	 }

	}

[size=large]匿名内部类：
匿名类是不能有名称的类，所以没办法引用他们。必须在创建时，作为new语句的一部分来声明他们。
这就要采用另一种形式的new语句，如下所示：

new <类或接口> <类的主体> 例：new Xxx（）{}[/size]