java内部类详解

         内部类是一种类的结构扩充，让一个类的内部除了属性与方法之外还可以存在有其它类的结构，并且内部类也可以定义在方法或代码块中，但是从开发的角度来讲，要尽量避免使用内部类，优先考虑普通类。

一个内部类的例子

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(); 			// 调用外部类方法
	}
}

那内部类有什么用呢？

1.    内部类有一个最大的优点：可以直接访问外部类的私有属性和方法，避免了对象间的过多的传递引用。需要注意的是，外部类同样也可以访问内部类的私有属性

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

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 内部类()；

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() ;
	}
}

使用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就无法访问
			}
		}
	}
	public class TestDemo {
		public static void main(String args[]) {
			Outer.Inner in = new Outer.Inner() ;// 实例化“外部类”对象
			in.print() ;	// 调用方法

在方法中定义内部类（最常用）

内部类理论上可以在类的任意位置上进行定义，这就包括代码块之中，或者是普通方法之中 

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() ;
	}
}

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

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 !