java内部类总结

内部类

本文主要参照网上的一些相关文章、以及thinking in java 第三版，对java里面的内部类进行了一个较为详细的总结

内部 类 是指在一个外部 类 的内部再定 义 一个 类 。内部 类 作 为 外部 类 的一个成 员 ，并且依附于外部 类 而存在的。内部 类 可 为 静 态 ，可用 protected 和 private 修 饰 （而外部 类 只能使用 public 和缺省的包访问权限）。内部类主要有以下几类： 成员内部类、局部内部类、静态内部类、匿名内部类

 

为什么需要内部类？

典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是：

每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。

 

A：成员内部类
作 为 外部 类 的一个成 员 存在，与外部 类 的属性、方法并列。

publicclass  Outer {

        privatestaticint i  = 1;

        privateint j  = 10;

        privateint k  = 20;

 

        publicstaticvoid outer_f1()  {

       }

 

        publicvoid outer_f2()  {

       }

 

        //  成 员 内部 类 中，不能定 义 静 态 成 员

        //  成 员 内部 类 中，可以 访问 外部 类 的所有成 员

        class  Inner {

               // static int inner_i = 100;// 内部 类 中不允 许 定 义 静 态变 量

               int j  = 100;  //  内部 类 和外部 类 的 实 例 变 量可以共存

               int inner_i  = 1;

 

               void  inner_f1() {

                     System. out .println( i );

                           // 在内部 类 中 访问 内部 类 自己的 变 量直接用 变 量名

                      System. out .println( j );

                           // 在内部 类 中 访问 内部 类 自己的 变 量也可以用 this. 变 量名

                      System. out .println( this . j );

                           // 在内部 类 中 访问 外部 类 中与内部 类 同名的 实 例 变 量用外部 类 名 .this. 变 量名

                      System. out .println(Outer. this . j );

                           // 如果内部 类 中没有与外部 类 同名的 变 量， 则 可以直接用 变 量名 访问 外部 类变 量

                      System. out .println( k );

                                          outer_f1();

                                          outer_f2();

              }

       }

 

        // 外部 类 的非静 态 方法 访问 成 员 内部 类

        publicvoid outer_f3()  {

              Inner inner =  new  Inner();

               inner.inner_f1();

       }

 

        //  外部 类 的静 态 方法 访问 成 员 内部 类 ，与在外部 类 外部 访问 成 员 内部 类 一 样

        publicstaticvoid outer_f4 () {

               //step1  建立外部 类对 象

              Outer out =  new  Outer();

               //step2  根据外部 类对 象建立内部 类对 象

              Inner inner = out. new  Inner();

               //step3  访问 内部 类 的方法

              inner.inner_f1();

       }

 

        publicstaticvoid  main(String[] args) {

               //outer_f4();// 该语 句的 输 出 结 果和下面三条 语 句的 输 出 结 果一 样

               // 如果要直接 创 建内部 类 的 对 象，不能想当然地 认为 只需加上外 围类 Outer 的名字，

               // 就可以按照通常的 样 子生成内部 类 的 对 象，而是必 须 使用此外 围类 的一个 对 象来

               // 创 建其内部 类 的一个 对 象：

               //Outer.Inner outin = out.new Inner()

               // 因此，除非你已 经 有了外 围类 的一个 对 象，否 则 不可能生成内部 类 的 对 象。因 为 此

               // 内部 类 的 对 象会悄悄地 链 接到 创 建它的外 围类 的 对 象。如果你用的是静 态 的内部 类 ，

               // 那就不需要 对 其外 围类对 象的引用。

               Outer out =  new  Outer();

               Outer.Inner outin = out. new  Inner();

               outin.inner_f1();

       }

}

注意：内部 类 是一个 编译时 的概念，一旦 编译 成功，就会成 为 完全不同的两 类 。 对 于一个名 为 outer 的外部 类 和其内部定 义 的名 为 inner 的内部 类 。 编译 完成后出 现 outer.class 和 outer$inner.class 两 类 。

 

B:局部内部类
在方法中定 义 的内部 类 称 为 局部内部 类 。与局部 变 量 类 似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。

 

publicclass  Outer {

        privateint s  = 100;

        privateint out_i  = 1;

 

        publicvoid  f( finalint  k) {

               finalint  s = 200;

               int  i = 1;

               finalint  j = 10;

             

                   // 定 义 在方法内部

               class  Inner {

                      int s  = 300; //  可以定 义 与外部 类 同名的 变 量

 

                      // static int m = 20;// 不可以定 义 静 态变 量

                     Inner( int  k) {

                             inner_f (k);

                     }

 

                      int inner_i  = 100;

 

                      void inner_f ( int  k) {

                           // 如果内部 类 没有与外部 类 同名的 变 量，在内部 类 中可以直接 访问 外部 类 的 实 例 变 量

                             System. out .println( out_i );

                           // 可以 访问 外部 类 的局部 变 量 ( 即方法内的 变 量 ) ，但是 变 量必 须 是 final 的

                             System. out .println( j );

                             //System.out.println(i);

                           // 如果内部 类 中有与外部 类 同名的 变 量，直接用 变 量名 访问 的是内部 类 的 变 量

                             System. out .println( s );

                           // 用 this. 变 量名 访问 的也是内部 类变 量

                             System. out .println( this . s );

                           // 用外部 类 名 .this. 内部 类变 量名 访问 的是外部 类变 量

                             System. out .println(Outer. this . s );

                     }

              }

               new  Inner(k);

       }

 

        publicstaticvoid  main(String[] args) {

               //  访问 局部内部 类 必 须 先有外部 类对 象

               Outer out =  new  Outer();

              out.f(3);

        }

}

 

C：静态内部类(嵌套类) ： （注意：前两 种 内部 类 与 变 量 类 似，所以可以 对 照参考 变 量）
如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为 static 。这通常称为嵌套类（ nested class ）。想要理解 static 应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是 static 的时，就不是这样了。嵌套类意味着：

1.  要创建嵌套类的对象，并不需要其外围类的对象。

2.  不能从嵌套类的对象中访问非静态的外围类对象。

 

publicclass  Outer {

        privatestaticint i  = 1;

        privateint j  = 10;

        publicstaticvoid outer_f1 () {

       }

 

        publicvoid outer_f2 () {

       }

 

        //  静 态 内部 类 可以用 public,protected,private 修 饰

        //  静 态 内部 类 中可以定 义 静 态 或者非静 态 的成 员

        staticclass  Inner {

               staticint inner_i  = 100;

               int inner_j  = 200;

               staticvoid inner_f1 () {

                       // 静 态 内部 类 只能 访问 外部 类 的静 态 成 员 ( 包括静 态变 量和静 态 方法 )

                     System. out .println( "Outer.i"  +  i );

                      outer_f1();

              }

 

               void inner_f2()  {

                      //  静 态 内部 类 不能 访问 外部 类 的非静 态 成 员 ( 包括非静 态变 量和非静 态 方法 )

                      // System.out.println("Outer.i"+j);

                      // outer_f2();

              }

       }

 

        publicvoid outer_f3()  {

               //  外部 类访问 内部 类 的静 态 成 员 ：内部 类 . 静 态 成 员

               System. out .println(Inner. inner_i );

               Inner.inner_f1();

               //  外部 类访问 内部 类 的非静 态 成 员 : 实 例化内部 类 即可

               Inner inner =  new  Inner();

               inner.inner_f2();

       }

 

        publicstaticvoid  main(String[] args) {

               new Outer().outer_f3();

       }

}

生成一个静 态 内部 类 不需要外部 类 成 员 ： 这 是静 态 内部 类 和成 员 内部 类 的区 别 。静 态 内部 类 的 对 象可以直接生成： Outer.Inner in = new Outer.Inner(); 而不需要通 过 生成外部 类对 象来生成。 这样实际 上使静 态 内部 类 成 为 了一个 顶级类 ( 正常情况下，你不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，因为它是 static  的。只是将嵌套类置于接口的命名空间内，这并不违反接口的规则）

 

D：匿名内部类(from thinking in java 3th)

简单地说：匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：

　　 · 只用到类的一个实例。  
　　 · 类在定义后马上用到。  
　　 · 类非常小（ SUN 推荐是在 4 行代码以下）  
　　 · 给类命名并不会导致你的代码更容易被理解。

　　在使用匿名内部类时，要记住以下几个原则：

　　 · 匿名内部类不能有构造方法。  
　　 · 匿名内部类不能定义任何静态成员、方法和类。  
　　 · 匿名内部类不能是 public,protected,private,static 。  
　　 · 只能创建匿名内部类的一个实例。

· 一个匿名内部类一定是在 new 的后面，用其隐含实现一个接口或实现一个类。  
　　 · 因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。  

 

下面的例子看起来有点奇怪：

// 在方法中返回一个匿名内部类

public class Parcel6 {

        public Contents cont() {

                return new Contents() {

                     private int i = 11;

 

                     public int value() {

                            return i;

                     }

              } ;  //  在这里需要一个分号

        }

 

        public static void main(String[] args) {

                Parcel6 p = new Parcel6();

                Contents c = p.cont();

        }

}

cont() 方法将下面两个动作合并在一起：返回值的生成，与表示这个返回值的类的定义！进一步说，这个类是匿名的，它没有名字。更糟的是，看起来是你正要创建一个 Contents 对象：

return new Contents()

但是，在到达语句结束的分号之前，你却说：“等一等，我想在这里插入一个类的定义” :

return new Contents() {

private int i = 11;

public int value() { return i; }

};

这种奇怪的语法指的是：“创建一个继承自 Contents 的匿名类的对象。”通过 new  表达式返回的引用被自动向上转型为对 Contents 的引用。匿名内部类的语法是下面例子的简略形式：

class MyContents implements Contents {

private int i = 11;

public int value() { return i; }

    }

return new MyContents();

在这个匿名内部类中，使用了缺省的构造器来生成 Contents 。下面的代码展示的是，如果你的基类需要一个有参数的构造器，应该怎么办：

public class Parcel7 {

public Wrapping wrap(int x) {

// Base constructor call:

return new Wrapping(x) { // Pass constructor argument.

public int value() {

return super.value() * 47;

            }

} ; // Semicolon required

    }

public static void main(String[] args) {

Parcel7 p = new Parcel7();

Wrapping w = p.wrap(10);

    }

}

只需简单地传递合适的参数给基类的构造器即可，这里是将 x  传进 new Wrapping(x) 。在匿名内部类末尾的分号，并不是用来标记此内部类结束（ C++ 中是那样）。实际上，它标记的是表达式的结束，只不过这个表达式正巧包含了内部类罢了。因此，这与别的地方使用的分号是一致的。

 

如果在匿名类中定义成员变量，你同样能够对其执行初始化操作：

public class Parcel8 {

// Argument must be final to use inside

// anonymous inner class:

public Destination dest(final String dest) {

return new Destination() {

private String label = dest;

public String readLabel() { return label; }

};

    }

public static void main(String[] args) {

Parcel8 p = new Parcel8();

Destination d = p.dest("Tanzania");

    }

}

如果你有一个匿名内部类，它要使用一个在它的外部定义的对象，编译器会要求其参数引用是final 型的 ，就像 dest() 中的参数。如果你忘记了，会得到一个编译期错误信息。如果只是简单地给一个成员变量赋值，那么此例中的方法就可以了。但是，如果你想做一些类似构造器的行为，该怎么办呢？在匿名类中不可能有已命名的构造器（因为它根本没名字！），但通过实例初始化，你就能够达到为匿名内部类“制作”一个构造器的效果。像这样做：

abstract class Base {

public Base(int i) {

System.out.println("Base constructor, i = " + i);

    }

public abstract void f();

}

 

public class AnonymousConstructor {

public static Base getBase(int i) {

return  new Base(i) {

            {

System.out.println("Inside instance initializer");

            }

public void f() {

System.out.println("In anonymous f()");

            }

};

    }

public static void main(String[] args) {

Base base = getBase(47);

base.f();

    }

}

在此例中，不要求变量 i  一定是 final  的。因为 i  被传递给匿名类的基类的构造器，它并不会在匿名类内部被直接使用。下例是带实例初始化的“ parcel ”形式。注意 dest() 的参数必须是 final ，因为它们是在匿名类内被使用的。

public class Parcel9 {

public Destination dest(final String dest, final float price) {

return new Destination() {

private int cost;

// Instance initialization for each object:

            {

cost = Math.round(price);

if(cost > 100)

System.out.println("Over budget!");

            }

 

private String label = dest;

public String readLabel() { return label; }

};

    }

public static void main(String[] args) {

Parcel9 p = new Parcel9();

Destination d = p.dest("Tanzania", 101.395F);

    }

}

在实例初始化的部分，你可以看到有一段代码，那原本是不能作为成员变量初始化的一部分而执行的（就是 if  语句）。所以对于匿名类而言，实例初始化的实际效果就是构造器。当然它受到了限制：你不能重载实例初始化，所以你只能有一个构造器。

 

 

  

 

 

从多层嵌套类中访问外部

一个内部类被嵌套多少层并不重要，它能透明地访问所有它所嵌入的外围类的所有成员，如下所示：

class MNA {

private void f() {}

class A {

private void g() {}

public class B {

void h() {

g();

f();

            }

        }

    }

}

public class MultiNestingAccess {

public static void main(String[] args) {

MNA mna = new MNA();

MNA.A mnaa = mna.new A();

MNA.A.B mnaab = mnaa.new B();

mnaab.h();

    }

}

可以看到在 MNA.A.B 中，调用方法 g() 和 f() 不需要任何条件（即使它们被定义为 private ）。这个例子同时展示了如何从不同的类里面创建多层嵌套的内部类对象的基本语法。“ .new ”语法能产生正确的作用域，所以你不必在调用构造器时限定类名。

 

 

 

 

 

内部类的重载问题

 

如果你创建了一个内部类，然后继承其外围类并重新定义此内部类时，会发生什么呢？也就是说，内部类可以被重载吗？这看起来似乎是个很有用的点子，但是“重载”内部类就好像它是外围类的一个方法，其实并不起什么作用：

 

class  Egg {

        private  Yolk  y ;

 

        protectedclass  Yolk {

               public  Yolk() {

                     System. out .println( "Egg.Yolk()" );

              }

       }

 

        public  Egg() {

              System. out .println( "New Egg()" );

               y  =  new  Yolk();

       }

}

 

publicclass  BigEgg  extends  Egg {

        publicclass  Yolk {

               public  Yolk() {

                     System. out .println( "BigEgg.Yolk()" );

              }

       }

 

        publicstaticvoid  main(String[] args) {

               new  BigEgg();

       }

}

 

 

输出结果为：

New Egg()

Egg.Yolk()

 

缺省的构造器是编译器自动生成的，这里是调用基类的缺省构造器。你可能认为既然创建了 BigEgg 的对象，那么所使用的应该是被“重载”过的 Yolk ，但你可以从输出中看到实际情况并不是这样的。

这个例子说明，当你继承了某个外围类的时候，内部类并没有发生什么特别神奇的变化。这两个内部类是完全独立的两个实体，各自在自己的命名空间内。当然，明确地继承某个内部类也是可以的：

 

class Egg2 {

       protected class Yolk {

              public Yolk() {

                     System.out.println("Egg2.Yolk()");

              }

 

              public void f() {

                     System.out.println("Egg2.Yolk.f()");

              }

       }

 

       private Yolk y = new Yolk();

 

       public Egg2() {

              System.out.println("New Egg2()");

       }

 

       public void insertYolk(Yolk yy) {

              y = yy;

       }

 

       public void g() {

              y.f();

       }

}

 

public class BigEgg2 extends Egg2 {

       public class Yolk extends Egg2.Yolk {

              public Yolk() {

                     System.out.println("BigEgg2.Yolk()");

              }

 

              public void f() {

                     System.out.println("BigEgg2.Yolk.f()");

              }

       }

 

       public BigEgg2() {

              insertYolk(new Yolk());

       }

 

       public static void main(String[] args) {

              Egg2 e2 = new BigEgg2();

              e2.g();

       }

}

 

输出结果为：

Egg2.Yolk()

New Egg2()

Egg2.Yolk()

BigEgg2.Yolk()

BigEgg2.Yolk.f()

 

现在 BigEgg2.Yolk  通过 extends Egg2.Yolk  明确地继承了此内部类，并且重载了其中的方法。 Egg2 的 insertYolk() 方法使得 BigEgg2  将它自己的 Yolk  对象向上转型，然后传递给引用 y 。所以当 g() 调用 y.f() 时，重载后的新版的 f() 被执行。第二次调用 Egg2.Yolk() 是 BigEgg2.Yolk  的构造器调用了其基类的构造器。可以看到在调用 g() 的时候，新版的 f() 被调用了。

 

 

 

 

 

 

 

 

内部类的继承问题（thinking in java 3th p294）

因为内部类的构造器要用到其外围类对象的引用，所以在你继承一个内部类的时候，事情变得有点复杂。问题在于，那个“秘密的”外围类对象的引用必须被初始化，而在被继承的类中并不存在要联接的缺省对象。要解决这个问题，需使用专门的语法来明确说清它们之间的关联：

class  WithInner {

        class  Inner {

                Inner(){

                        System.out.println("this is a constructor in WithInner.Inner");

                };

        }

}

 

public class InheritInner extends  WithInner.Inner {

        // ! InheritInner() {} // Won't compile

        InheritInner(WithInner wi) {

                 wi.super();

                System.out.println("this is a constructor in InheritInner");

        }

 

        public static void main(String[] args) {

                WithInner wi = new WithInner();

                InheritInner ii = new InheritInner(wi);

        }

}

 

输出结果为：

this is a constructor  in WithInner.Inner

this is a constructor  in InheritInner

 

可以看到， InheritInner  只继承自内部类，而不是外围类。但是当要生成一个构造器时，缺省的构造器并不算好，而且你不能只是传递一个指向外围类对象的引用。此外，你必须在构造器内使用如下语法：

enclosingClassReference. super ();

这样才提供了必要的引用，然后程序才能编译通过。