内部类详解

以下是我对几种典型的内部类的理解：

一、 成员内部类

      

package com.unit;

  //A，成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列。
public class MemberOuter {
  private static int i = 1;
  private int j = 10;
  private int k = 20;
  
  public static void outer_f1(){
   
  }
  
  public void outer_f2(){
   System.out.println(1);
   
  }
  
   // 成员内部类中，不能定义静态成员
   // 成员内部类中，可以访问外部类的所有成员 
  class Inner{
    //static int inner_i = 100;//内部类中不允许定义静态变量
    int j=100;   //内部类和外部类的实例变量可以共存
    int inner_i = 1;
    void inner_f1(){
     System.out.println(i);//如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
     System.out.println(j);//在内部类中访问内部类自己的变量直接用变量名或者用this.变量名
     System.out.println(this.j);
     System.out.println(MemberOuter.this.j);//在内部类中访问外部类中与内部类同名的实例变量用 外部类名.this.变量名
     System.out.println(k);//如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
     outer_f1();//成员内部类中可以直接通过方法名访问
     MemberOuter.this.outer_f2();//在内部类中访问外部类中与内部类同名的方法用 外部类名.this.方法名
    
   }
   void outer_f2(){
    System.out.println(2);
    
   }
  }
  // 外部类的非静态方法访问成员内部类直接用内部类对象.内部类方法
  public void outer_f3(){
   Inner inner = new Inner();
   inner.inner_f1();
  }
  
  //外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样
  public static void outer_f4(){
  //step1 建立外部类对象
   MemberOuter out = new MemberOuter();
  //step2 根据外部类对象建立内部类对象
   Inner inner=out.new Inner();
  //step3 访问内部类的方法
   inner.inner_f1();
  }
 
  public static void main(String[] args) {
   outer_f4();
  }

}

二、 局部内部类

package com.unit;


/*B，局部内部类
在方法中定义的内部类称为局部内部类。
与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。*/

public class PartialOuter {
 private int s = 100;
 private int out_i = 1;
 
 
 public void f(final int k){
  final int s = 200;
  int i = 1;
  final int j = 10;
  
   //定义在方法内部
  class Inner{
   int s = 300;//可以定义与外部类同名的变量
   //static int m = 20;//不可以定义静态变量
   Inner(int k){//构造器
    inner_f(k);
   }
   
   int inner_i = 100;
    void inner_f(int k){
	    System.out.println(out_i);//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
	    System.out.println(k);//可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
	    //System.out.println(i);
	    System.out.println(s);//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
	    System.out.println(this.s);//用this.变量名 访问的也是内部类变量
	    System.out.println(PartialOuter.this.s);//用外部类名.this.内部类变量名 访问的是外部类变量
   }
  }
  new Inner(k);//调用构造器，就调用构造器返回的方法
 }

 public static void main(String[] args) {
 //访问局部内部类必须先有外部类对象
	 PartialOuter partialOuter = new PartialOuter();
	 partialOuter.f(3);
 }

}

  /*注意：
     在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。
     要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。
    通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，
    使局部内部类不可见，屏蔽实现类的可见性。*/

三、静态内部类

package com.unit;

/**
 * C，静态内部类：（注意：前三种内部类与变量类似，
 * 所以可以对照参考变量）
       静态内部类定义在类中，任何方法外，用static定义。
**/

public class StaticOuter {
	 private static int i = 1;
	 private int j = 10;
	 public static void outer_f1(){
	  
	 }
	 public void outer_f2(){
	  
	 }
	 // 静态内部类可以用public,protected,private修饰
	 // 静态内部类中可以定义静态或者非静态的成员
	 static class Inner{
		  static int inner_i = 100;
		  int inner_j = 200;
		  static void inner_f1(){
		   System.out.println("StaticOuter"+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) {
	  new StaticOuter().outer_f3();
	 }

}


	/**生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区
	
	别。静态内部类的对象可以直接生成：
	Outer.Inner in=new Outer.Inner()；
	而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。
	静态内部类不可用private来进行定义。例子：
	对于两个类，拥有相同的方法：**/
	/*People
	{
	  run();
	}
	Machine{
	   run();
	}
	此时有一个robot类：
	class Robot extends People implement Machine.
	此时run()不可直接实现。
	注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。
	用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。*/