普通/实例成员内部类
==================================================
1、成员内部类中不能定义静态变量
2、可以访问外部类的所有成员
public class Outer{
private static int i = 1;
private int j=10;
public static void outer_f1(){
//do more something
}
public void out_f2(){
//do more something
}
//成员内部类
class Inner{
int j=100;//内部类中外部类的相同名字的实例变量可以共存
void inner_f1(){
System.out.println(i); //访问外部类中与内部类不同名的实例变量直接用"变量名"
System.out.println(Outer.this.j);//访问外部类中与内部类同名的实例变量用"外部类名.this.变量名"
System.out.println(j); //在内部类中直接用变量名访问内部类自己的变量
System.out.println(this.j);//在内部类中也可以用"this.变量名"来访问内部类自己的变量
outer_f1();
outer_f2();
}
}
//外部类的非静态方法访问成员内部类
public void outer_f3(){
Inner inner = new Inner();
inner.inner_f1();
}
//外部类的静态方法访问成员内部类
public static void outer_f4(){
//step1 建立外部类对象
Outer out = new Outer();
//step2 根据外部类对象建立内部类对象（必须先有外部类的对象才能生成内部类的对象，因为内部类需要访问外部类中的成员变量，成员变量必须实例化才有意义）
Inner inner=out.new Inner();
//step3 访问内部类的方法
inner.inner_f1();
}
public static void main(String[] args){
outer_f4();
}
}
静态内部类----定义在类中，任何方法外，用static定义
=================================================================================
1、静态内部类中可以定义静态或者非静态的成员
2、静态内部类只能访问外部类的静态成员（包括静态变量和静态方法）
public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1(){
}
public void outer_f2(){
}
// 静态内部类中可以定义静态或者非静态的成员
static class Inner{
static int inner_i = 100;
int inner_j = 200;
static void inner_f1(){
System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员
outer_f1();
}
void inner_f2(){
}
}
public void outer_f3(){
// 外部类访问内部类的静态成员：内部类.静态成员
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部类访问内部类的非静态成员:实例化内部类即可
Inner inner = new Inner();
inner.inner_f2();
}
public static void main(String[] args) {
new Outer().outer_f3();
}
}
3、静态内部类可以用public,protected修饰
4、生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别，静态内部类的对象可以直接生成
而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类，所以静态内部类不可用private来进行定义。
局部内部类----在方法中定义的内部类，与局部变量类似
===========================================================================
1、局部内部类中不能定义静态变量
2、当访问外部类的局部变量(即方法内的变量)时，被访问的局部变量必须是final类型的
public class Outer {
private int s = 100;
private int out_i = 1;
public void f(final int k){
final int s = 200;
int i = 1;
final int j = 10;
class Inner{
int s = 300;
Inner(int k){
inner_f(k);
}
int inner_i = 100;
void inner_f(int k){
System.out.println(out_i); //访问外部类中的与内部类不同名的实例变量用"变量名"
System.out.println(Outer.this.s);//访问外部类中与内部类同名的实例变量用"外部类名.this.变量名"
System.out.println(s); //在内部类中直接用变量名访问内部类自己的变量
System.out.println(this.s);//在内部类中也可以用"this.变量名"来访问内部类自己的变量
System.out.println(k); //访问外部类的局部变量(即方法内的变量)，被访问的变量必须是final类型
}
new Inner(k);
}
public static void main(String[] args) {
//访问局部内部类必须先有外部类对象
Outer out = new Outer();
out.f(3);
}
}
3、局部内部类前不能用修饰符public,protected,private修饰，因为其作用范围就在定义它的代码块里
匿名内部类（一种特殊的局部内部类）
======================================================================
1、如同匿名数组一样，当你只需要创建一个类的对象而且用不上它的名字时可以使用java的匿名内部类
2、匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建
它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。
扩：记忆内部类可以记忆变量一样的
类变量从该类的准备阶段起开始存在，直到系统完全销毁这个类，类变量的作用域与这个类的生存范围相同；
而实例变量则从该类的实例被创建起开始存在，直到系统完全销毁这个实例，实例变量的作用域与对应实例的生存范围相同；
综上，所以先有类变量再有成员变量；
所以抛开可见性/访问权限（public，protected，default和private），静态成员（类，方法）只能访问静态成员（类，方法，变量），实例成员（类，方法）即可以访问静态成员又可以访问其他实例成员