四大内部类

一. 成员内部类

①定义: 把一个类当做普通成员变量那样定义。

class OuterClass{
	int a=0;
	class InnerClass{
		int b=1;
		void test(){
			System.out.println(a);
		}

	}
}

//主方法中:
OuterClass out=new OuterClass();
OuterClass.InnerClass inner=out.new InnerClass();

②成员内部类的使用:
a. 内部类的票的类型有固定格式为 外部类名称+”.”+内部类名称,构造方法为new +内部类类名+”()”;
b. 如果要生成内部类的实例，需要依靠外部类的实例.
c. 内部类会持有外部类类型的一张票,可以利用所持有的这张外部类类型的票直接访问外部类的成员变量和成员方法(包括静态成员变量和成员方法)
d. 外部类不可以直接访问到内部类的任何成员变量和成员方法
e. 注意内部类中两种不同的this所指向的内存区别
f. 实际的编译会生成两个class文件,分别为OuterClass.class和OuterrClass$InnerClass.class
g. 内部类里面不能定义静态的成员变量或者成员方法
(完全掌握的标准 是你可以将内部类提出来写 并且达到内部类的效果，这里需要的基础是大家对this关键字作为凭证的用法完全掌握)

拆分成两个类来写

class OuterClass{
	int age=18;
	void test(){

}

class InnerClass{
	int age=18;
	void test(){
		System.out.println(age);
		OuterClass.this.test();
}


}
} 
	//主方法:
	OuterClass outerClass=new OuterClass();
	OuterClass.InnerClass innerClass=outerClass.new OuterClass.InnerClass();
	innerClass.test();

class OuterClass{
	int age=18;
	void test(){

}
}

class InnerClass{
	int age=18;
	OutClass outClass;
	void test(){
		System.out.println(this.age);
		outClass.test();
	}
	InnerClass(OutClass outClass){
	this.outClass=outClass;
	}
	
}

//主方法中:
OuterClass outerClass=new OuterClass();
	InnerClass innerClass=new InnerClass(outerClass);
	innerClass.test();

二.静态内部类

①定义: 把一个类当做静态成员变量那样定义。

class OuterClass{
	static int a=0;
	void test(){
	System.out.println(OutClass.InnerClass.b);
	}
	static class InnerClass{
		static int b=1;
	void test(){
	System.out.println(a);
	}
}

}

②静态内部类的使用:
a.内部类的票的类型有固定格式为 外部类名称+”.”+内部类名称
b.如果要生成内部类的实例，不需要依靠外部类的实例
c. 内部类只可以直接访问到外部类的静态成员变量和静态成员方法
d. 外部类不可以直接访问到内部类的任何成员变量和成员方法(包括静态)
d. 实际的编译会生成两个class文件,分别为OuterClass.class和OuterrClass$InnerClass.class

class Out{
	static int ageOut=1;
	void test(){
	}
	static class Inner{
	int ageInner=2;
	void test1(){
		System.out.println(ageOut);
		System.out.println(test());
	}
	void test2(){
		}
	}
}
//主方法
Out.Inner inner=new Out.Inner();//静态内部类的实例

3.为什么静态内部类不可以访问外部类的普通成员变量和普通成员方法
因为静态内部类不会依靠外部类的实例生成对象，若能访问外部类的普通成员变量和普通成员方法，则可能找不到是哪个外部类对象的普通成员变量和普通成员方法。

三.匿名内部类

①出现了一个实例，这个实例并不属于我们所编写的任何模板,并且都伴随着向上转型的过程
②代码举例:
③在①中出现的实例若出现在成员方法中或是成员变量中，则这个实例实际上可以转换成成员内部类的一个实例，则这个实例拥有一个外部类实例的权限，具有成员内部类的所有特点。如果出现在静态方法中或静态成员变量中，则这个实例实际上可以转换成静态内部类的一个实例，则具有静态内部类的所有特点。

注意：这是静态方法下的匿名内部类

.class Entrance{
	int a=18;
	public static void main(String[] args){
		Person p=new Person(){
			void test(){
				System.out.println(“2-->”);
				①
			}
		};

	}
}

class Person{
	int b=19;
	void test(){
		System.out.println(“1-->”);
	}
}

**显式写

显式写出来:

class Entrance{
	int a=18;
	public static void main(String[] args){
		Person p=new Person1();
	}

   static class Person1 extends Person{
		void test(){
			System.out.println(“2-->”);	
		}
	}
}

问题: 在①的位置可以访问到Entrance的a么？可以访问到Person的b么？
访问不到Entrance的a，可以访问到Person的b。
因为实际上那个匿名类显示写出来是静态内部类，不能访问外部类的成员变量，但是静态内部类继承了Person，所以可以访问到Person的b.

注意这是普通方法下的匿名内部类

class Entrance{
	int a=18;
	public static void main(String[] args){
		
	}

	void test(){
		Person p=new Person(){
			void test(){
				System.out.println(“2-->”);
				②
			}
		};
	}

}
class Person{
	int b=19;
	void test(){
		System.out.println(“1-->”);
	}
}

显式写法

class Entrance{
	int a=18;
	public static void main(String[] args){
	}
	void test(){
		Person p=new Person1();
	}

class Person1 extends Person{
	void test(){
			System.out.println(“2-->”);	
			}
	}
}

四.局部类

我还没见过，孤陋寡闻了呜呜