Java内部类笔记

非静态内部类

非静态内部类是外部类的成员，在创建对象时，需要先创建外部类的实例，然后才能创建内部类的实例。

package Test;

public class InsideClass {
	public class A{
		//非静态内部类
	}
}

在InsideClass定义之外使用非静态内部类A时，必须先创建InsideClass的实例对象,如：

package Test;

public class InsideClass {
	public class A{
		//非静态内部类
	}
}

package Test;
public class Test {

	public static void main(String[] args)
	{
		InsideClass inside=new InsideClass();//创建InsideClass的实例对象
		InsideClass.A a=inside.new A();
	}
}

如果不想在前面写上InsideClass类，需要将InsideClass类导入，如：

package Test;
import Test.InsideClass.A;
public class Test {

	public static void main(String[] args)
	{
		InsideClass inside=new InsideClass();
		A a=inside.new A();
	}
}

非静态内部类可以直接调用外部类的方法，如下：

package Test;

public class InsideClass {
	public void doSomething() {
		System.out.println("doSomething");
	}
	public class A{
		//非静态内部类
		public A()
		{
			doSomething();
		}//访问外部类方法
	}
	public static class B{
		//静态内部类
	}
}

如果非静态内部类与外部类有同名变量，需要在前面加上类名以区分：如下：

package Test;

public class InsideClass {
	private String str="toString";
	public void doSomething() {
		System.out.println("doSomething");
	}
	public class A{
		//非静态内部类
		private String str="toStringA";
		public A()
		{
			doSomething();
			System.out.println(InsideClass.this.str);
			System.out.println(this.str);
		}//访问外部类方法
	}
	public static class B{
		//静态内部类
	}
}

此时A的构造函数的输出结果是：
toString
toStringA
外部类不一定能访问内部类，（创建外部类不一定创建内部类），内部类一定能访问外部类成员。

静态内部类

静态内部类是外部类的静态成员，创建对象时，无需创建外部类的实例。可以访问外部类的静态成员。
静态内部类可以直接访问，不需要创建外部类的实例对象，如：

package Test;

public class InsideClass {
	public static class B{
		//静态内部类
	}
}

package Test;
public class Test {

	public static void main(String[] args) {
		InsideClass.B b=new InsideClass.B();
	}
}

定义静态内部类不需要创建外部类的实例，如下：

package Test;

public class Test {

	public static void main(String[] args) {
		InsideClass.B b=new InsideClass.B();
	}
}

静态内部类无法访问外部类的实例成员，外部类可以直接访问静态内部类的静态成员无需创造静态内部类的实例，如下

package Test;

public class InsideClass {
	public InsideClass()
	{
		B.doSomething();
	}
	public static class B {
		// 静态内部类
		private static void doSomething()
		{
			System.out.println("静态内部类的私有方法");
		}
	}
}

内部类如果定义成private，就只有外部类能访问

局部内部类

定义在作用域内部，仅在作用域内使用作用域通常是方法。和变量类似，有作用域和生命周期，使用少。
局部内部类只有abstract和final修饰的才可以被定义，默认final修饰，代码如下：

package Test;

public class InsideClass {
	public void doSomething()
	{
		final class C{
			public void test()
			{
				System.out.println("test");
			}
		}
	}
}

匿名内部类

没有名字，在定义类的同时，创建匿名类的对象。
如下创建一个继承自InsideClass的匿名内部类的实例：

package Test;

public class Test {

	public static void main(String[] args) {
		InsideClass a1=new InsideClass() {
		};
	}
}

如下创建一个实现A接口的匿名内部类的实例：

package Test;
interface A
{
	public void doSomething();
}
public class Test {

	public static void main(String[] args) {
		A cl=new A() {
			public void doSomething()
			{
				System.out.println("doSomething");
			}
		};
	}
}

匿名内部类只能使用它的父类或接口做引用