内部类

内部类随着JAVA技术的发展，慢慢的已经形成了自己的独特应用。 

一、内部类的基本语法：

所谓的内部类就是指一个类的内部还包含了另外的一个操作类，被包含的类称为内部类，包含的类称为外部类。 

class Outer { // 定义外部类
	private String info = "Hello";

	class Inner { // 定义内部类
		public void print() {
			System.out.println(info); // 输出info属性
		}
	};

	public void fun() {
		new Inner().print();
	}
};

public class InnerDemo01 {
	public static void main(String args[]) {
		new Outer().fun();
	}
};

  从以上的代码中可以观察到内部类的特点： 
   1、  缺点：破坏了一个程序的标准结构； 
   2、  优点：可以方便的访问外部类中的私有成员。 
  如果要想观察出内部类优点的话，则需要将以上的Outer和Inner类拆分成两个独立的类。 

class Outer { // 定义外部类
	private String info = "Hello";

	public void fun() {
		new Inner(this).print();
	}

	public String getInfo() {
		return this.info;
	}
};

class Inner { // 定义内部类
	private Outer out;

	public Inner(Outer out) {
		this.out = out;
	}

	public void print() {
		System.out.println(out.getInfo()); // 输出info属性
	}
};

public class InnerDemo02 {
	public static void main(String args[]) {
		new Outer().fun();
	}
};

此时，现在的内部类是通过外部类的fun()方法进行对象实例化的，有没有可能在一个类的外部来实例化内部类的对象呢？ 
观察内部类的*.class 文件的格式：Outer$Inner.class，其中程序中的“$”符号要替换成“.”，也就是说现在内部类的类名称：外部类.内部类。 

class Outer { // 定义外部类
	private String info = "Hello";

	class Inner { // 定义内部类
		public void print() {
			System.out.println(info); // 输出info属性
		}
	};
};

public class InnerDemo03 {
	public static void main(String args[]) {
		Outer.Inner in = null; // 声明内部类的对象
		in = new Outer().new Inner();
		in.print();
	}
};

内部类如果要被外部所调用的话，则一定要先产生外部类的实例化对象，之后再产生内部类的实例化对象。 

二、使用static声明内部类 

  在内部类的定义中，也可以使用static 关键字完成操作，一旦使用static 声明了一个内部类的话，则此类将成为外部类，且只能访问外部类中的static成员。 

class Outer { // 定义外部类
	private static String info = "Hello";

	static class Inner { // 定义内部类，是static变为外部类
		public void print() {
			System.out.println(info); // 输出info属性
		}
	};
};

public class InnerDemo04 {
	public static void main(String args[]) {
		// Outer.Inner in = new Outer().new Inner() ;
		Outer.Inner in = new Outer.Inner();
		in.print();
	}
};

三、在方法中声明内部类

理论上而言，一个内部类可以在任意的位置上声明，例如：一个循环语句中，或者在一个方法之中，从开发来看，在方法中声明内部类的操作出现的是最多的。 

class Outer {
	private String info = "hello";

	public void fun() {
		class Inner { // 方法中声明内部类
			public void print() {
				System.out.println(info);
			}
		}
		;
		new Inner().print();
	}
};

public class InnerDemo05 {
	public static void main(String args[]) {
		new Outer().fun();
	}
};

 此时，可以发现，一个在方法中定义的内部类，依然可以访问外部类中的属性，但是对于方法的参数，这个内部类是无法直接访问的，如果要访问，则在参数前面必须使用final关键字进行声明。 

class Outer {
	private String info = "hello";

	public void fun(final int x) {
		final int y = 100;
		class Inner { // 方法中声明内部类
			public void print() {
				System.out.println(info);
				System.out.println("x = " + x);
				System.out.println("y = " + y);
			}
		}
		;
		new Inner().print();
	}
};

public class Test {
	public static void main(String args[]) {
		new Outer().fun(30);
	}
};

小结：

  ·  定义在一个类内部的类，被包含的类称为内部类，包含的类称为外部类。 
  ·  内部类可以直接访问外部类中的私有操作，但是会破坏原有程序的结构。 
  ·  内部类可以被static修饰，修饰之后的类成为外部类 
  ·  要是在类外部进行实例化，使用外部类.内部类 
  ·  如果没有被修饰，需要先实例化外部类对象，再实例化内部类对象 
  ·  可以在一个方法中定义一个内部类，这个内部类可以直接访问外部类中的私有操作，如果要访问方法中的变量，这些变量需要使用final来修饰。