- 浏览: 171647 次
- 性别:
- 来自: 杭州
文章分类
最新评论
-
muyiou:
这篇文章讲的真好!
java内部类 -
刚开始吧:
讲的很好。很经典。貌似还有点小问题。就像19层说的,是不是&l ...
Spring+Hibernate+Struts2整合文档 -
306335604:
相关的分析文档出来;在什么地方,大哥,能不能贴出来
有点piwik的一点东西 -
nextman:
小儿科
Spring+Hibernate+Struts2整合文档 -
liu2511981:
按照Lz 的配置,其中在 配置 声明式事务处理的时候有异常, ...
Spring+Hibernate+Struts2整合文档
内部类学习
所谓内部类(Inner Class),顾名思义,就是指定义在另外一个类中的类,我们为什么要这么做呢?为什么不直接定义它而要在别的类中定义一个内部类呢?这样做主要有如下三个原因:
1. 内部类的方法可以访问它所在的外部类中的所有域,包括私有型别的;
2. 对于同一个包中的其它类它是隐藏的;
3. 匿名的内部类可以让我们很方便的定义事件响应(call back),这在GUI编程中很常见;
一.内部类(inner class)如何访问外部类(outer class)中的域
因为安全机制的原因,内部类通常声明为private类别,因此,只有在内部类所在的外部中才能够创建内部类的对象,对其它类而言它是隐藏的。另外,只有内部类才会用到private修饰符,一般的类如果用private修饰符则会报错。
下面看如下的代码:
注意上面红色加粗部分的代码,如你所见beep这个变量在内部类TimerPrinter中我们并没有声明,那么它引用自何处呢?显然是来自于外部类。一般来说,一个方法可直接refer to调用它的对象中的所有域,而一个内部类的方法则可以直接refer to它所在类以及创建它的外部类中的所有域,如上例所示。
事实上,在每一个内部类中都存在一个默认的隐式的reference,它指向创建了这个内部类的实例的那个对象,我们假设它叫outer,这样上面红色加粗部分就相当于:
if(outer.beep) Toolkit.getDefaultToolkit().beep();。Ok,既然存在这样一个reference,那么outer的值又是如何设置的?实际上编译器会合成一个构造方法来设置它,如下面代码所示:
public TimePrinter(Court court) {
outer = clock;
}
这段代码是编译时自动产生的,就像前面我们讨论的自动拆箱装箱中一样,编译器自
己会添加一些代码。然后当我们在Court类的start()方法中创建TimerPrinter实例的时
候,编译器会自动把this作为参数传递过去,效果如下面代码所示:
参数是编译器自动给加上的,不用我们来管。
二.内部类的一些特殊语法规则
前面我们说在每一个内部类中都存在一个默认的隐式的reference,它指向创建了这个内
部类的实例的那个对象,并且我们以outer来带指它,如果我们想显式的指明该按照如下的
语法,OuterClass.this,例如if(Court.this.beep) Toolkit.getDefaultToolkit().beep();。
此外,因为我们定义的内部类通常是private,所以它通常是通过外部类的方法创建,如
本例中的start()方法,这样那个隐式的reference就指向调用了start()方法的对象,就是this。
如果内部类声明为public,那么我们就可以在任何地方实例化一个内部类,如下面代码:
Court court=new Court(10000,true);
Court.TimerPrinter test=court.new TimerPrinter();
上述代码在InnerClassTest的main方法中,这时候那个隐式的reference就直接指向了
court对象。注意语法是:OuterClassName.InnerClassName
许多人认为内部类的语法十分复杂,尤其是匿名内部类,这与Java所一直奉行的“简单”原则相背离的,有人甚至怀疑java中加入这么一个“特征”(feature),是不是已经开始走向“灭亡”?就像许多其它语言一样走向“灭亡”?内部类是否真的有用,有没有存在的必要?我们首先来看看内部的工作原理。
先指明一点,内部类如何工作是由编译器来负责的,与java虚拟机无关,它对这个是一无所知的。仔细留意一下上篇中编译后产生的class文件,你会发现有一个class文件的名字是Court$TimerPrinter,它的基本格式是:外部类名称$内部类名称。当碰到内部类时,编译器会自动根据内部类的代码生成一个class文件并按照上述规则命名,那么编译器到底对它做了什么呢?我们可以使用Java的反射(reflection)机制来“偷窥”它,嘿嘿。具体的代码如下所示:
如上所示,编译器自动为我们加上了一个域this$0,它指向一个外部类,另外自动给构造方法增加了一个Court型别参数,用来设置this$0的值,注意this$0是编译器自己合成的,不能直接引用。
既然编译器能够自动进行转化,为什么我们不直接自己进行转换,把TimerPrinter改写成普通的class呢?如下所示:
问题来了,我们在实现actionPerformed方法的时候要用到访问outer.beep,但是beep是private类型的,在TimerPrinter中是不能直接访问的。这样内部类的一个优点就显示出来了:内部类能够访问其所属外部类中的私有域而其它普通的类则不行。
那么内部类是通过什么样的机制访问它所属的外部类中的私有数据的呢?联想前面讲私有域的时候,我们都是通过方法来间接访问私有域的,那么这里是不是这样的呢?我们还是对外部类Court进行一下反射,结果如下所示:
我们看到新增了一个方法access$0,它的返回值就是传递过来的Court对象的beep域,这样actionPerformed方法中的if(beep)就相当于if(access$0(outer)),内部类就是通过这种机制来访问外部类的私有数据。
这里我们介绍一种特殊的内部类:局部内部类(Local Inner Classes)。
在前面的例子中,我们可以发现TimerPrinter仅在start方法中创建一个新的对象时出现过一次,其它地方都没再用到过,这个情况下我们可以把TimerPrinter就定义在start方法中,如下面代码所示:
注意,局部内部类不需要任何access modifier,否则编译出错,它的作用域一般都被限制在它所在的block中。此时,编译会产生一个名字叫Court$1TimerPrinter的class文件。局部内部类有如下两个优点:
1. 它对外面的所有类来说都是隐藏的,即时是它所属的外部类,仅有它所在的方法知道它;
2. 它不仅可以访问它所属外部类中的数据,还可以访问局部变量,不过局部变量必须生命为final类型,看下面的例子:
注意,局部内部类所要访问的局部变量必须声明为final类型,如上例中红色粗体部分。那么局部内部类是如何访问这个局部变量的呢?我们再对Court$1TimerPrinter反射一下,会得到如下的输出:
编译器又给我们增加了一个域val$beep,同时构造方法增加了一个boolean类型的参数,因此我们猜想如下的实现过程:
TimerPrinter action=new TimerPrinter(this,beep);//编译器自动增加
然后构造方法中会有:val$beep=beep;这样就成功的把局部变量的值复制过来了。局部变量必须为final就是为了保证成功的复制值,因为final类型的变量一经赋值就不能再发生变化了。
这里再介绍一种特殊的内部类――匿名内部类(Anonymous Inner Class),顾名思义,就是没有名字的内部类,这是Java为了方便我们编写程序而设计的一个机制。因为有时候有的内部类只需要创建一个它的对象就可以了,以后再不会用到这个类,这时候使用匿名内部类就比较合适,而且也免去了给它取名字的烦恼,:)。
匿名类的语法是什么样的呢?如下所示:
new SuperType(){
内部类的方法和域;
}
注意,这里的SuperType指超类,它可以是一个接口(interface)或者是一个类(Class),当它是一个接口的时候就不能有构造参数(Construction parameters)了。匿名类的语法相对于Java的其他部分来说稍微复杂一点,我们可以按如下方式理解:
1.SuperType为接口
例子:Interface1() test=new Interface1(){
要实现的的方法;
Interface1的域;
内部类的域以及方法;
}
我们可以如下理解:
先声明了如下一个类,
class Anonymous1 implements Interface1{
要实现的的方法;
Interface1的域;
内部类的域以及方法;
}
然后,Interface1() test=new Anonymouse1();
这样就比较容易理解了。
2.SuperType为类
例子:Class2 test=new Class2(Construction parameters){
内部类的域以及方法;
}
我们可以如下理解:
先声明了如下一个类,
class Anonymous2 extends Class2{
public Anonymous2(Construction parameters){
super(Construction parameters);
}
内部类的域以及方法;
}
然后,Class2 test=new Anonymouse2(Construction parameters);
本节测试代码如下:
这里介绍最后一种比较特殊的内部类――静态内部类(Static Inner Class),即在内部类的前面增加了static修饰符(modifier)。注意,仅仅只有内部类能够被声明为static类型,通常我们声明一个普通类的时候不能使用static,否则编译出错。
那么为什么我们要使用静态的内部类呢?在什么情况下我们需要使用静态的内部类呢?我们前面讲过,编译器会自动给内部类加上一个reference,指向产生它的那个外部类的对象,如果不想要或者说不需要这个reference,那么我们就可以把这个内部类声明为static,禁止这个reference的产生。除此之外静态类的使用与普通的静态类是一样的。例子如下:
在这个例子中之所以要用静态内部类,主要是因为getMinMax这个方法是静态的,由类直接调用。而前面说过创建内部类的时候语法是这样的:
OuterClassObject.new InnerClassName(),如果省略了OuterClassObject则是
this. new InnerClassName(),OuterClassObject或者this指代创建这个内部类对象的一个外部类对象,是一个隐式参数,它将传入内部类的构造方法(见前所述)。但是现在这个内部类对象是由“类”直接创建的,不会产生这样的一个隐式参数传入内部类构造方法,因此内部类也就不需要“编译器自动给内部类加上一个reference,指向产生它的那个外部类的对象”,所以我们把这个内部类声明为static。上面的代码中如果我们去掉static将会报错,除非我们把getMinMax的static去掉,同时通过FindMinMax的一个实例来调用这个方法,如下:
FindMinMax test=new FindMinMax();
test.getMinMax(d);
我们下面来对内部类所产生的class文件反射(reflection)一下,结果如下:
很清楚的看到,编译器没有给我们自动加上一个reference,指向产生它的那个外部类的对象,也没有给构造方法加上一个FindMinMax型别的参数。
所谓内部类(Inner Class),顾名思义,就是指定义在另外一个类中的类,我们为什么要这么做呢?为什么不直接定义它而要在别的类中定义一个内部类呢?这样做主要有如下三个原因:
1. 内部类的方法可以访问它所在的外部类中的所有域,包括私有型别的;
2. 对于同一个包中的其它类它是隐藏的;
3. 匿名的内部类可以让我们很方便的定义事件响应(call back),这在GUI编程中很常见;
一.内部类(inner class)如何访问外部类(outer class)中的域
因为安全机制的原因,内部类通常声明为private类别,因此,只有在内部类所在的外部中才能够创建内部类的对象,对其它类而言它是隐藏的。另外,只有内部类才会用到private修饰符,一般的类如果用private修饰符则会报错。
下面看如下的代码:
package cn.edu.hust.cm.test; import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.Toolkit; import javax.swing.JOptionPane; import javax.swing.Timer; public class InnerClassTest { public InnerClassTest() { super(); // TODO Auto-generated constructor stub } public static void main(String[] args) { Court court=new Court(10000,true); court.start(); JOptionPane.showMessageDialog(null,"停止么,CMTobby?"); System.exit(0); } } class Court{ public Court(int interval,boolean beep){ this.interval=interval; this.beep=beep; } public void start(){ TimerPrinter action=new TimerPrinter(); Timer t=new Timer(interval,action); t.start(); } private int interval; private boolean beep; private class TimerPrinter implements ActionListener{ public void actionPerformed(ActionEvent e){ System.out.println("Cindyelf,would you be my mm?"); if(beep) Toolkit.getDefaultToolkit().beep(); } } }
注意上面红色加粗部分的代码,如你所见beep这个变量在内部类TimerPrinter中我们并没有声明,那么它引用自何处呢?显然是来自于外部类。一般来说,一个方法可直接refer to调用它的对象中的所有域,而一个内部类的方法则可以直接refer to它所在类以及创建它的外部类中的所有域,如上例所示。
事实上,在每一个内部类中都存在一个默认的隐式的reference,它指向创建了这个内部类的实例的那个对象,我们假设它叫outer,这样上面红色加粗部分就相当于:
if(outer.beep) Toolkit.getDefaultToolkit().beep();。Ok,既然存在这样一个reference,那么outer的值又是如何设置的?实际上编译器会合成一个构造方法来设置它,如下面代码所示:
public TimePrinter(Court court) {
outer = clock;
}
这段代码是编译时自动产生的,就像前面我们讨论的自动拆箱装箱中一样,编译器自
己会添加一些代码。然后当我们在Court类的start()方法中创建TimerPrinter实例的时
候,编译器会自动把this作为参数传递过去,效果如下面代码所示:
public void start(){ TimerPrinter action=new TimerPrinter(this);//编译器自动加上的 Timer t=new Timer (interval,action); t.start (); }
参数是编译器自动给加上的,不用我们来管。
二.内部类的一些特殊语法规则
前面我们说在每一个内部类中都存在一个默认的隐式的reference,它指向创建了这个内
部类的实例的那个对象,并且我们以outer来带指它,如果我们想显式的指明该按照如下的
语法,OuterClass.this,例如if(Court.this.beep) Toolkit.getDefaultToolkit().beep();。
此外,因为我们定义的内部类通常是private,所以它通常是通过外部类的方法创建,如
本例中的start()方法,这样那个隐式的reference就指向调用了start()方法的对象,就是this。
如果内部类声明为public,那么我们就可以在任何地方实例化一个内部类,如下面代码:
Court court=new Court(10000,true);
Court.TimerPrinter test=court.new TimerPrinter();
上述代码在InnerClassTest的main方法中,这时候那个隐式的reference就直接指向了
court对象。注意语法是:OuterClassName.InnerClassName
许多人认为内部类的语法十分复杂,尤其是匿名内部类,这与Java所一直奉行的“简单”原则相背离的,有人甚至怀疑java中加入这么一个“特征”(feature),是不是已经开始走向“灭亡”?就像许多其它语言一样走向“灭亡”?内部类是否真的有用,有没有存在的必要?我们首先来看看内部的工作原理。
先指明一点,内部类如何工作是由编译器来负责的,与java虚拟机无关,它对这个是一无所知的。仔细留意一下上篇中编译后产生的class文件,你会发现有一个class文件的名字是Court$TimerPrinter,它的基本格式是:外部类名称$内部类名称。当碰到内部类时,编译器会自动根据内部类的代码生成一个class文件并按照上述规则命名,那么编译器到底对它做了什么呢?我们可以使用Java的反射(reflection)机制来“偷窥”它,嘿嘿。具体的代码如下所示:
* Created on 2006-09-24 * * TODO To change the template for this generated file go to * Window - Preferences - Java - Code Style - Code Templates */ package cn.edu.hust.cm.access; import java.lang.reflect.*; import javax.swing.*; /** * @author Demon * * TODO To change the template for this generated type comment go to * Window - Preferences - Java - Code Style - Code Templates */ public class ReflectionTest { public static void main(String[] args) { String name=""; if(args.length>0) name=args[0]; else name=JOptionPane.showInputDialog("Class name (e.g. java.util.Date): "); try{ Class c1=Class.forName(name); Class c2=c1.getSuperclass(); System.out.print("class " + name); if(c2!=null&&c2!=Object.class) System.out.print(" extends " + c2.getName()); System.out.print("\n{\n"); printConstructors(c1); System.out.println(); printMethods(c1); System.out.println(); printFields(c1); System.out.println("}"); } catch(ClassNotFoundException e) { e.printStackTrace(); } System.exit(0); } public static void printConstructors(Class c1){ Constructor[] constructors=c1.getDeclaredConstructors(); for(int i=0;i<constructors.length;i++){ Constructor c=constructors[i]; String name =c.getName(); System.out.print(Modifier.toString(c.getModifiers())); System.out.print(" " + name + "("); Class[] paramTypes = c.getParameterTypes(); for(int j=0;j<paramTypes.length;j++){ if (j > 0) System.out.print(", "); System.out.print(paramTypes[j].getName()); } System.out.println(");"); } } public static void printMethods(Class c1){ Method[] methods=c1.getDeclaredMethods(); for(int i=0;i<methods.length;i++){ Method m=methods[i]; String name=m.getName(); Class type=m.getReturnType(); System.out.print(Modifier.toString(m.getModifiers())+" "+type.getName()+" "+name+"("); Class[] paramTypes=m.getParameterTypes(); for(int j=0;j<paramTypes.length;j++){ if(j>0) System.out.print(","); System.out.print(paramTypes[j].getName()); } System.out.println(");"); } } public static void printFields(Class c1){ Field fields[]=c1.getDeclaredFields(); for(int i=0;i<fields.length;i++){ System.out.print(Modifier.toString(fields[i].getModifiers())); System.out.print(" "); Class type=fields[i].getType(); System.out.print(type.getName()); System.out.println(" "+fields[i].getName()+";"); } } } 运行该程序,在对话框中输入cn.edu.hust.cm.test.Court$TimerPrinter,将会得到如下输出: } cn.edu.hust.cm.test.Court$TimerPrinter(cn.edu.hust.cm.test.Court); public void actionPerformed(java.awt.event.ActionEvent); final cn.edu.hust.cm.test.Court this$0; }
如上所示,编译器自动为我们加上了一个域this$0,它指向一个外部类,另外自动给构造方法增加了一个Court型别参数,用来设置this$0的值,注意this$0是编译器自己合成的,不能直接引用。
既然编译器能够自动进行转化,为什么我们不直接自己进行转换,把TimerPrinter改写成普通的class呢?如下所示:
class Court { . . . public void start() { ActionListener listener = new TimePrinter(this); Timer t = new Timer(interval, listener); t.start(); } } class TimePrinter implements ActionListener { public TimePrinter(TalkingClock clock) { outer = clock; } . . . private TalkingClock outer; }
问题来了,我们在实现actionPerformed方法的时候要用到访问outer.beep,但是beep是private类型的,在TimerPrinter中是不能直接访问的。这样内部类的一个优点就显示出来了:内部类能够访问其所属外部类中的私有域而其它普通的类则不行。
那么内部类是通过什么样的机制访问它所属的外部类中的私有数据的呢?联想前面讲私有域的时候,我们都是通过方法来间接访问私有域的,那么这里是不是这样的呢?我们还是对外部类Court进行一下反射,结果如下所示:
class cn.edu.hust.cm.test.Court { public cn.edu.hust.cm.test.Court(int, boolean); static boolean access$0(cn.edu.hust.cm.test.Court); public void start(); private int interval; private boolean beep; }
我们看到新增了一个方法access$0,它的返回值就是传递过来的Court对象的beep域,这样actionPerformed方法中的if(beep)就相当于if(access$0(outer)),内部类就是通过这种机制来访问外部类的私有数据。
这里我们介绍一种特殊的内部类:局部内部类(Local Inner Classes)。
在前面的例子中,我们可以发现TimerPrinter仅在start方法中创建一个新的对象时出现过一次,其它地方都没再用到过,这个情况下我们可以把TimerPrinter就定义在start方法中,如下面代码所示:
public void start(){ class TimerPrinter implements ActionListener{ //private boolean beep; public void actionPerformed(ActionEvent e){ System.out.println("Bigface,would you be my boy?"); if(beep) Toolkit.getDefaultToolkit().beep(); } } TimerPrinter action=new TimerPrinter(); Timer t=new Timer(interval,action); t.start(); }
注意,局部内部类不需要任何access modifier,否则编译出错,它的作用域一般都被限制在它所在的block中。此时,编译会产生一个名字叫Court$1TimerPrinter的class文件。局部内部类有如下两个优点:
1. 它对外面的所有类来说都是隐藏的,即时是它所属的外部类,仅有它所在的方法知道它;
2. 它不仅可以访问它所属外部类中的数据,还可以访问局部变量,不过局部变量必须生命为final类型,看下面的例子:
package cn.edu.hust.cm.test; import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.Toolkit; import javax.swing.JOptionPane; import javax.swing.Timer; public class InnerClassTest { public InnerClassTest() { super(); } public static void main(String[] args) { Court court=new Court(); court.start(5000,true); JOptionPane.showMessageDialog(null,"停止么,CMTobby?"); } } class Court{ public void start(int interval,final boolean beep){ class TimerPrinter implements ActionListener{ public void actionPerformed(ActionEvent e){ System.out.println("Cindyelf,are you crazy?"); if(beep) Toolkit.getDefaultToolkit().beep(); } } TimerPrinter action=new TimerPrinter();//编译器会自动更改 Timer t=new Timer(interval,action); t.start(); } }
注意,局部内部类所要访问的局部变量必须声明为final类型,如上例中红色粗体部分。那么局部内部类是如何访问这个局部变量的呢?我们再对Court$1TimerPrinter反射一下,会得到如下的输出:
class cn.edu.hust.cm.test.Court$1TimerPrinter { cn.edu.hust.cm.test.Court$1TimerPrinter(cn.edu.hust.cm.test.Court, boolean); public void actionPerformed(java.awt.event.ActionEvent); final cn.edu.hust.cm.test.Court this$0; private final boolean val$beep; }
编译器又给我们增加了一个域val$beep,同时构造方法增加了一个boolean类型的参数,因此我们猜想如下的实现过程:
TimerPrinter action=new TimerPrinter(this,beep);//编译器自动增加
然后构造方法中会有:val$beep=beep;这样就成功的把局部变量的值复制过来了。局部变量必须为final就是为了保证成功的复制值,因为final类型的变量一经赋值就不能再发生变化了。
这里再介绍一种特殊的内部类――匿名内部类(Anonymous Inner Class),顾名思义,就是没有名字的内部类,这是Java为了方便我们编写程序而设计的一个机制。因为有时候有的内部类只需要创建一个它的对象就可以了,以后再不会用到这个类,这时候使用匿名内部类就比较合适,而且也免去了给它取名字的烦恼,:)。
匿名类的语法是什么样的呢?如下所示:
new SuperType(){
内部类的方法和域;
}
注意,这里的SuperType指超类,它可以是一个接口(interface)或者是一个类(Class),当它是一个接口的时候就不能有构造参数(Construction parameters)了。匿名类的语法相对于Java的其他部分来说稍微复杂一点,我们可以按如下方式理解:
1.SuperType为接口
例子:Interface1() test=new Interface1(){
要实现的的方法;
Interface1的域;
内部类的域以及方法;
}
我们可以如下理解:
先声明了如下一个类,
class Anonymous1 implements Interface1{
要实现的的方法;
Interface1的域;
内部类的域以及方法;
}
然后,Interface1() test=new Anonymouse1();
这样就比较容易理解了。
2.SuperType为类
例子:Class2 test=new Class2(Construction parameters){
内部类的域以及方法;
}
我们可以如下理解:
先声明了如下一个类,
class Anonymous2 extends Class2{
public Anonymous2(Construction parameters){
super(Construction parameters);
}
内部类的域以及方法;
}
然后,Class2 test=new Anonymouse2(Construction parameters);
本节测试代码如下:
package cn.edu.hust.cm.test; import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.Toolkit; import javax.swing.JOptionPane; import javax.swing.Timer; public class InnerClassTest { public InnerClassTest() { super(); } public static void main(String[] args) { Court court=new Court(10000,true); court.start(); JOptionPane.showMessageDialog(null,"停止么,CMTobby?"); System.exit(0); } } class Court{ public Court(int interval,boolean beep){ this.interval=interval; this.beep=beep; } public void start(){ ActionListener action=new ActionListener(){ public void actionPerformed(ActionEvent e){ System.out.println("Cindyelf,wouly you be my girl?"); } }; Timer t=new Timer(interval,action); t.start(); } private int interval; private boolean beep; }
这里介绍最后一种比较特殊的内部类――静态内部类(Static Inner Class),即在内部类的前面增加了static修饰符(modifier)。注意,仅仅只有内部类能够被声明为static类型,通常我们声明一个普通类的时候不能使用static,否则编译出错。
那么为什么我们要使用静态的内部类呢?在什么情况下我们需要使用静态的内部类呢?我们前面讲过,编译器会自动给内部类加上一个reference,指向产生它的那个外部类的对象,如果不想要或者说不需要这个reference,那么我们就可以把这个内部类声明为static,禁止这个reference的产生。除此之外静态类的使用与普通的静态类是一样的。例子如下:
package cn.edu.hust.cm.test; public class StaticInnerClassTest { public StaticInnerClassTest() { super(); // TODO Auto-generated constructor stub } public static void main(String[] args) { // TODO Auto-generated method stub double d[]=new double[20]; for(int i=0;i<d.length;i++) d[i]=100*Math.random(); //FindMinMax test=new FindMinMax(); FindMinMax.Pair pair=FindMinMax.getMinMax(d); System.out.println("最小值是:"+pair.getFirst()); System.out.println("最大值是:"+pair.getSecond()); } } class FindMinMax{ static double min=Double.MAX_VALUE; static double max=Double.MIN_VALUE; public static Pair getMinMax(double d[]){ for(double value:d){ if(min>value) min=value; if(max<value) max=value; } return new Pair(min,max); } public static class Pair{ public Pair(double first,double second){ this.first=first; this.second=second; } public double getFirst(){ return this.first; } public double getSecond(){ return this.second; } private double first; private double second; } }
在这个例子中之所以要用静态内部类,主要是因为getMinMax这个方法是静态的,由类直接调用。而前面说过创建内部类的时候语法是这样的:
OuterClassObject.new InnerClassName(),如果省略了OuterClassObject则是
this. new InnerClassName(),OuterClassObject或者this指代创建这个内部类对象的一个外部类对象,是一个隐式参数,它将传入内部类的构造方法(见前所述)。但是现在这个内部类对象是由“类”直接创建的,不会产生这样的一个隐式参数传入内部类构造方法,因此内部类也就不需要“编译器自动给内部类加上一个reference,指向产生它的那个外部类的对象”,所以我们把这个内部类声明为static。上面的代码中如果我们去掉static将会报错,除非我们把getMinMax的static去掉,同时通过FindMinMax的一个实例来调用这个方法,如下:
FindMinMax test=new FindMinMax();
test.getMinMax(d);
我们下面来对内部类所产生的class文件反射(reflection)一下,结果如下:
class cn.edu.hust.cm.test.FindMinMax$Pair { public cn.edu.hust.cm.test.FindMinMax$Pair(double, double); public double getSecond(); public double getFirst(); private double first; private double second; }
很清楚的看到,编译器没有给我们自动加上一个reference,指向产生它的那个外部类的对象,也没有给构造方法加上一个FindMinMax型别的参数。
发表评论
-
如何處理Java應用在CPU高時的問題排查與解決
2014-10-11 16:30 616如何處理Java應用在CPU高時的問題排查與解決在Tomc ... -
JSP连接数据库方法大全
2008-04-04 09:52 802JSP连接数据库方法大全 http://www.we ... -
jsp基础速成精华讲解
2008-04-04 20:57 563Servlet三个要素:1.必须继 ... -
IT职业规划之从开发人员到行业专家
2008-04-05 18:26 717本文刊登于程序员杂志08年第三期,发表题为:以业务为中心的行业 ... -
DAO模式学习笔记
2008-04-06 17:12 925DAO是Data Access Object数据 ... -
Vector使用
2008-04-06 17:32 894Vector 是个处理结果集的 ... -
jsp数据库操作的具体代码
2008-04-08 15:50 826数据库连接语言老是出问题,好好做了一下,然后把东西记录下来.以 ... -
MVC学习
2008-04-08 19:39 925一、MVC设计思想 MVC英文即Model-View-Co ... -
jsp-SmartUpload上传下载全攻略
2008-04-12 11:51 957jsp-SmartUpload上传下载全攻略(详)一、安装篇j ... -
JAVA工具类集锦1--分页类
2008-05-07 08:23 7261、分页类: public class Page { /** ... -
JAVA工具类集锦2--时间格式转化类
2008-05-07 08:27 8242、时间格式转化类: public class DateUt ... -
JAVA工具类集锦3--编码过滤器
2008-05-07 08:30 9443、编码过滤器 import javax.servlet.* ... -
JAVA工具类集锦4--登录过滤器
2008-05-07 08:33 9914、登录过滤器 import javax.servlet.F ... -
JAVA工具类集锦5--字符编码规范类
2008-05-07 08:46 7705、字符编码规范类 public class StringU ... -
JAVA工具类集锦6--中文乱码处理类
2008-05-07 16:38 10286、中文乱码处理类 package com.mingri.c ... -
写BBS的体会
2008-05-09 08:27 851BBS快写完了,感觉里面也没有什么东西,写起来还是很简单的了. ... -
jsp中文乱码处理总结
2008-05-13 12:00 818jsp开发中的中文乱码的处理是一个很简单,又很麻烦的问题,但 ... -
jsp四种属性范围
2008-05-15 19:38 709四种属性范围:(按使用范围从小到大排列)pageContext ... -
MD5加密
2008-05-21 15:50 672MD5加密代码: ********************* ... -
日历控件的代码及使用方法
2008-05-25 16:01 812calendar.js ...
相关推荐
Java内部类是Java言语的一个很重要的概念,《Java编程思想》花了很大的篇幅来讲述这个概念。但是我们在实践中很少用到它,虽然我们在很多时候会被动的使用到它,但它仍然像一个幕后英雄一样,不为我们所知,不为我们...
java内部类详解
Java内部类总结 学习java的资源
从Java1.1开始引入了内部类以来,它就引起了人们的激烈争论。其实任何优秀的语言特性用得不好就是滥用,内部类用得不好就会导致代码像迷宫一样,导致出现毫无重用的综合征。...本文档讲述Java内部类的规则及应用
12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类...
这里是自己对java内部类整理的一篇文章,有可执行的源代码
java内部类使用例子,可以运行
谈Java内部类的四个应用场景
java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用
Java 的使用 分别介绍了 成员内部类、方法内部类、静态内部类
Java内部类Java内部类Java内部类Java内部类Java内部类Java内部类Java内部类
java 内部类 实例内部类 局部内部类 匿名类 静态内部类 实例代码
详细介绍JAVA内部类的用法,用途,基本语法,及匿名类用法
Java内部类的作用
JAVA内部类的一些总结
对内部类不错的讲解,以及如何应用并且还帮你归了类,不错的选择
Java 干货之深入理解Java内部类;Java 干货之深入理解Java内部类;Java 干货之深入理解Java内部类;Java 干货之深入理解Java内部类;Java 干货之深入理解Java内部类;
java基础java内部类