Java内部类

Java内部类

Java的类的成员中还有一个特殊的成员——内部类。

有关内部类中，我们有几种常见的内部类：公共的内部类，私有内部类，静态的内部类，局部内部类，匿名内部类。

我们按顺序来介绍各种内部类

公共的内部类

public class Outer {
	
	class Inner {

		public Inner() {
			System.out.println("内部类被创建了");
		}
	}
	
	public Outer() {
		System.out.println("外部类被创建了");
	}

}

public class Text {
	
	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner();
	}

}

我们来看看这个程序的运行成果：

外部类被创建了
内部类被创建了

根据以上的运行效果，我们总结了以下几点：

1. 创建内部类的对象我们的方式是：外部类.内部类  内部类引用  = new 外部类构造方法().new 内部类的构造方法();当然你也可以先创建外部的对象，然后利用外部对象来创建内部对象。

2. 在创建内部类的同时，我们一定会调用外部类的构造方法。

如果内部类和外部类都有成员变量会怎么样呢？

public class Outer {
	private int a = 1;

	public  class Inner{

		private int a = 2;

		public Inner() {
			System.out.println("内部类被创建了");
		}

		void run(){
            //先看内部类里有木有成员变量， 如果没有就找外部类的成员
			System.out.println(a);
            //访问的一定是内部类的成员。
			System.out.println(this.a);
            //如果是这个，则访问的一定是外部类。
			System.out.println(Outer.this.a);
		}

	}
	
	public Outer() {
		System.out.println("外部类被创建了");
	}

	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner();
		inner.run();
	}

}

根据以上程序：

我们总结，外部类不能访问内部类的私有成员。

内部类可以访问外部类私有成员。

私有内部类

public class Outer {
	
	private class Inner{
		public Inner() {
			System.out.println("内部类被创建了");
		}
	}
	
	public Outer() {
		System.out.println("外部类被创建了");
	}

	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner();
	}

}

大家肯定发现了什么，对，小编把主方法放在了含有内部类的外部类里。为什么呢？

因为：私有的内部类只能在外部本类中创建对象。

静态内部类：（这里不写代码了）

我们类成员分静态和静态的，那么我们的内部类中也有成员，而且是静态成员呢？

小编告诉你答案吧。如果内部类有静态的成员，那么我们的内部类也要是静态的，否则编译错误。

注意：静态内部类的实例方法只能访问外部类的静态成员。

静态内部类静态方法的访问：

外部类.内部类.静态方法名();

局部内部类

定义在方法中的内成为匿名内部类。

要注意以下几点：

1. 局部内部类的地位和方法内的局部变量的位置类似，因此不能修饰局部变量的修饰符也不能修饰局部内部类，譬如public、private、protected、static、transient等

2. 局部内部类只能在声明的方法内是可见的，因此定义局部内部类之后，想用的话就要在方法内直接实例化，记住这里顺序不能反了，一定是要先声明后使用，否则编译器会说找不到。

3. 局部内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为fina 。

 

匿名内部类

1. 匿名内部类就是没有类名字的内部类。
2. 匿名内部类作用：简化内部类书写。
3. 匿名内部类的前提:必须继承一个父类或者是实现一个接口。
4. 匿名内部类的格式： 
new 父类或者接口(){ 执行代码….};
内部类的写法：

下面我们说说有关java内部类的一些注意点：

 

1. 创建实例

//注意是 外部类实例.new，内部类
OutClass.InnerClass obj = outClassInstance.new InnerClass();

//注意是 外部类本身，静态内部类
AAA.StaticInner in = new AAA.StaticInner();

2. 内部类的this关键字

内部类中的this与其他类一样是指的本身。创建内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件，可理解为内部类链接到外部类。 用外部类创建内部类对象时，此内部类对象会秘密的捕获一个指向外部类的引用，于是，可以通过这个引用来访问外围类的成员。

3. 外部类访问的内部类的成员

内部类类似外部类的属性，因此访问内部类对象时总是需要一个创建好的外部类对象。内部类对象通过‘外部类名.this.xxx’的形式访问外部类的属性与方法。如：

System.out.println("Print in inner Outer.index=" + pouter.this.index);
System.out.println("Print in inner Inner.index=" + this.index);

4. 内部类向上转型

内部类也可以和普通类一样拥有向上转型的特性。将内部类向上转型为基类型，尤其是接口时，内部类就有了用武之地。如果内部类是private的，只可以被它的外部类问，从而完全隐藏实现的细节。

5. 方法内的类

方法内创建的类（注意方法中也能定义类），不能加访问修饰符。另外，方法内部的类也不是在调用方法时才会创建的，它们一样也被事先编译了。

6. 静态内部类

定义静态内部类：在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

通常称为嵌套类，当内部类是static时，意味着：

[1]要创建嵌套类的对象，并不需要其外围类的对象；

[2]不能从嵌套类的对象中访问非静态的外围类对象（不能够从静态内部类的对象中访问外部类的非静态成员）；

嵌套类与普通的内部类还有一个区别：普通内部类的字段的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段，也不能包含嵌套类。但是在嵌套类里可以包含所有这些东西。也就是说，在非静态内部类中不可以声明静态成员，只有将某个内部类修饰为静态类，然后才能够在这个类中定义静态的成员变量与成员方法。

另外，在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。普通非静态内部类的对象是依附在外部类对象之中的，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。静态类和方法只属于类本身，并不属于该类的对象，更不属于其他外部类的对象。

7. 内部类标识符

每个类会产生一个.class文件，文件名即为类名。同样，内部类也会产生这么一个.class文件，但是它的名称却不是内部类的类名，而是有着严格的限制：外围类的名字，加上$,再加上内部类名字。

8. 为何要用内部类

1. 内部类一般只为其外部类使用；

2. 内部类提供了某种进入外部类的窗户；

3. 也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外部类是否已经继承了某个接口。因此，内部类使多重继承的解决方案变得更加完整。