Java内部类使用详解

静态内部类

静态内部类无需依赖于外部类，只能使用外部类的静态成员和静态方法，即使是private的也可以。
默认调用内部类字节的属性方法，若外部类有相同的默认使用如下方法：
调用外部类的属性方法： 类名 . 静态属性名（方法名）
创建内部类对象的方法：外部类名 . 内部类名 xx = new 外部类名 . 内部类名()

package innerclass;

public class StaticInner {

	private static int a = 1;
	private static int b = 2;
	
	public static class InnerStatic{
		
		public static int a = 3;
		
		public void testInnerA() {
			System.out.println("this is inner field A : " + a);
		}
		
		public void testOutterA() {
			System.out.println("this is outter field A : " + StaticInner.a);
		}
		
		public void testUse() {
			System.out.println("static inner class use success!");
		}
		
		public void testOutterPrivate() {
			testPrivate();
		}
		
	}
	
	private static void testPrivate() {
		System.out.println("this is using outter private static method B : " + b);
	}
	
	public void useInner() {
		InnerStatic s = new InnerStatic();
		s.testUse();
	}

}

外部使用

package innerclass;

public class UseInner {
	public static void main(String[] args) {
		
		// 通过静态外部类使用内部类函数  和  外界调用内部类 
		StaticInner si = new StaticInner();
		si.useInner();
		StaticInner.InnerStatic inner = new StaticInner.InnerStatic();
		inner.testInnerA();
		inner.testOutterA();
		inner.testOutterPrivate();
}

结果

static inner class use success!
this is inner field A : 3
this is outter field A : 1
this is using outter private static method B : 2

成员内部类

内部类可访问外部类的所有属性方法
外部访问内部，创建内部对象才可访问
内部有和外部相同部分，内部默认访问内部，若要用外部则：
外部类.this.成员属性方法
创建内部类对象：

Outter outter = new Outter() ;   
Outter.Inner inner = outter.new Inner() ;

内部类private，则仅外部类可访问；
protect继承外部类和同一包可访问；
public都可访问，默认则同包可访问。

package innerclass;

public class MemberInner {
	
	private int a = 1;
	private int b = 2;
	
	
	public class InnerMember{
		private int a = 3;
		public void testInnerA() {
			System.out.println("this is inner field A : " + a);
		}
		public void testOutterA() {
			System.out.println("this is outter field A : " + MemberInner.this.a);
		}
		public void testUse() {
			System.out.println("member inner class use success!");
		}
		public void testOutterPrivate() {
			testPrivate();
		}
	}
	
	public void useInner() {
		InnerMember in = new InnerMember();
		in.testUse();
	}
	
	private void testPrivate() {
		System.out.println("this is using outter private method B : " + b);
	}

}

使用：

package innerclass;

public class UseInner {
	public static void main(String[] args) {

		// 成员内部类的初始化和变量的内外取值方法 和外部调用内部类
		MemberInner mi = new MemberInner();
		MemberInner.InnerMember miim = mi.new InnerMember();
		mi.useInner();
		miim.testInnerA();
		miim.testOutterA();
		miim.testOutterPrivate();
}

结果：

member inner class use success!
this is inner field A : 3
this is outter field A : 1
this is using outter private method B : 2

局部内部类

在代码块或者域中的类，作用在局部类或者域中有效。
仅可以定义为默认、抽象或者final类型的类

package innerclass;

public class PartInner {
	
	public int a = 1;
	public int b = 2;
	
	public void usePartInner() {
		int a = 4; // 这个啊达不到
		int b = 5;
		class InnerPart{
			public int a = 3; 
			public void testUse() {
				System.out.println("part inner class use success!");
			}
			public void testInnerA() {
				System.out.println("this is inner part field A : " + a);
			}
			public void testOutterB() {
				System.out.println("this is inner part field B : " + b);
			}
			public void testOutter() {
				System.out.println("part inner can't reach outter!");
			}
		}
		InnerPart il = new InnerPart();
		il.testUse();
		il.testInnerA();
		il.testOutterB();
		il.testOutter();
	}
}

使用

无法在外部生成局部内部类的对象，因为它的作用于仅在类的方法或者域中，外部调用方法也看不见里面的类。
优先访问局部内部类的变量，再在类外面的方法块中找。

package innerclass;

public class UseInner {
	public static void main(String[] args) {
		// 局部内部类仅方法体或者域内可访问
		PartInner pi = new PartInner();
		pi.usePartInner();
}

结果：

part inner class use success!
this is inner part field A : 3
this is inner part field B : 5
part inner can't reach outter!

匿名内部类

匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。
匿名内部类是唯一没有构造方法的类
匿名内部类在编译的时候由系统自动起名为 Outter$1.class

package innerclass;
// 当然不是抽象类也可以，实现方法并且后面重载就行了。
public abstract class AnonymousInner {
	
	public abstract int test();
	
}

使用

package innerclass;

public class UseInner {
	public static void main(String[] args) {

		// 匿名类的使用
		UseInner ui = new UseInner();
		ui.useAnonymous(new AnonymousInner() {
			public int test() {
				System.out.println("use success!");
				return 100;
			}
		});
	}
	
	// 用于使用匿名内部类
	public void useAnonymous(AnonymousInner ai) {
		
		System.out.println("this is the use! " + ai.test());
		
	}

}

结果：
可以看出，先执行的重载方法再执行的调用处代码

use success!
this is the use! 100