java内部类学习笔记

注意：纯属个人笔记。

笔记1：常规内部类（有包名）

package cn.hncu.map.inner;

public class MyOuter {
	private int x = 100;

	// 创建内部类
	class MyInner {
		private String y = "Hello!";

		public void innerMethod() {
			System.out.println("内部类中 String =" + y);
			System.out.println("外部类中的x =" + x);// 直接访问外部类中的实例变量x
			outerMethod();
			System.out.println("x is" + MyOuter.this.x);
		}
	}

	public void outerMethod() {
		x++;
	}

	/*
	 * 通过外部类的函数创建内部类，
	 * 外部类的函数与内部类其实是兄弟关系，
	 * 这时可以把内部类看成一个函数，
	 * newInnerInstance（）调用内部类。
	 */
	public MyInner newInnerInstance() {
		// 在外部类方法中创建内部类实例
		MyInner inner = new MyInner();
		return inner;
	}

	public static void main(String[] args) {
		MyOuter mo = new MyOuter();
		/*
		 *  创建方案一，该方法错误无法创建实例。
		 */
		// MyInner inner1 = new MyInner();
		/*
		 *  创建方案二，该方法可行。
		 *  常规内部类需要通过外部类的实例才能创建对象，
		 *  与实例变量需要通过对象来访问相似。
		 *  例如：调用x 》》》 mo.x 相当于 mo.new MyInner()，
		 *  调用内部累的时候就创建实例，且是内名实例，然后将该类返回给inner2。
		 */
		MyInner inner2 = mo.new MyInner();
		/*
		 *  创建方案三，该方法可行。
		 */
		MyOuter.MyInner inner3 = mo.new MyInner();
		/*
		 * 创建方案四，该方法可行。
		 */
		MyOuter.MyInner inner4 = mo.newInnerInstance();
	}

}

在bin中生成的"*.class"文件

笔记2：静态内部类

package cn.hncu.collection.mapSystem.inner2;

public class MyOuter {
	private int x = 100;

	/*
	 *  创建内部类
	 *  public static这两个都是修士符，
	 *  public是文件的访问权限，
	 *  没有写修士符，就表明该成员是同包访问，
	 *  他的父包或子包内的类中的函数无法
	 *  --调用该类的这个成员（java中的包就windows中的文件夹）；
	 *  static是类成员的运行时间设置，
	 *  定义成static后，该成员就会在该实例构造前就生成，
	 *  所以java的静态函数中不能直接调用非静态的成员。
	 */
	public static class MyInner {
		private String y = "Hello!";

		public void innerMethod() {
			System.out.println("内部类中 String =" + y);
		}
	}

	/*
	 * 通过外部类的函数创建内部类，
	 * 外部类的函数与内部类其实是兄弟关系，
	 * 这时可以把内部类看成一个函数，
	 * newInnerInstance（）调用内部类。
	 */
	public MyInner newInnerInstance() {
		// 在外部类方法中创建内部类实例
		MyInner inner = new MyInner();
		return inner;
	}

	public static void main(String[] args) {
		MyOuter mo = new MyOuter();
		/*
		 *  创建方案一，该方法错误无法创建实例。
		 */
		MyInner inner1 = new MyInner();
		/*
		 *  创建方案二，该方法错误。
		 */
		//MyOuter.MyInner inner2 = mo.new MyInner();
		/*
		 * 创建方案三，该方法可行。
		 */
		MyOuter.MyInner inner3 = mo.newInnerInstance();
	}

}

包树图片：

笔记三：局部内部类

package cn.hncu.collection.mapSystem.inner3;

public class LocalInner {
	private int size = 5, y = 7;

	/*
	 * makeInner-创建局部内部类函数
	 */
	public Object makeInner(int localVar) {
		final int finalLocalVar = localVar;
		/*
		 * finalLocalVar-局部变量
		 * 只有final才可以被局部内部类直接访问。
		 *  创建内部类，
		 *  该类只在makeInner（）方法有效，
		 *  就像局部变量一样。
		 *  在方法体外部不能创建MyInner类的对象。
		 */
		class MyInner {
			int y = 4;

			public String toString() {
				return "OuterSize:" + size + "\nfinalLocalVar" + finalLocalVar
						+ " " + "this.y=" + this.y;
			}
		}
		return new MyInner();
	}
}

class Main {
	public static void main(String[] args) {
		/*
		 * 创建Jubu对象obj，
		 * 并调用它的makeInner（）方法，
		 * 该方法返回一个
		 */
		Object obj = new LocalInner().makeInner(47);
		/*
		 *  该方法返回一个MyInner类型的的对象obj，
		 *  然后调用其同toString方法。
		 */
		System.out.println(obj.toString());
	}
}

笔记四：匿名内部类

package cn.hncu.collection.mapSystem.inner4;

/*
 * AnomynityInner-匿名内部类
 */
public class AnomynityInner {
	private int size = 5;

	public Object makeInner(int localVar) {
		final int finalLocalVar = localVar;
		return new Object() {
			// 使用匿名内部类
			public String toString() {
				return "OuterSize=" + size + "\nfinalLocalVar=" + finalLocalVar;

			}

		};

	}

	public static void main(String args[]) {
		Object obj = new AnomynityInner().makeInner(47);
		System.out.println(obj.toString());

	}
}

总结：

定义为public 的内部类可以直接定义类型，不需要通过外部类名来调用。

例如：

包名Exercise01中的类A{

class Inner01 {

}

public class Inner02 {

}

}

包名Exercise02中的类B{

public static void main(String args[]){

A a = new A();

通过A.Inner01 无法调用

通过A.Inner02 就可以调用

也可以直接定义Inner02

例如：

Inner02 in1 = null;

}

}

----但是

超链接：java四种内部类详解