Java内部类

[来源] 达内    [编辑] 达内   [时间]2012-11-01

创建内部类的时候只需要将内部类放到外部类的打括号内部就可以,如果需要实例化这个内部类,只要不是在外部类的非静态方法中,必须使用外部类名称加上内部类名称来表示这个类

创建内部类

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   创建内部类的时候只需要将内部类放到外部类的打括号内部就可以,如果需要实例化这个内部类,只要不是在外部类的非静态方法中,必须使用外部类名称加上内部类名称来表示这个类:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
//
: innerclasses/Parcel2.java //


 Returning a reference to an inner class.

public class
 Parcel2 {   class
 Contents {     private
 int i = 11;     
public int
 value() { return
 i; }   }   

class Destination {     


private
 String label;     Destination(String whereTo) {       label = whereTo;     }     String readLabel() { 
return label; }   }   
public
 Destination to(String s) {     

return new
 Destination(s);   }   
public

 Contents contents() {     
return

 new Contents();   }   
public void
 ship(String dest) {     Contents c 
= contents();     Destination d 

= to(dest);     System.out.println(d.readLabel());   }   
public

 static void
 main(String[] args) {     Parcel2 p 
= new

 Parcel2();     p.ship(
"Tasmania"

);     Parcel2 q = new
 Parcel2();     //
 Defining references to inner classes:

    Parcel2.Contents c = q.contents();     Parcel2.Destination d 
= q.to("Borneo");   } } 
/*

 Output: Tasmania *///
:~
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">与外部类的连接

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   看起来内部类只是一种命名隐藏和代码组织的方式,并不是强制性的语法 但是,这里有另外一点需要注意。当你创建一个内部类的时候,这个内部类的对象具有对与创建这个内部类的对象的连接,它可以获取到创建它的类的对象中的成员,而不用其他特殊的标识。另外,内部类具有对外部类所有成员的访问权限,如下面的代码:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
//
: innerclasses/Sequence.java 
//

 Holds a sequence of Objects.

interface Selector {   
boolean
 end();   Object current();   void
 next(); } 

public class
 Sequence {   private
 Object[] items;   private
 int next = 0;   
public Sequence(int
 size) { items = new
 Object[size]; }   

public void
 add(Object x) {     if
(next < items.length)       items[next
++] = x;   }   

private class
 SequenceSelector implements
 Selector {     

private int
 i = 0;     public
 boolean end() { return
 i == items.length; }     
public

 Object current() { return
 items[i]; }     

public void
 next() { if(i < items.length) i++
; }   }   

public
 Selector selector() {     

return new
 SequenceSelector();   }   
public

 static void
 main(String[] args) {     Sequence sequence 
= new

 Sequence(10);     for
(int i = 0; i < 10; i++
)       sequence.add(Integer.toString(i));     Selector selector = sequence.selector();     
while(!
selector.end()) {       System.out.print(selector.current() 

+ " ");       selector.next();     }   } } 
/*
 Output: 0 1 2 3 4 5 6 7 8 9 

*///:~
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   从上面的代码中我们可以看到内部类具有对外部类的所有成员的访问权限。内部类创建的时候必须与对应的外部类相关联,使得内部类能够抓取创建它的外部类的实例。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">使用this和new

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">  用外部类的名字跟上.this表示外部类对象的引用,如下:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
//
: innerclasses/DotThis.java //


 Qualifying access to the outer-class object.

public class
 DotThis {   void
 f() { System.out.println("DotThis.f()"); }   


public class
 Inner {     

public
 DotThis outer() {       return
 DotThis.this

;       //
 A plain "this" would be Inner’s "this"

    }   }   
public Inner inner() { return 
new

 Inner(); }   public
 static void
 main(String[] args) {     DotThis dt 
= new

 DotThis();     DotThis.Inner dti 
=

 dt.inner();     dti.outer().f();   } } /*
 Output: DotThis.f() *///
:~
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   当你已经获得了某个外部类的实例的引用,当你需要创建这个外部类实例的一个内部类实例的时候,可以使用.new关键字,如下:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Parcel3.java //


 Using .new to create instances of inner classes.

public class
 Parcel3 {   class
 Contents {     private
 int i = 11;     
public int
 value() { return
 i; }   }   

class Destination {     


private
 String label;     Destination(String whereTo) { label 

= whereTo; }     String readLabel() { 


return label; }   }   
public static void
 main(String[] args) {     Parcel3 p 
= 

new Parcel3();     
//

 Must use instance of outer class     
//
 to create an instance of the inner class:


    Parcel3.Contents c = p.new
 Contents();     Parcel3.Destination d = p.new
 Destination("Tasmania");   } } 
//

/:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">内部类和上塑造型

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">    在上塑造型到基类或者接口的时候,内部可可以完全隐藏他们自己,这种情况下只能获得接口或者基类的引用,而无法获得具体的对象类型。因为继承了基类或者接口的内部类,可以设置为外界不可见或不可用,这对于实现的隐藏非常有用。所有你获得的仅仅是一个对基类或者接口的引用:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/TestParcel.java

class Parcel4 {   
private class
 PContents implements
 Contents {     

private int
 i = 11;     public
 int value() { return
 i; }   }   protected
 class PDestination implements


 Destination {     
private

 String label;     
private

 PDestination(String whereTo) {       label 
=

 whereTo;     }     public
 String readLabel() { return
 label; }   }   

public
 Destination destination(String s) {     

return new
 PDestination(s);   }   
public

 Contents contents() {     
return

 new PContents();   } } 
public class


 TestParcel {   public 
static void
 main(String[] args) {     Parcel4 p = new


 Parcel4();     Contents c = p.contents();     Destination d 
= p.destination("Tasmania");     
//

 Illegal -- can’t access private class:     
//

! Parcel4.PContents pc = p.new PContents();

  } } //
/:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); "> 方法和作用域中的内部类

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   内部类还可以定义在方法中,甚至是一个作用域中,这样做的原因有两点:首先,像前面所看到的,你需要继承某个接口,从而可以创建和返回某个引用;其次,当你需要解决某些复杂问题的时候,你在类中创建某些辅助对象,而这些对象并不许要对外可见。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">  下面这个例子在方法中创建了一个内部类,我们也称之为本地内部类:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Parcel5.java //


 Nesting a class within a method.

public class
 Parcel5 {   public
 Destination destination(String s) {     
class

 PDestination implements
 Destination {

      private
 String label;       private


 PDestination(String whereTo) {         label = whereTo;       }       
public String readLabel() { 
return

 label; }     }     
return

 new
 PDestination(s);   }   

public static
 void
 main(String[] args) {     Parcel5 p 

= new
 Parcel5();     Destination d 

= p.destination("Tasmania");   } } 
//

/:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">  下面的例子显示了在任意作用域内创建的内部类:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Parcel6.java //


 Nesting a class within a scope.

public class
 Parcel6 {   private
 void internalTracking(boolean


 b) {     if
(b) {       class
 TrackingSlip {         
private

 String id;         TrackingSlip(String s) {           id 
= s;         }         String getSlip() { 
return

 id; }       }       TrackingSlip ts 
= new

 TrackingSlip("slip");       String s 
= ts.getSlip();     }     
//

 Can’t use it here! Out of scope:     
//

! TrackingSlip ts = new TrackingSlip("x");

  }   public
 void track() { internalTracking(
true

); }   public
 static void
 main(String[] args) {     Parcel6 p 
= new

 Parcel6();     p.track();   } } 
//

/:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">匿名内部类

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">  如下是匿名内部类的一种写法:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Parcel7.java //


 Returning an instance of an anonymous inner class.

public class
 Parcel7 {   public
 Contents contents() {     
return

 new Contents() { //
 Insert a class definition

      private int
 i = 11;       
public

 int value() { return
 i; }     }; //
 Semicolon required in this case

  }   public
 static void
 main(String[] args) {     Parcel7 p 
= new

 Parcel7();     Contents c =
 p.contents();   } } //
/:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">其含义表示如下:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Parcel7b.java 
//

 Expanded version of Parcel7.java

public class
 Parcel7b {   class
 MyContents implements
 Contents {     

private int
 i = 11;     public
 int value() { return
 i; }   }   public
 Contents contents() { return 
new

 MyContents(); }   public
 static void
 main(String[] args) {     Parcel7b p 
= new

 Parcel7b();     Contents c =
 p.contents();   } } 

///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">  当需要向匿名内部类传递初始化参数的时候可以使用如下的写法:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Parcel8.java //


 Calling the base-class constructor.
 
public class
 Parcel8 {   public
 Wrapping wrapping(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) {     Parcel8 p 
= new

 Parcel8();     Wrapping w 
= p.wrapping(10

);   } } ///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   如果需要在匿名内部类中使用匿名内部类外部定义的对象,那么编译器需要在参数前面加上final关键字,如下:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Parcel9.java //


 An anonymous inner class that performs 
//

 initialization. A briefer version of Parcel5.java.

public class
 Parcel9 { //
 Argument must be final to use inside 
//

 anonymous inner class:

  public Destination destination(


final String dest) {     
return new


 Destination() {       private
 String label = dest;       
public

 String readLabel() { return
 label; }     };   }   

public static
 void
 main(String[] args) {     Parcel9 p 

= new
 Parcel9();     Destination d 

= p.destination("Tasmania");   } } 
//

/:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   以内匿名内部类没有名称,那么如何执行匿名内部类的初始化函数呢?可以通过instance initialization实例初始化来执行初始化的工作,如下:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/AnonymousConstructor.java 
//

 Creating a constructor for an anonymous inner class.

import static
 net.mindview.util.Print.*; 
abstract

 class Base {   
public Base(int
 i) {     print(
"Base constructor, i = " +

 i);   }   public 
abstract

 void f(); } 
public class
 AnonymousConstructor {   
public

 static Base getBase(int
 i) {     return
 new
 Base(i) {       { print(

"Inside instance initializer"); }       
public

 void
 f() {         print(

"In anonymous f()");       }     };   }   
public static
 void
 main(String[] args) {     Base base 

= getBase(47);     base.f();   } } 
/*

 Output: Base constructor, i = 47 Inside instance initializer In anonymous f() 
*///

:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); "> 这里的i不用添加final关键字,因为它只是用来传递给基类的初始化函数,而在匿名内部类中并没有对他进行任何使用。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">  下面是parcel例子的一个匿名内部类版本:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Parcel10.java 
//

 Using "instance initialization" to perform 
//

 construction on an anonymous inner class.

public class
 Parcel10 {   public
 Destination destination(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) {     Parcel10 p 
= new Parcel10();


      Destination d = p.destination("Tasmania", 101.395F);   } } 
/* Output: Over budget! 
*///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); "> 从上面代码我们看到,可以将不能放在域中初始化的代码放到实例初始器中, 完成构造器的功能,但是实例构造器也有限制,它不能被重载,因此对于内部匿名类只能有一个构造其。另外一点还需要记住的是匿名内部类只能继承自来或者接口,不能同时继承类和接口,如果是继承接口的话,也只能继承自一个接口。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">  下面我们就用匿名内部类来修改工厂方法:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Factories.java

import static
 net.mindview.util.Print.*; 
interface

 Service {   void
 method1();   void
 method2(); } interface
 ServiceFactory {   Service getService(); } 
class

 Implementation1 implements
 Service {   

private
 Implementation1() {}   

public void
 method1() {print("Implementation1 method1");}   


public void
 method2() {print("Implementation1 method2");}   
public

 static ServiceFactory factory = 
new

 ServiceFactory() {                                         


public Service getService() {                                           
return new

 Implementation1();                                         }                                       }; } 
class

 Implementation2 implements
 Service {   

private Implementation2() {}
   public
 void
 method1() {print("Implementation2 method1");}   

public void
 method2() {print("Implementation2 method2");}   
public

 static ServiceFactory factory = 
new

 ServiceFactory() {                                         
public
 Service getService() {                                           return
 new
 Implementation2();                                         }                                       }; } 
public

 class Factories {   
public static
 void
 serviceConsumer(ServiceFactory fact) {     Service s 

= fact.getService();     s.method1();     s.method2();   }   
public static
 void

 main(String[] args) {     serviceConsumer(Implementation1.factory);     
//
 Implementations are completely interchangeable:


    serviceConsumer(Implementation2.factory);   } } 
/*
 Output: Implementation1 method1 Implementation1 method2 Implementation2 method1 Implementation2 method2 

*///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">嵌套类

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   如果不许要内部类与包含它的类有联系的话,可以使用嵌套类,也就是用st atic修饰的内部类。一般的内部类总是包含一个包含它的外部类的引用,但是静态的内部类你需要记住两点:你不许要外部类来创建内部类的实例;在嵌套类内不你不能使用非静态的外部类对象。同时,一般内部类的域和方法只能通过外部ulei访问,因此一般内部类中不能有静态数据,静态域或嵌套类。但是在静态内部类中这些都可以存在:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Parcel11.java 
//

 Nested classes (static inner classes).
public

 class Parcel11 {   
private static
 class ParcelContents 
implements

 Contents {     private
 int i = 11;     
public int
 value() { return
 i; }   }   

protected static
 class ParcelDestination 
implements
 Destination {     

private
 String label;     

private
 ParcelDestination(String whereTo) {       label 

= whereTo;     }     
public

 String readLabel() { return
 label; }     

//
 Nested classes can contain other static elements:

    public static
 void f() {}     
static int
 x = 10;     static
 class
 AnotherLevel {       

public static
 void f() {}       
static int
 x = 10;     }   }   
public

 static
 Destination destination(String s) {     

return new
 ParcelDestination(s);   }   
public

 static
 Contents contents() {     

return new
 ParcelContents();   }   
public

 static void
 main(String[] args) {     Contents c 
= contents();     Destination d 

= destination("Tasmania");   } } 


///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   另外,在一般内部类中可以使用this关键字来表示对外部类的引用,但是在静态内部类中没有类似与上面的this引用外部类的用法。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   一般来讲,接口中是不能有实现功能的代码的,但是在接口中可以有内部类,任何在接口中定义的类都是自动为public和static的。因为接口中的类是静态的,因此它并没有违反接口的规则,仅仅是在同一个命名空间下防止了一个嵌套类,这个静态的内部类还可以对周围的接口进行实现:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/ClassInInterface.java 
//

 {main: ClassInInterface$Test}

public interface
 ClassInInterface {   void
 howdy();   class
 Test implements
 ClassInInterface {     

public void
 howdy() {       System.out.println(
"Howdy!"

);     }     public
 static void


 main(String[] args) {       new


 Test().howdy();     }   } } /*
 Output: Howdy! *///


:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   当你需要为接口的多种实现版本定义一些共同的实现代码的时候,使用接口内部类非常方便。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   不管嵌套类嵌套了多少个层次,在嵌套类中总是可以获取到这个嵌套层次中任何一个类的成员,如下:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/MultiNestingAccess.java 
//

 Nested classes can access all members of all 
//

 levels of the classes they are nested within.

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();   } } //


/:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); "> 我们可以看到在MNAAB中调用方法g和f的时候不许要特殊的修饰,同时也示范了如何在多嵌套层次的类中如何创建不同层次上的对象,.new可以帮助获取正确的范围。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">为何使用内部类

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   为何Java的开发者要费劲心思创建出内部类的语法呢?通常内部类都是继承 一个基类或者接口的,通常在内部类中对创建它的外部类对象进行操作。因此你可以说内部类提供了一个针对外部类的窗口。但是如果仅仅是为了获得对接口的引用,那么为什么不直接让外部类继承自这个接口呢?那么内部类 承和外部类继承有什么不同呢?答案是我们并不是总是要继承自接口,有时候我们需要继承自基类。因此使用内部类的最主要原因是:每个内部类都可以继承自一个基类,因此,使用内部类继承基类的时候不会受到外部类是否已经继承了某个基类的限制,本质上也就是可以实现多基类继承。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   当有两个接口需要某个类继承的时候,可以选择继承一个接口,然后在内 类继承另外一个接口,另外一种方法就是直接继承自这两个接口,选择哪个都可以实现你需要的功能;但是如果这两个不是接口,而是抽象类或者类呢?那么那么我们就必须选择第一种方法,继承自一个类,然后在内部类中继承自另外一个类,如下:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/MultiImplementation.java 
//

 With concrete or abstract classes, inner 
//

 classes are the only way to produce the effect 
//
 of "multiple implementation inheritance."


package innerclasses; 
class D {}
abstract class
 E {} class
 Z extends
 D {   E makeE() { 

return new
 E() {}; } } public
 class
 MultiImplementation {   

static void
 takesD(D d) {}   static
 void takesE(E e) {}   
public static
 void

 main(String[] args) {     Z z 
= 

new Z();     takesD(z);     takesE(z.makeE());   } } 
///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   如果不许要解决多重:继承的问题,那么可以完全不许要内部类,但是使 了内部类的话你还可以获得其他的特点,如下:在外部类对象中可以创建多个内部类对象的实例,每个实例都有自己的信息,相互独立;在一个外部类中你可以定义多个内部类,每个继承自相同或不同的类;内部类的创建不依赖与外部类对象。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">    闭包指的是保存了创建它的作用域信息的对象。从这个定义来看,内部类 是一种闭包,内部类保存了对外部创建类的引用,并且可以引用所有的成员,即使是private修饰的成员。另外,Java中有一种类似与指针机制的参数使用称之为回调。通过回调可以在一些类中反向调用创建这个对象中的一些信息。但是Java中对指针的使用非常谨慎,因此在语言中并没有包含指针的概念。闭包可以有效地解决这个问题,如下面的代码:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/Callbacks.java 
//

 Using inner classes for callbacks

package innerclasses; 
import static
 net.mindview.util.Print.*; 
interface

 Incrementable {   void
 increment(); } //
 Very simple to just implement the interface:

class Callee1 implements
 Incrementable {   private
 int i = 0;   
public void
 increment() {     i++
;     print(i);   } } 

class MyIncrement {   
public void
 increment() { print("Other operation"); }   
static

 void
 f(MyIncrement mi) { mi.increment(); } } //


 If your class must implement increment() in //


 some other way, you must use an inner class:

class Callee2 extends
 MyIncrement {   private
 int i = 0;   
public void
 increment() {     super


.increment();     i++
;     print(i);   }   

private class
 Closure implements
 Incrementable {     

public void
 increment() {       
//

 Specify outer-class method, otherwise       
//

 you’d get an infinite recursion:

      Callee2.this
.increment();     }   }   Incrementable getCallbackReference() {     return
 new Closure();   } } 
class Caller {   
private
 Incrementable callbackReference;   Caller(Incrementable cbh) { callbackReference 

= cbh; }   void
 go() { callbackReference.increment(); } } 
public

 class Callbacks {
   public
 static void
 main(String[] args) {     Callee1 c1 
= new

 Callee1();     Callee2 c2 = 
new

 Callee2();     MyIncrement.f(c2);     Caller caller1 
= new

 Caller(c1);     Caller caller2 
= new

 Caller(c2.getCallbackReference());     caller1.go();     caller1.go();     caller2.go();     caller2.go();   } } 
/*
 Output: Other operation 1 1 2 Other operation 2 Other operation 3 *///
:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">    内部类的另外一种用法就是控制框架,应用框架是指一个或者一系列类,能够处理一系列一般性的问题。在使用框架的时候通常继承或者扩展框架里面类从而解决特定的问题。控制框架主要是针对事件响应的系统,主要的应用场景有用户界面。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">  首先我们创建一个事件基类:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/controller/Event.java 
//

 The common methods for any control event.

package
 innerclasses.controller; public
 abstract

 class Event {   
private long
 eventTime;   protected
 final long
 delayTime;   public
 Event(long
 delayTime) {     

this.delayTime =
 delayTime;     start();   }   

public void
 start() { //
 Allows restarting


    eventTime = System.nanoTime() + delayTime;   }   
public boolean
 ready() {     return
 System.nanoTime() >= eventTime;   }   
public

 abstract void
 action(); } //
/:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); "> 下面是控制框架的主体部分,分离了不变和变化的部分,不便的部分已经封装到控制器内,变化的部分可以分散到不同的Event基类的派生类当中:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/controller/Controller.java 
//

 The reusable framework for control systems.

package
 innerclasses.controller; import
 java.util.*; 

public class
 Controller {   //
 A class from java.util to hold Event objects:

  private
 List<Event> eventList = new
 ArrayList<Event>();   

public void


 addEvent(Event c) { eventList.add(c); }   public
 void run() {     
while(eventList.size() > 0
)     

//
 Make a copy so you’re not modifying the list     

//
 while you’re selecting the elements in it:


    for(Event e : new
 ArrayList<Event>(eventList))       
if
(e.ready()) {         System.out.println(e);         e.action();         eventList.remove(e);       }   } } 
//

/:
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); "> 这个时候就可以使用内部类了,使用内部类可以一方面将控制框架集中到一个类中,内部类可以用来扩展不同的action方法;另外一方面使用内部类可以方便的获得外部类的成员,从而更加容易理解,如下:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/GreenhouseControls.java 
//

 This produces a specific application of the 
//

 control system, all in a single class. Inner 
//
 classes allow you to encapsulate different 

//
 functionality for each type of event.


import innerclasses.controller.*
; public class
 GreenhouseControls extends
 Controller {   

private boolean
 light = false;   
public class
 LightOn extends
 Event {     

public LightOn(long
 delayTime) { super
(delayTime); }     

public void
 action() {       //


 Put hardware control code here to       
//

 physically turn on the light.

      light = true
;     }     public
 String toString() { return
 "Light is on"; }   }   

public class
 LightOff extends
 Event {     

public LightOff(long
 delayTime) { super
(delayTime); }     

public void
 action() {       //


 Put hardware control code here to       
//

 physically turn off the light.

      light = false
;     }     public
 String toString() { return
 "Light is off"; }   }   

private boolean
 water = false;   
public class
 WaterOn 

extends Event {     
public WaterOn(long
 delayTime) { 

super(delayTime); }     


public void
 action() {       //


 Put hardware control code here.

      water = true
;     }     public


 String toString() {       return
 "Greenhouse water is on";     }   }   
public

 class WaterOff extends
 Event {     public
 WaterOff(long delayTime) { 
super

(delayTime); }     
public

 void
 action() {       

//
 Put hardware control code here.


      water = false
;     }     public


 String toString() {       return
 "Greenhouse water is off";     }   }   
private

 String thermostat = "Day";   
public

 class ThermostatNight extends


 Event {     public
 ThermostatNight(long
 delayTime) {       

super
(delayTime);     }     

public void
 action() {       //


 Put hardware control code here.

      thermostat = "Night";     }     
public
 String toString() {       

return
 "Thermostat on night setting";     }   }   

public class
 ThermostatDay extends
 Event {     

public ThermostatDay(long
 delayTime) {       
super
(delayTime);     }     

public void
 action() {       //


 Put hardware control code here.

      thermostat = "Day";     }     
public
 String toString() {       

return
 "Thermostat on day setting";     }   }   

//
 An example of an action() that inserts a   

//
 new one of itself into the event list:


  public class
 Bell extends
 Event {     

public Bell(long
 delayTime) { super
(delayTime); }     

public void
 action() {       addEvent(
new

 Bell(delayTime));     }     
public

 String toString() { return
 "Bing!"; }   }   
public

 class Restart extends


 Event {     private
 Event[] eventList;     public
 Restart(long
 delayTime, Event[] eventList) {       

super
(delayTime);       

this.eventList =
 eventList;       

for
(Event e : eventList)       addEvent(e);     }     

public void
 action() {       
for

(Event e : eventList) {         e.start(); 
//

 Rerun each event

        addEvent(e);       }       start(); 
// Rerun this Event

      addEvent(this
);     }     public


 String toString() {       return
 "Restarting system";     }   }   
public

 static class
 Terminate extends
 Event {     

public Terminate(long
 delayTime) { super
(delayTime); }     

public void
 action() { System.exit(0); }     
public

 String toString() { return
 "Terminating"; }   } } 

///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">下面是对控制框架的使用:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/GreenhouseController.java 
//

 Configure and execute the greenhouse system. 
//

 {Args: 5000}

import innerclasses.controller.*
; public class
 GreenhouseController {   
public

 static void
 main(String[] args) {     GreenhouseControls gc 
= new

 GreenhouseControls();     
// Instead of hard-wiring, you could parse     
//
 configuration information from a text file here:


    gc.addEvent(gc.new Bell(900


));     Event[] eventList = {       gc.
new ThermostatNight(0
),       gc.

new LightOn(200
),       gc.

new LightOff(400
),       gc.

new WaterOn(600
),       gc.

new WaterOff(800
),       gc.

new ThermostatDay(1400
)     };     gc.addEvent(gc.

new Restart(2000
, eventList));     

if(args.length == 1
)       gc.addEvent(new


 GreenhouseControls.Terminate(new
 Integer(args[0

])));     gc.run();   } } /*


 Output: Bing! Thermostat on night setting Light is on Light is off Greenhouse water is on Greenhouse water is off Thermostat on day setting Restarting system Terminating 
*///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">内部类继承

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   因为内部类的构造器必须引用包含它的外部类对象,因此在继承内部类的时候有一点点复杂。因此对与外部类的实例必须在派生类中初始化,因为在派生类中没有默认的外部类的实例,因此必须显示初始化:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/InheritInner.java 
//

 Inheriting an inner class.

class WithInner {   
class Inner {} } 
public class
 InheritInner extends
 WithInner.Inner {   

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

  InheritInner(WithInner wi) {     wi.
super();   }   
public static
 void

 main(String[] args) {     WithInner wi 
= new
 WithInner();     InheritInner ii 

= new
 InheritInner(wi);   } } 

///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">内部类是否能够重写

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">  如果要扩展外部类,继承之后重写内部类,会怎么样呢?

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/BigEgg.java //
 An inner class cannot be overriden like a method.

import static
 net.mindview.util.Print.*; 
class

 Egg {   private
 Yolk y;   
protected class
 Yolk {     public
 Yolk() { print("Egg.Yolk()"); }   }   
public

 Egg() {     print(
"New Egg()");     y 

= new
 Yolk();   }
}
public class BigEgg extends Egg {   public class Yolk {     public Yolk() { print("BigEgg.Yolk()"); }   }    public static void main(String[] args) {      new BigEgg();   } } /* Output: New Egg() Egg.Yolk() */// :~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); "> 我们可以看到继承外部类并且重写内部类实际上并没有做任何事情。下面的例子告诉我们继承外部类并且重写内部类的时候,两个内部类是分开的尸体,各有自己的命名空间,但是可以显式的继承内部类:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/BigEgg2.java //


 Proper inheritance of an inner class.

import static
 net.mindview.util.Print.*; 
class

 Egg2 {   protected
 class Yolk {     
public
 Yolk() { print("Egg2.Yolk()"); }     

public void
 f() { print("Egg2.Yolk.f()");}   }   


private Yolk y = new
 Yolk();   public
 Egg2() { print("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() { print("BigEgg2.Yolk()"

); }     public 
void

 f() { print("BigEgg2.Yolk.f()"); }   }   
public BigEgg2() { insertYolk(
new

 Yolk()); }   public
 static void


 main(String[] args) {     Egg2 e2 = new
 BigEgg2();     e2.g();   } } 
/*

 Output: Egg2.Yolk() New Egg2() Egg2.Yolk() BigEgg2.Yolk() BigEgg2.Yolk.f() 
*///

:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">本地内部类

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   之前提到过内部类可以定义在语句块中,通常是在方法体中。一个本类内部类不能拥有可见性标识,因为它不是外部类的一部分,但是它能够获取到当前语句块中的final变量和外部类的所有成员:

< div style="margin: 5px 0px; padding: 5px; background-color: rgb(245, 245, 245); font-family: 'Courier New'; font-size: 12px; border: 1px solid rgb(204, 204, 204); overflow: auto; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; " class="cnblogs_code">
复制代码
//
: innerclasses/LocalInnerClass.java 
//

 Holds a sequence of Objects.

import static
 net.mindview.util.Print.*; 
interface

 Counter {   int
 next(); } public
 class LocalInnerClass {   
private int
 count = 0;   Counter getCounter(
final

 String name) {     //
 A local inner class:

    class LocalCounter 
implements Counter {       
public
 LocalCounter() {         

//
 Local inner class can have a constructor


        print("LocalCounter()");       }       
public int
 next() {         printnb(name); 
//

 Access local final

        return count++
;       }     }     return
 new
 LocalCounter();   }   

//
 The same thing with an anonymous inner class:


  Counter getCounter2(final
 String name) {     return
 

new Counter() {       


// Anonymous inner class cannot have a named       
//
 constructor, only an instance initializer:


      {         print(
"Counter()");       }       
public

 int
 next() {         printnb(name); 

// Access local final

        return count++
;       }     };   }   public
 static void
 main(String[] args) {     LocalInnerClass lic 
= new

 LocalInnerClass();     Counter c1 
= lic.getCounter("Local inner "),          c2 

= lic.getCounter2("Anonymous inner ");     
for(int
 i = 0; i < 5; i++)       print(c1.next());     
for

(int i = 0; i < 5; i++)
       print(c2.next());   } } 
/*


 Output: LocalCounter() Counter() Local inner 0 Local inner 1 Local inner 2 Local inner 3 Local inner 4 Anonymous inner 5 Anonymous inner 6 Anonymous inner 7 Anonymous inner 8 Anonymous inner 9 

*///:~
复制代码
< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); "> 因为本地内部类不能在方法外部使用,因此使用本地内部类而不使用匿名内部类的原因是你是否需要构造其或者重载的构造其,因为匿名内部类只能使用实例化初始。

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">内部类标识

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">   每个类编译之后都会产生一个.class 文件,里面包含了对象的相关信息,那么内部类呢,是否也是一个单独的clas文件呢?是的,但是文件的名称有着严格的格式,是外部类名称加上$再加上内部类的名称,例如上面的LocalInnerClass.java文件编译后产生如下class文件:

< p style="margin: 10px auto; padding: 0px; text-indent: 0px; line-height: 19px; color: rgb(0, 0, 0); font-size: 13px; font-family: verdana, 'ms song', 宋体, Arial, 微软雅黑, Helvetica, sans-serif; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: left; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px; background-color: rgb(254, 254, 242); ">Counter.class
LocalInnerClass$l.class
LocallnnerClassSlLocalCounter.class
LocallnnerClass.class
如果内部类是匿名的,那么编译器仅仅是用数字表示匿名内部类的名称,如果有嵌套的内部类,那么将直接在后面继续添加$和内部类的名称即可。

资源下载