Javaの内部クラスと匿名内部クラスの紹介

4つの内部Javaクラス

使用するJava内部クラスと匿名内部クラス

印象を深めるためには、内部クラスのコード-4種類のハンズオン。

内部クラスのメンバー：

package innerclass;

/**内部类之一：成员内部类的实现  相当于非静态方法
 *
 * 
 */
public class MemberInner {
	private String a = "OuterMember"; //外部类属性
	private int b = 3;
	
	public static void main(String[] args) {
		//当在静态方法或外部类外的类调用成员属性需要如此申明实例，如果是普通方法，则可以去掉MemberInner
		MemberInner.inner in = new MemberInner().new inner();
		System.out.println(in.bb + " " + in.a); //无论内部类属性是不是私有，都可以访问到
		in.show();
	}
	
	 class inner{ //创建成员内部类
		 private String a = "InnerMember"; //内部类属性，该属性与外部类属性同名
		 private int bb = 2;
		 void show(){
			//如果存在同名属性，必须加上前缀调用，如果没有同名，可以去掉前缀直接调用。
			 System.out.println(MemberInner.this.a + " " + b);
		 }
	 }
}

静的な内部クラス：

package innerclass;

import innerclass.MemberInner.inner;

/**
 * 静态内部类
 *
 * 
 */
public class StaticInner {
	private static String a = "OuterMember"; //外部类属性
	private static int b = 3;
	
	public static void main(String[] args) {
		//当在静态方法或外部类外的类调用成员属性需要如此申明实例，如果是普通方法，则可以去掉StaticInner
		StaticInner.inner in = new StaticInner.inner();//注意与成员内部类的区别，没有new了
		//无论内部类属性是不是私有，都可以访问到,当然如果是其他类，还是需要满足修饰符的访问权限的
		System.out.println(in.bb + " " + in.a); 
		in.show();
	}
	
	static class inner{ //创建静态内部类,如果访问外部类的成员的话只能访问静态的
		 private String a = "InnerMember"; //内部类属性，该属性与外部类属性同名
		 private int bb = 2;
		 void show(){
			//如果存在同名属性，必须加上前缀调用，如果没有同名，可以去掉前缀直接调用。
			 System.out.println(StaticInner.a + " " + b);
		 }
	 }
}

部分的な内部クラス：

package innerclass;

/**
 *局部内部类
 * 
 */
public class LocalInner {
	private String a = "OuterClass";
	private int b = 0;
	
	void show(){
		final String a = "method";
		class inner{ //在方法里创建局部内部类
			String aa = a; //只能访问当前方法中的final变量
		}
	}
}

匿名内部クラス：

package innerclass;

import java.util.Date;

/**
 *匿名内部类
 */
public class AnonymousInner {
	private String a = "OuterClass";
	private int b = 0;
	
	void testAnonymousClass(){
		//匿名内部类的格式就是这样，没有名字，Date就是匿名内部类的父类，当然这里放接口也行。若父类构造函数还有参数，则括号内
		//还应该加上对应参数
		show(new Date() { 
			public long getTime() {
                return 10086;
			}
        });
	}
	
	void show(Date d){
		System.out.println(d.getTime());
	}
	
	public static void main(String[] args) {
		AnonymousInner ai = new AnonymousInner();
		ai.testAnonymousClass();
	}
}

ここで達成するためにすべての4つの内部コードのクラスは、非常に包括的です！

package innerclass;

import java.util.Date;

class OutClass {
	private static String field_Static = "外围类：静态变量";
	private String field_Common = "外围类：普通变量";

	private static void methodStatic() {
		System.out.println("外围类：静态方法");
	}

	private void methodCommon() {
		System.out.println("外围类：普通方法");
	}

	// 成员内部类
	class InnerClassMember {
		// Err:
		// private static String inner_fieldStatic = "内部类：静态变量";
		private String inner_fieldCommon = "|---内部类：普通变量";

		// Err:
		// private static void innerMethodStatic() {}
		private void innerMethodCommon() {
			System.out.println("|---内部类：普通方法");
		}

		public void methodInner() {
			// 变量·外
			System.out.println(OutClass.this.field_Common);
			System.out.println(field_Static);//不重名可直接调用
			// 变量·内
			System.out.println(inner_fieldCommon);
			// 方法·外
			methodStatic();
			OutClass.this.methodCommon();
			// 方法·内
			innerMethodCommon();
		}
	}

	// 静态内部类
	static class InnerClassStatic {
		private static String inner_fieldStatic = "|---静态内部类：静态变量";
		private String inner_fieldCommon = "|---静态内部类：普通变量";

		private static void innerMethodStatic() {
			System.out.println("|---静态内部类：静态方法");
		}

		private void innerMethodCommon() {
			System.out.println("|---静态内部类：普通方法");
		}

		public void methodInner() {
			// 变量·外
			System.out.println(OutClass.field_Static);
			// 变量·内
			System.out.println(inner_fieldCommon);
			System.out.println(inner_fieldStatic);
			// 方法·外
			OutClass.methodStatic();
			// 方法·内
			innerMethodStatic();
			innerMethodCommon();
		}
	}

	// 局部內部类
	public void method4InnerClassLocal() {
		String localField = "局部变量";
		final String localFieldFinal = "局部变量(final)";
		// ↑Java 8中不用加final，但局部内部类中不能修改其值
		// 局部内部类
		class InnerClassLocal {
			public void localClassM() {
				// Err: System.out.println(localField);
				System.out.println(localFieldFinal);
				System.out.println(field_Common);
				System.out.println(field_Static);
				methodCommon();
				methodStatic();
			}
		}
		InnerClassLocal _local_in_c = new InnerClassLocal();
		_local_in_c.localClassM();
	}

	// --------------------
	public void testAnonymousClass() {
		// 匿名内部类
		PrintDate(new Date() {
			public long getTime() {
				System.out.println(field_Common);
				System.out.println(field_Static);
				methodCommon();
				methodStatic();
				return 10086;
			}
		});
	}

	private void PrintDate(Date dt) {
		System.out.println(dt.getTime());
	}
}

public class InnerClassTest1 {
	public static void main(String[] args) {
		System.out.println("===↓↓↓成员内部类===================");
		OutClass.InnerClassMember ic = new OutClass().new InnerClassMember();
		ic.methodInner();
		System.out.println("===↓↓↓静态内部类===================");
		OutClass.InnerClassStatic ics = new OutClass.InnerClassStatic();//只有一个new
		ics.methodInner();
		System.out.println("===↓↓↓局部内部类===================");
		OutClass oc = new OutClass();
		oc.method4InnerClassLocal();
		System.out.println("===↓↓↓匿名内部类===================");
		oc.testAnonymousClass();
	}
}