面向对象深入1（内部类）

内部类

（内部类只是一个编译时概念，一旦编译成功 ，就会成为两个完全不同的类）
非静态内部类

1. 非静态内部类必须寄存在一个外部类对象里，所以，如果有一个非静态内部类对象，那么就一定存在对应的外部类对象，非静态内部类对象单独属于外部类的某个对象。
2. 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。
3. 非静态内部类不能有静态方法，静态属性，静态初始化块。
4. 成员变量访问
5. 内部类里方法的局部变量：变量名
6. 内部类属性：this.变量名
7. 外部类属性：外部类名.this.变量名

public class testInnerClass {
	public static void main(String[] args) {
		//创建内部类对象	//有内部类对象时，必然是有外部类对象的
		Outer.Inner inner=new Outer().new Inner();
		inner.show();
		}
}
class Outer{	//外部类
	private int age=100;
	public void testOuter(){
		System.out.println("Outer.testOuter()");
	}
	class Inner{	//创建内部类
		int qwe=10;
		public void show() {
			int awe=100;
			//内部类访问外部类成员变量（外部类名.this.变量名）
			System.out.println("外部类成员变量age:"+Outer.this.age);
			System.out.println("内部类成员变量qwe:"+this.qwe);
			System.out.println("内部类局部变量awe:"+awe);
		}
	}
}
> 编译结果
> 外部类成员变量age:100
> 内部类成员变量qwe:10
> 内部类局部变量awe:100

静态内部类

1. 静态内部类用static修饰
2. 静态内部类不依托外部类对象
3. 静态内部类访问
4. 通过 new 外部类名.内部类名() 来创建内部类对象

public class testStaticInnerClass {
	public static void main(String[] args) {
		//通过 new 外部类名.内部类名() 来创建内部类对象
		Outer2.Inner2 inner2=new Outer2.Inner2();
		inner2.show2();
	}
}
class Outer2{
	//相当于外部类的一个静态成员
	static class Inner2{
		public void show2() {
			System.out.println("Outer2.Inner2.show2()");
		}
	}
}
> 编译结果
> Outer2.Inner2.show2()

匿名内部类

1. 适合那种只需要使用一次的类
2. 匿名内部类没有访问修饰符
3. 匿名内部类没有构造方法、

public class testanonymityInnerClass {
	public static void test01(Outer3 a) {
		a.ou();
	}
	public static void main(String[] args) {
		testanonymityInnerClass.test01(new Outer3(){
			@Override
			public void ou() {
				System.out.println("testanonymityInnerClass.main(...).新建 Outer3() {...}.ou()");
			}		
		});
	}
}
interface Outer3{
	void ou();
}

方法内部类

1. 定义在方法内部的类，作用域仅限于该方法

public class testmethodInnerClass {
   public void test() {
		class Inner{	//作用仅限于该方法
			public void run() {
				System.out.println("test");
			}
		}
		   new Inner().run();
	}
   public static void main(String[] args) {
	new testmethodInnerClass().test();
   }
}