内部类

成员内部类

public class NBClass{
	
	public void test(){
		System.out.println("外部类方法");
	}
	
	public static void test2(){
		System.out.println("外部类静态方法");
	}
	class demo{
		//不可定义静态方法
		
		//静态成员需同时有final关键字修饰
		static final String str = "静态成员需同时有final关键字修饰";
		public void classDemo(){
			System.out.println("内部类方法---");
			System.out.println(str);
			
			//内部类访问外部类非static.this.成员方法/属性
			//外部类名.this.外部类成员方法/属性
			NBClass.this.test();
			//可以直接访问外部类静态方法
			test2();
		}
	}
	
	public static void main(String[] args){
		//NBClass nn = new NBClass();
		//外部类名.内部类名 实例名 = 外部类实例名.new 内部类构造方法(参数);
		//非静态内部类与静态内部类创建实例都需要通过外部类实例创建
		//静态内部类直接调用静态内部类名即可，非静态内部类通过new关键字创建
		NBClass.demo nd = new NBClass(). new demo();
		nd.classDemo();
	}
	
	/**与外部类平级的类继承内部类时，其构造方法中需要传入父类的实例对象。且
	  *在构造方法的第一句调用“外部类实例名.super(内部类参数)”
	  */
}

静态内部类

public class NBClass2{
	
	String NBClass2str = "外部类成员";
	
	static String NBClassstr2 = "外部类静态成员";
	
	//静态
	public static class demo{
		public static String str = "静态内部类可以直接有静态成员";
		public static void demoTest(){
			System.out.println(str);
			System.out.println("静态内部类可以有静态方法");
		}
		public void classDemo(){
			System.out.println("静态内部类");
			
			//不可访问外部类非静态成员/方法
			//System.out.println(NBClass2);
			
			//访问外部类静态成员
			System.out.println(NBClassstr2);
		}
	}
	
	public static void main(String[] args){
		//外部类名.内部类名 实例名 = new 外部类名.内部类名(参数);
		NBClass2.demo nd = new NBClass2.demo();
		nd.classDemo();
		nd.demoTest();
		
	}
	
}

局部内部类

public class NBClass3{
	
    // 局部内部类只能在代码代码块、方法体内和作用域中使用（如创建对象和使用类对象等）
    // 局部内部类访问作用域内的局部变量，该局部变量需要使用final修饰。
    // 可以使用abstract修饰，声明为抽象类。
	public void NBClass3test(){
		System.out.println("外部非静态属性/方法访问格式：外部类名.this.成员方法/属性");
	}
	static String NBClass3str = "外部类成员变量";
	
	public void test(){
		
		class demoTest{
			//不可定义静态方法
			//静态成员需要同时用final修饰
			static final String str = "静态成员需要同时使用final修饰";
			
			public void tDemo(){
				NBClass3.this.NBClass3test();
				System.out.println(str);
				//外部类静态变量直接调用
				System.out.println(NBClass3str);

			}
		}
		//在方法中创建局部内部类实例,通过外部类实例调用方法，运行内部类
		demoTest dt = new demoTest();
		dt.tDemo();
	}
	
	public static void main(String[] args){
		NBClass3 n3 = new NBClass3();
		//NBClass3.demoTest nd = n3.new demoTest();
		//nd.tDemo();
		n3.test();
	}
}
// 与外部类平级的类继承内部类时，其构造方法中需要传入父类的实例对象。
// 且在构造方法的第一句调用“外部类实例名.super(内部类参数)”

匿名内部类

class NBC{
	public void test(){}
}
/*
 *匿名内部类不可以定义静态成员方法，访问外部非static属性/方法：外部类名.this.成员方法/属性
 *外部类访问内部类通过内部类的一个实例访问
*/
public class NBClass4{
	NBC n;
	public NBClass4(NBC n){
		this.n = n;
	}
	
	public void demo(){
		n.test();
	}
	public static void main(String[] args){
		NBClass4 n = new NBClass4(new NBC(){
			public void test(){
				System.out.println("匿名内部类");
			}
		});
		n.demo();
		
		//直接调用匿名内部类方法
		new NBC(){
			public void test(){
				System.out.println("匿名内部类");
			}
		}.test();

	}
}