Java的内部类

1.内部类:定义在类结构中的另一个类

类中的定义的成员:
        字段
        方法
        内部类
-------------------------------------------------------------------
为什么使用内部类：
1):增强封装，把内部类隐藏在外部类之内，不许其他类访问内部类。
2):内部类能提高代码的可读性和可维护性，把小型类嵌入到外部类中结构上代码更靠近。

3):内部类可以直接访问外部类的成员。

2.内部类的分类

内部类根据使用不同的修饰符或者定位的位置不同,分成四种:
四种内部类：
①　实例内部类：  内部类没有使用static修饰.
②　静态内部类：  内部类使用了static修饰.
③　局部内部类：  在方法中定义的内部类.
④　匿名内部类适合于仅使用一次使用的类,属于局部内部类的特殊情况：

对于每个内部类来说:Java编译器会生成独立.class文件.
成员内部类:外部类名$内部类名字
局部内部类:外部类名$数字内部类名称
匿名内部类:外部类名$数字

外部类的访问修饰符:要么使用public,要么就缺省.
内部类看做是外部类的一个成员,好比字段,那么内部类可以使用public/缺省/protected/private修饰.还可以是static修饰.

3.实例内部类

没有使用static修饰内部类,说明内部类属于外部类的对象,不属于外部类本身.
特点:
1:创建实例内部类前,必须存在外部类对象,通过外部类对象创建内部类对象(当存在内部类对象时,一定存在外部类对象).
    Outter.Inner in = new Outter().new Inner();
2:实例内部类的实例自动持有外部类的实例的引用,内部类可以直接访问外部类成员.
3:外部类中不能直接访问内部类的成员,必须通过内部类的实例去访问.
4:实例内部类中不能定义静态成员,只能定义实例成员.
5:如果实例内部类和外部类存在同名的字段或方法abc,那么在内部类中:
this.abc:表示访问内部类成员.
外部类.this.abc:表示访问外部类成员.

class OuterClass //外部类 
{
	private String name = "Outer.name";  //外部类成员变量

	class InnerClass  //成员内部类
	{
		private String name = "Inner.name";  //内部类的成员变量

		public void doWork(){
			String name = "local.name";      //内部类的局部变量

			System.out.println(name);  //local.name
			System.out.println(this.name); //Inner.name
			System.out.println(OuterClass.this.name); //Outer.name
		}
	}
}

//测试类

class TestDemo
{
	public static void main(String[] args){
		OuterClass.InnerClass in = new OuterClass().new InnerClass();  //创建内部类对象
		in.doWork();
	}
}

4.静态内部类

使用static修饰的内部类.
特点:
1):静态内部类的实例不会自动持有外部类的特定实例的引用,在创建内部类的实例时,不必创建外部类的实例.
     Outter.Inner in = new Outter.Inner();
2):静态内部类可以直接访问外部类的静态成员,如果访问外部类的实例成员,必须通过外部类的实例去访问.
3):在静态内部类中可以定义静态成员和实例成员.
4):测试类可以通过完整的类名直接访问静态内部类的静态成员.

class OuterClass //外部类 
{
	private static String name = "Outer.name";  //外部类成员变量

	static class InnerClass  //成员内部类
	{
		private String name = "Inner.name";  //内部类的成员变量

		public void doWork(){
			String name = "local.name";      //内部类的局部变量

			System.out.println(name);  //local.name
			System.out.println(this.name); //Inner.name
			System.out.println(OuterClass.name); //Outer.name
		}
	}
}

//测试类

class TestDemo
{
	public static void main(String[] args){
		OuterClass.InnerClass in = new OuterClass.InnerClass();  //创建内部类对象
		in.doWork();
	}
}

5.局部内部类(打死都不用)

在方法中定义的内部类,其可见范围是当前方法和局部变量是同一个级别.
1):不能使用public,private,protected,static修饰符.
2):局部内部类只能在当前方法中使用.
3):局部内部类和实例内部类一样,不能包含静态成员.
4):局部内部类和实例内部类,可以访问外部类的所有成员.
5):局部内部类访问的局部变量必须使用final修饰(在Java8中是自动隐式加上final,但是依然是常量,不能改变值).
原因:如果当前方法不是main方法,那么当前方法调用完毕之后,当前方法的栈帧被销毁,方法内部的局部变量的空间全部销毁.
       然后局部内部类是定义在方法中的,而且在方法中会创建局部内部类对象,而局部内部类会去访问局部变量,当当前方法被销毁的时候,对象还在堆内存,依然持有对局部变量的引用,但是方法被销毁的时候局部变量以及被销毁了.
       此时出现:在堆内存中,一个对象引用着一个不存在的数据. 为了避免该问题,我们使用final修饰局部变量,从而变成常量,永驻内存空间,即使方法销毁之后,该局部变量也在内存中,对象可以继续持有.

6.匿名内部类

匿名内部类(Anonymous),是一个没有名称的局部内部类,适合只使用一次的类。在开发中经常有这样的类,只需要定义一次,使用一次就可以丢弃了,此时:不应该白白定义在一个文件中. 在JavaSE/Android的事件处理中:不同的按钮点击之后,应该有不同的响应操作,首先使用匿名内部类.
特点:
1):匿名内部类本身没有构造器,但是会调用父类构造器.
2):匿名类尽管没有构造器,但是可以在匿名类中提供一段实例初始化代码块,JVM在调用父类构造器后,会执行该段代码.
3):内部类处理可以继承类之外,还可以实现接口.
格式：
     new 父类构造器([实参列表]) 或 接口()
     { 
         //匿名内部类的类体部分
      }
注意：匿名内部类必须继承一个父类或者实现一个接口，但最多只能一个父类或实现一个接口。

new父类:

abstract class Fu 
{
	abstract void doWork();
}

class TestDemo2
{
	public static void main(String[] args){
		//匿名内部类    new父类,相当于创建了一个子类,继承它的父类,实现它的方法,只不过没有给名字
		new Fu(){
			void doWork(){
				System.out.println("子类覆盖父类的抽象方法");
			};		
		};
	}
}

new接口

interface Iusb
{
	void doWork();
}  

class Test
{
	public static void main(String[] args){
		//匿名内部类       new 接口实现接口中的方法
		new Iusb(){
			public void doWork(){
				System.out.println("实现接口方法");
			}
		};
	}
}