-
- 静态内部类与前面所讲的两种非静态内部类的语法基同。差别主如果在内部类的声明前面要加上static 关键字。别的，静态内部类也不成以用private进行定义。
- 静态内部类的对象可以直接生成，而不须要外部类的对象来生成，如许实际上是使静态内部类成为了一个类。这主如果因为静态内部类是外部类的静态成员，并不依附于外部类的对象而存在。
- 静态内部类与非静态内部类的差别是本质上的。非静态内部类是外部类对象构成的一项目组，主如果帮助外部类对象工作的，与外部类对象存在这对成员变量的共享关系。
Java内部类
添加时间:2013-5-9 点击量:转自：http://www.cnblogs.com/yan5lang/archive/2011/05/27/2059506.html
从Java1.1开端引入了内部类以来，它就引起了人们的激烈争辩。其实任何优良的说话特点用得不好就是滥用，内部类用得不好就会导致代码像迷宫一样，导致呈现毫无重用的综合征。
1、内部类分为成员内部类、静态嵌套类、办法内部类、匿名内部类。
几种内部类的共性：
A、内部类仍然是一个自力的类，在编译之后会内部类会被编译成自力的.class文件，然则前面冠以外部类的类命和￥符号。
B、内部类不克不及用通俗的体式格式接见。内部类是外部类的一个成员，是以内部类可以地接见外部类的成员变量，无论是否是private的。
2、成员内部类：情势如下
1 class Outer {
2 class Inner{}
3 }编译上述代产生两个文件：Outer.class和Outer￥Inner.class。
成员内部类内不容许有任何静态声明！下面代码不克不及经由过程编译。
1 class Inner{
2 static int a = 10;
3 }可以或许接见成员内部类的独一路子就是经由过程外部类的对象！
A、从外部类的非静态办法中实例化内部类对象。
1 class Outer {
2 private int i = 10;
3 public void makeInner（）{
4 Inner in = new Inner（）;
5 in.seeOuter（）;
6 }
7 class Inner{
8 public void seeOuter（）{
9 System.out.print（i）;
10 }
11 }
12 }概况上，我们并没有创建外部类的对象就实例化了内部类对象，和上方的话抵触。
事实上，若是不创建外部类对象也就不成能调用makeInner（）办法，所以到头来还是要创建外部类对象的。
你可能试图把makeInner（）办法润饰为静态办法，即static public void makeInner（）。
如许不创建外部类就可以实例化外部类了！
然则在一个静态办法里能接见非静态成员和办法吗？显然不克不及。
它没有this引用。没能跳出那条规矩！
然则若是在这个静态办法中实例化一个外部类对象，再用这个对象实例化外部类呢？完全可以！也就是下一条的内容。
B、从外部类的静态办法中实例化内部类对象。
1 class Outer {
2 private int i = 10;
3 class Inner{
4 public void seeOuter（）{
5 System.out.print（i）;
6 }
7 }
8 public static void main（String[] args） {
9 Outer out = new Outer（）;
10 Outer.Inner in = out.new Inner（）;
11 //Outer.Inner in = new Outer（）.new Inner（）;
12 in.seeOuter（）;
13 }
14 }被注释掉的那行是它上方两行的归并情势，一条简洁的语句。
对比一下：在外部类的非静态办法中实例化内部类对象是通俗的new体式格式：Inner in = new Inner（）;
在外部类的静态办法中实例化内部类对象，必须先创建外部类对象：
Outer.Inner in = new Outer（）.new Inner（）;
C、内部类的this引用。
通俗的类可以用this引用当前的对象，内部类也是如此。然则假若内部类想引用外部类当前的对象呢？用“外部类名”.this；的情势，如下例的 Outer.this。
1 class Outer {
2 class Inner{
3 public void seeOuter（）{
4 System.out.println（this）;
5 System.out.println（Outer.this）;
6 }
7 }
8 }D、成员内部类的润饰符。
对于通俗的类，可用的润饰符有final、abstract、strictfp、public和默认的包接见。
然则成员内部类更像一个成员变量和办法。
可用的润饰符有：final、abstract、public、private、protected、strictfp和static。 一旦用static润饰内部类，它就变成静态内部类了。
3、办法内部类。
顾名思义，把类放在办法内。
1 class Outer {
2 public void doSomething（）{
3 class Inner{
4 public void seeOuter（）{
5 }
6 }
7 }
8 }A、办法内部类只能在定义该内部类的办法内实例化，不成以在此办法外对其实例化。
B、办法内部类对象不克不及应用该内部类地点办法的非final局部变量。
因为办法的局部变量位于栈上，只存在于该办法的生命期内。
当一个办法停止，其栈布局被删除，局部变量成为汗青。
然则该办法停止之后，在办法内创建的内部类对象可能仍然存在于堆中！
例如，若是对它的引用被传递到其他某些代码，并存储在一个成员变量内。
正因为不克不及包管局部变量的存活期和办法内部类对象的一样长，所以内部类对象不克不及应用它们。
[讲的太好了，之前的困惑如今没有了]
下面是完全的例子：
1 class Outer {
2 public void doSomething（）{
3 final int a =10;
4 class Inner{
5 public void seeOuter（）{
6 System.out.println（a）;
7 }
8 }
9 Inner in = new Inner（）;
10 in.seeOuter（）;
11 }
12 public static void main（String[] args） {
13 Outer out = new Outer（）;
14 out.doSomething（）;
15 }
16 }C、办法内部类的润饰符。
与成员内部类不合，办法内部类更像一个局部变量。 可以用于润饰办法内部类的只有final和abstract。
D、静态办法内的办法内部类。
静态办法是没有this引用的，是以在静态办法内的内部类遭受同样的待遇，即：只能接见外部类的静态成员。
4、匿名内部类。
顾名思义，没有名字的内部类。概况上看起来它们似乎有名字，实际那不是它们的名字。
A、持续式的匿名内部类。
1 class Car {
2 public void drive（）{
3 System.out.println（Driving a car!）;
4 }
5 }
6
7 class Test{
8 public static void main（String[] args） {
9 Car car = new Car（）{
10 public void drive（）{
11 System.out.println（Driving another car!）;
12 }
13 };
14 car.drive（）;
15 }
16 }成果输出了：Driving another car! Car引用变量不是引用Car对象，而是Car匿名子类的对象。
建树匿名内部类的关键点是重写父类的一个或多个办法。
再夸大一下，是重写父类的办法，而不是创建新的办法。
因为用父类的引用不成能调用父类本身没有的办法！
创建新的办法是多余的。简言之，参考多态。
B、接口式的匿名内部类。
1 interface Vehicle {
2 public void drive（）;
3 }
4
5 class Test{
6 public static void main（String[] args） {
7 Vehicle v = new Vehicle（）{
8 public void drive（）{
9 System.out.println（Driving a car!）;
10 }
11 };
12 v.drive（）;
13 }
14 }上方的代码很怪，如同是在实例化一个接口。
事实并非如此，接口式的匿名内部类是实现了一个接口的匿名类。
并且只能实现一个接口。
C、参数式的匿名内部类。
1 class Bar{
2 void doStuff（Foo f）{}
3 }
4
5 interface Foo{
6 void foo（）;
7 }
8
9 class Test{
10 static void go（）{
11 Bar b = new Bar（）;
12 b.doStuff（new Foo（）{
13 public void foo（）{
14 System.out.println（foofy）;
15 }
16 }）;
17 }
18 }5、静态嵌套类。
从技巧上讲，静态嵌套类不属于内部类。
因为内部类与外部类共享一种特别关系，更确切地说是对实例的共享关系。
而静态嵌套类则没有上述关系。它只是地位在另一个类的内部，是以也被称为嵌套类。
静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也可以或许接见它。
静态嵌套类不克不及接见外部类的成员和办法。
1 class Outer{
2 static class Inner{}
3 }
4 class Test {
5 public static void main（String[] args）{
6 Outer.Inner n = new Outer.Inner（）;
7 }
8 }
静态内部类：不克不及接见外部类的非静态成员，这是由Java语法中静态办法不克不及直接接见非静态成员所限制。
若想接见外部类的变量，必须经由过程其它办法解决，因为这个原因，静态嵌套类应用很少。
静态内部类其实已经离开了外部类。
在创建静态内部类对象时也不须要外部类对象的存在。
其本质是一个放置在此外类内部的通俗类。
而关键字static也只是申明其在创建对象时不依附于外部类对象的存在，并不是说这个类本身是静态的。
http://hi.baidu.com/zhumulangma/item/bcd478c140427b2cef466532
所有随风而逝的都属于昨天的，所有历经风雨留下来的才是面向未来的。—— 玛格丽特·米切尔 《飘》
