java中的内部类（四种包含实现代码较全）

局部内部类：定义在方法中，在局部类中的方法只能访问定义多所在的方法的外面的final类型的属性，也可以访问局部内部类中的属性。实例化这个局部内部类的时候也只能够在这个定义这个类的方法中使用：

class LocalInner
{
	public void doSomething()
	{
		final int b = 5;
		final int a = 4;
		//局部内部类的成员变量必须是final
		
		class Inner
		//局部     的内部类，在这个类只能访问定义在doSomething（）这个方法里面的声明final类型的变量
		{
//			int a = 6;局部有优先访问局部
			public void test()
			//这个就相当于一个局部的，只能在这个方法中去访问，当这个完成后，就会消失，所以这个类只能在上面的那个方法中去访问
			{
				System.out.println(a);
				//只能访问方法中声明的final类型的变量
				System.out.println("hello world");
				System.out.println(b);//把final去掉就不行了
				
			}
		}
		new Inner().test();
	}
}

匿名内部类：比如一个方法的参数类型是某一个类的类型。然后传参数的时候直接new 出一个对象，直接实现穿进去。

public class AnonymousInnerClassTest
{
	@SuppressWarnings("deprecation")
	public String get(Date date)
	{
		return date.toLocaleString();
		//调用的是Date类中的tolocalString方法，但是，参数是一个new Date（）对象，在这个对象中重写了这个方法，那么
		//在调用这个方法的时候就会调用重写的这个方法
	}
	public static void main(String[] args)
	{
		AnonymousInnerClassTest test = new AnonymousInnerClassTest();
//		String string = test.get(new Date());
//		System.out.println(string);
		String string = test.get(new Date()
		{
			@Override
			public String toLocaleString()
			{
				return "hello world";
			}
		});
		System.out.println(string);
	
	}

}

成员内部类：成员内部类和方法属性处于同一级别，

1>    成员内部类中的属性一般不能是static的，如果静态的那么这个需要声明为final类型，方法不能是静态的。

2>    在成员内部类中可以指定访问外部的属性还是内部类的属性：

访问外部属性：外部类.this.a访问的是外部类的属性a

访问内部属性：this.a访问的是内部类的属性a

3>    如果没有指明访问内部的还是外部的，这个就优先访问内部的属性。

4>    实例化内部类的对象的时候这个时候可以：

在该外部类的非静态方法中：

Inner inner= this.new Inner();

在改外部类的静态方法中：

MemberInnermemberInner = new MemberInner();

           Innerinner2 = memberInner.new Inner();

在其他类中：

MemberInner.Inner inner = new MemberInner().new Inner();

class MemberInner
{
	private static int c = 5;
	private int a = 4;
	private int b = 10;
	public class Inner
	//静态的成员内部类和成员内部类的区别就是这个内部类有无static修饰
	{
		private static final int a = 5;
		//成员内部类中不能定义静态成员，内部类中的可以定义相同的变量
		public void doSomething()
		{
			System.out.println(this.a);//访问的是内部的
			System.out.println(MemberInner.this.a);
			//访问的是外部的成员变量，而且因为这个是非静态的成员内部类，所以可以去访问外部类的非静态的成员变量
			//在内部类中访问外部和内部都有的一个成员变量的时候，既可以访问外部的那个，也可以访问内部的
			
			System.out.println(b);
			System.out.println(c);
			
		}
	}
	public void method()
	//非静态的方法
	{
		Inner inner = this.new Inner();//this指代的就是当前类
	}
	public static void method2()
	//静态方法访问，不能直接访问非静态的
	{
		
		MemberInner memberInner = new MemberInner();
		Inner inner2 = memberInner.new Inner();
	}
}
public class MemberInnerClassTest
{
	public static void main(String[] args)
	{
		MemberInner.Inner inner = new MemberInner().new Inner();
		//这个内部类不是一个静态的内部类，所以需要所以需要将外部类实例化一个对象，然后再去调用这个内部类的对象
		//非静态的类属于对象，也就是只能通过对象来访问
		inner.doSomething();
	}
}

静态内部类：和方法和属性处于同一级别。

         静态内部类只能访问外部类的静态的属性和静态的方法；

         实例化对象：

StaticInner.Innerinner = new StaticInner.Inner();

class StaticInner
{
	private static int a = 4;
	public static class Inner
	//静态的只能访问静态的，可以访问外部的静态方法和静态的成员变量
	{
		private static int a = 5;
		public void test()
		{
			System.out.println(StaticInner.a);
		}
		
	}
}

public class StaticInnerTest//外部类不可能是静态类
{
	public static void main(String[] args)
	{
		StaticInner.Inner inner = new StaticInner.Inner();
		//这个内部类是一个静态的内部类，可以直接用外部类.内部类来调用
		//静态的属于类本身的
		inner.test();
		
	}
}