普通/实例成员内部类

==================================================

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)，静态成员(类，方法)只能访问静态成员(类，方法，变量)，实例成员(类，方法)即可以访问静态成员又可以访问其他实例成员