03-15_内部类

内部类

内部类是一种类的结构扩充，让一个类的内部除了属性与方法之外还可以存在有其它类的结构，并且内部类也可以定义在方法或代码块中

范例：观察内部类的基本形式

class Outer { 				// 外部类
	private String msg = "Hello World !";
	class Inner { 			// 定义一个内部类
		public void print() {
			System.out.println(msg);
		}
	}
	public void fun() {
		new Inner().print();	// 实例化内部类对象，并且调用print()方法
	}
}
public class TestDemo {
	public static void main(String args[]) {
		Outer out = new Outer(); 		// 实例化外部类对象
		out.fun(); 			// 调用外部类方法
	}
}
程序执行结果：
Hello World !

范例：访问内部类的私有属性

class Outer {				// 外部类
	private String msg = "Hello World !" ;
	class Inner {			// 定义了一个内部类
		private String info = "世界，你好！" ;	// 内部类的私有属性
		public void print() {
			System.out.println(msg) ;// 直接访问外部类的私有属性
		}
	}
	public void fun() {
		Inner in = new Inner() ;	// 内部类对象
		System.out.println(in.info) ;// 直接利用了内部类对象访问了内部类中定义的私有属性
	}
}
public class TestDemo {
	public static void main(String args[]) {
		Outer out = new Outer() ;	// 实例化外部类对象
		out.fun() ;	// 调用外部类方法
	}
}
程序执行结果：
世界，你好！

实例化内部类对象

内部类实例化语法：

外部类.内部类 对象 = new 外部类().new 内部类()；

由于内部类需要使用外部类中的属性，而所有的属性只有在对象实例化之后才会分配空间，所以在实例化内部类对象时首先要实例化外部类对象，但是需要提醒读者的是，以上的格式只是一个基础，指的是在一个类内部只定义一个内部类的情况，而如果说一个内部类中又定义了内部类，则类结构需要继续向下延伸，变为“外部类.内部类1.内部类2 对象 = new 外部类().new 内部类1().new 内部类2()；”

范例：实例化内部类对象

class Outer {		// 外部类
	private String msg = "Hello World !" ;
	class Inner {		// 定义了一个内部类
		public void print() {
			System.out.println(Outer.this.msg) ;
		}
	}
}
public class TestDemo {
	public static void main(String args[]) {
		Outer.Inner in = new Outer().new Inner() ;	// 实例化内部类对象
		in.print() ;
	}
}
程序执行结果：
Hello World !

范例：定义私有内部类

class Outer {								// 外部类
	private String msg = "Hello World !" ;
	private class Inner {		// 定义私有内部类
		public void print() {
			System.out.println(Outer.this.msg) ;
		}
	}
}

由于存在有private声明，所以Inner类只能够在Outer类的内部使用，这个时候将无法在外部实例化Inner类对象，而这个内部类只能够为Outer一个类服务。

使用static定义内部类

使用static定义的属性或者是方法是不受到类实例化对象控制的，所以如果使用了static定义内部类。它一定不可能受到外部类的实例化对象控制。

如果一个内部类使用了static定义的话，那么这个内部类就变为了一个“外部类”，并且只能够访问外部类中定义的static操作。相当于定义一个外部类。

范例：利用static定义内部类

class Outer { 				// 外部类
	private static String msg = "Hello World !";	// static属性
	static class Inner {		// static定义的内部类等同于外部类
		public void print() {
			System.out.println(Outer.msg);	// 直接访问static属性
		}
	}
}

此时的代码利用了static定义了内部类，这个内部类就相当于变为了外部类，并且只能够访问Outer类中的static属性或方法。但是此时如果要想取得内部类的实例化对象，使用的语法如下：

外部类.内部类 对象 = new 外部类.内部类() ;

范例：实例化“外部类”对象

class Outer { 		// 外部类
	private static String msg = "Hello World !";	// static属性
	static class Inner {	// static定义的内部类等同于外部类
		public void print() {
			System.out.println(Outer.msg);// 直接访问static属性
		}
	}
}
public class TestDemo {
	public static void main(String args[]) {
		Outer.Inner in = new Outer.Inner() ;// 实例化“外部类”对象
		in.print() ;	// 调用方法
	}
}
程序执行结果：
Hello World !

在方法中定义内部类

内部类理论上可以在类的任意位置上进行定义，这就包括代码块之中，或者是普通方法之中，而在以后的开发过程之中，在普通方法里面定义内部类的情况是最多的。

class Outer {			// 外部类
	private String msg = "Hello World !" ;
	public void fun() {	// 外部类普通方法
		class Inner {	// 方法中定义的内部类
			public void print() {
				System.out.println(Outer.this.msg) ;
			}
		}
		new Inner().print() ;	// 内部类实例化对象调用print()输出
	}
}
public class TestDemo {
	public static void main(String args[]) {
		new Outer().fun() ;
	}
}
程序执行结果：
Hello World !

范例：访问方法中定义的参数或者是变量

class Outer {					// 外部类
	private String msg = "Hello World !" ;
	public void fun(int num) {	// 外部类普通方法
		double score = 99.9 ;	// 方法变量
		class Inner {		// 方法中定义的内部类
			public void print() {
				System.out.println("属性：" + Outer.this.msg) ;
				System.out.println("方法参数：" + num) ;
				System.out.println("方法变量：" + score) ;
			}
		}
		new Inner().print() ;// 内部类实例化对象调用print()输出
	}
}
public class TestDemo {
	public static void main(String args[]) {
		new Outer().fun(100) ;
	}
}
程序执行结果：
属性：Hello World !
方法参数：100
方法变量：99.9