关键词：J2ME MIDP 移植 平台无关 本地代码

1 MIDP2.0简介

随着现代信息化社会的发展，小型移动通信设备已经从最初的一种单纯的通信工具转变成如今集通信、工作、娱乐等功能为一体的综合设备；但仅有这些还不能满足用户的要求。个性永远是千变万化的，时尚也不会始终为一种模式。因此，在移动终端上开发通用的、丰富的应用已成为必然的趋势。这些应用可以按用户的意愿随时安装和删除。

J2ME（JAVA2 Micro Edition）正是这样一种JAVA应用开发平台。实际上，JAVA语言从其诞生起就以其运行的平台无关性这一强大的优势而成为网络应用的宠儿。J2ME是JAVA2标准版本的微型版本，专门为小型移动设备所设计。这些设备处理器的处理能力都不强，可使用的资源也有限。因此，J2ME只包含了J2SE中在移动通信设备上所必需的功能和组件，使其能够在移动设备及其有限的资源上开发出丰富多彩且平台无关的应用。J2ME在结构上分为CDC（Connecte Device Configuration）和基于其上，以Foundation Profile为主的规范，以及CLDC（Connecte Limited Device Configuration）和基于其上，以MIDP为主的规范。

MIDP（Mobile Information Device Profile）是移信息设备规范的简称。规范具体定义了J2ME适用的硬件和软件框架，并提供了这个框架要实现的基本功能及其标准接口；而应用开发者就可以基于这个框架开发出各种应用。2000年9月，SUN公司发布了MIDP的第一个正式版本MIDP1.0。它将J2ME适用的设备定位在至少拥有数百KB RAM和ROM，并具有基本网络和显示功能的移动通信设备上；在该基础上定义了一系列软件接的移动通信设备上；在该上基础上定义了一系列软件接口，其中包括基本输入输出、图形化用户接口（GUI）、网络、事件机制、文件系统、应用管理系统（AMS）等之后，随着JAVA技术的不断发展和用户需求的不断提高，SUN公司又于2002年11月发布了MIDP2.0。它对设备的内存资源和处理能力的要求较1.0要高，但MIDP2.0也为应用开发者提供了更方便、更丰富多彩的软件包，主要增加了游戏接口的实现、声音输出接口的实现安全网络机制的实现。MIDP2.0的这些特性将使基于移动设备的JAVA应用具有更加广阔的前景，也必将使新一代的移动设备发生革命性的变化并领导时尚潮流。MIDP2.0接口包如表1所列。

表1 MIDP2.0接口包及其功能

2 MIDP2.0的移植

既然MIDP2.0是定位在移动通信设备之上的一系列JAVA应用开发接口，我们就必须考虑如何将整个MIDP系统嵌入到特定的硬件设备和其上的操作系统中。只有这样，JAVA应用程序才能运行在该设备上，并利用MIDP提供的强大功能将用户带入一个全新的JAVA世界。在一个完全不同的操作系统平台上，用该平台上对应的系统API调用（或一系列操作），替换MIDP参考实现中所有与操作平台相关的调用（或操作），使MIDP能在目标平台上正确地执行所有要求的功能；同时，调用该平台上特有的能充分发挥目标设备硬件特性的接口，替换参考实现中相应的接口，使MIDP能在目标平台上更高效地运行，这个过程就称为MIDP的移植。

MIDP由许多不同的部分组成，每一部分完成MIDP一个特定的功能接口。其中需要移植的部分主要包括事件处理、文件系统、用户图形化接口、网络、AMS、多媒体。它们都分为高端的JAVA层和低端的本地方法层。JAVA层是用JAVA语言实现的，由KVM解释执行；因此没有涉及到与操作系统平台相关的调用和操作，可以不经修改就在任何操作平台上运行，是平台无关的（PlateForm Independent）。它的移植主要是为满足用户的特殊要求而进行的个性化工作。本地方法层（NativeCode）是指为提高代码的执行效率，保持JAVA语言的平台无关性而使用C语言实现的部分MIDP功能的代码。本地即是指它是与当前的操作平台相关的，它的移植才是涉及到具体平台和执行效率而进行的具体调用和操作的替换过程，其结构如图1所示。

下面，我们就具体到MIDP的每一个部分的移植进行讨论。

2.1 事件处理

MIDP的事件处理部分要处理的事件主要来自两个方面：①来自虚拟机底层的事件，如虚拟机的异常消息；②来自MIDP内部的事件，如屏幕刷新、按键消息、触控笔点击消息、时钟消息等。由于不同的平台可能使用不同的事件消息获取和传递机制，因此MIDP事件处理的移植也集中在这上面，其实现被放在本地方法层的文件nativeGUI.c中的函数GetAndStoreKVMEvent中。我们只需根据目标平台获取和传递事件的要求修改该文件中的相应函数即可。

例如，Windows采用消息响应机制来处理各种事件，所有消息都可以通过系统API调用GetMessage获取，系统会调用消息处理函数WndProc(HWND hwnd、UINTiMsg、WPARAM wParam、LRARAM 1Param)，在其中处理和传递不同的事件。其大致实现过程如下：

void

GetAndStoreNextKVMEvent(bool_t forever,ulong64 waitUntil){

MSG msg；

……

while(GetMessage(&msg,NULL,0,0)){

……

TranslateMessage(&msg);

DispatchMessage(&msg);

if(gotEvent){

StoreMIDPEvent(&kvmEvent);

Return;

}

}

return;

}

static LRESULT CALLBACK

WndProc (HWND hwnd,UINT iMsg,WPARAM wParam,LPARAM lParam){

……

switch(iMsg){

case WM_CREATE:

……

case WM_KEYDOWN:

case WM_KEYUP:

……

}

}

MIDP在GetAndStoreNextKVMEvent中获取事件后，就完全独立地传递和处理事件消息，与平台无关，因此无需移植。

    2.2 文件系统

基于MIDP的JAVA应用以及MIDP本身在某些时候要求数据能够长期保存，即使在应用退出或系统掉电的情况下，数据也不能丢失。这就必须借助于MIDP的文件系统。MIDP的文件系统同样分为JAVA层（称为RMS，即Record Manage System）和本地方法层。一般情况下，文件系统的JAVA层不用移植就可以在任何平台上运行，但如果目标平台的文件系统较为特殊，例如采用数据库的记录方式保存数据，甚至根本就没有提供高效的数据存取接口，我们就必须自己实现数据存取接口。这样，JAVA层就需要跳过RMS而直接通过本地方法调用本地接口，相应的RMS的JAVA代码就可以从MIDP中删去。

而在文件系统的本地方法层，MIDP会调用目标平台的数据存取接口来实现MIDP本身的数据存取。这些接口是平台相关的，是文件系统中需要移植的部分。这些调用被放在文件src/share/native/storage.c中，主要包括文件的打开（open）、文件的关闭（close）、文件的读写（read、write）、文件属性的获取（size、freesize等）、文件的删除（delete）、文件的定位（seek）、文件的删节（truncate）等。以下便是MIDP文件系统在Windows下的部分实现。

文件的打开：

int storageOpen(char**ppszError,char*pszAsciiFilename,int ioMode){

……

handle=open(pszAsciiFilename,flags,creationMode)；

……

}

文件的关闭：

void storageClose(char**ppszError,int handle){

……

status=close(handle)；

……

}

文件的读取：

int storageRead(char**ppszError,int handle,char*buffer,int length)

{

……

bytesRead=read(handle,buffer,length);

……

}

文件的写入：

void storageWrite(char**ppszError,int handle,char*buffer,int length){

……

bytesWritten=write(handle,buffer,length);

……

}

还有许多其它有关文件的操作，移植时只需使用目标平台的API替换以上的Widnows调用，这里就不再逐一列举。

2.3 用户图形化接口

用户图形化接口包括画点、画线、作圆、作椭圆、位图拷贝等基本作图函数（可在GRAPHICS.C中找到）；有关定时器、屏幕刷新和键盘触控笔消息等有关与用户交互的操作（可在TEXT.C中找到），它是整个MIDP移植中工作量最大，也是对上层应用的执行效率影响最大的一个部分。这是因为用户在应用中看到的各种图形和文字都是调用底层的图形函数在屏幕上作图的结果。由于屏幕要频繁刷新，图形函数也就成为应用调用最多的接口。因此，移植者必须使每一个底层作图函数与硬件设备紧密配合起来，并使用最高效的算法。

在不同的平台上，能最大地发挥其作图功能的函数和算法不尽相，这就要求移植者作大量细致的工作，按照MIDP规范的要求逐一重新实现每一个作图函数和屏幕刷新函 数。下面我们就以将画线函数和位图拷贝函数在Windows上的实现为例，简单说明移植要做的工作（键盘、触控笔是以事件消息的方式实现的，它们的移植与事件消息的移植相同）。

Windows的画线函数接口：

Void LCDUIdrawLine(int pixel,short*clip,void*dst,int dotted,int x1,int y1,int x2,int y2){

……

Polyline(hdc,pts,2);/*绘x1,y1点像素信号*/

……

}

Windwos的屏幕刷新函数：

Void refreshPaintWindow(int x1,int y1,int x2,int y2){

RECT r；

If(x1<x2){

r.left=x1+x_offset;r.right=x2+x_offset;

}else{

r.left=x2+x_offset;r.right=x1+x_offset;

}

if(y1<y2){

r.top=y1+y_offset;r.bottom=y2+y_offset;

}else{

r.top=y2+y_offset;r.bottom=y1+y_offset；

}

++r.bottom;++r.right;

InvalidateRect(hMainWindow,&r,KNI_TRUE);

}

如果目标平台对这些GUI接口函数有不同实现法，可以用这些方法替换以上的Windows系统调用，这样才能使MIDP图形化用户接口正确地工作，并充分发挥目标平台的工作效率。

2.4 网络

MIDP的网络功能是指基于MIDP的J2ME应用可以通过HTTP等网络协议进行下载安装，不同的MIDlet实体也可以通过它交换信息，实现资源共享。遵循HTTP协议的规定，移植者必须利用目标平台的底层网络接口重新实现网络的初始化（networkInit）、建立连接（open0）、断开连接（close0）、接收数据（read0）、获取缓冲区的剩余空间（available0）、关闭发送（shutdownOutput）。如果目标设备具有服务器功能，还要实现serversocket所有上述功能。所有上述接口都在文件socketProtocol_md.c中实现。

Windwos中获取IP地址的实现：

Int prim_com_sun_midp_io_j2me_socket_Protocol_getIpNumber

(char*host)

{

……

hp=gethostbyname(host);

……

}

如果目标平台还需要其它网络协议（datagram、comm），其移植过程与Socket的移植基本相同。

2.5 应用管理系统（AMS）

MIDP的应用管理系统(application management system)负责管理当前设备中安装的J2ME应用，其功能包括MIDlet的加载、安装、显示、更新和删除。AMS从main.c中的函数main()开始执行，根据其输入初始化一些系统参数，包括系统路径（classJ2ME MIDP 移植 平台无关 本地代码）、堆空间大小（heapsize）、命令行（command line）等，然后就启动KVM，而KVM就会从AMS的JAVA界面main.java开始解释执行java代码。AMS的所有管理功能都是用JAVA语言实现的，因此AMS的实现是与平台无关的。但不同的平台可能有不同的系统参数和格式，对AMS的界面网络也可能有不同的要求。所以，移植者有可能要修改main.c中解析系统参数的部分，保证AMS能正确解析目标平台的所有参数；同时修改AMS的JAVA层，使其界面网络满足用户的需求。

2.6 多媒体

MIDP2.0较MIDP1.0最大的改变就是在MIDP2.0中向应用提供了音频接口（Audio API）的支持。音频接口是移动设备媒体接口MMAPI（Mobile Media API）的一部分。音频的播放过程为5个部分（unrealized、realized、prefetched、started、closed），同时它有自己的音频播放事件的传道和处理过程。MIDP音频播放部分所要做的移植工作就主要集中在声音播放接口，事件的处理方式和兼容不同的音频文件格式上。

播放接口的移植：不同的目标平台，提供的音频系统API是不同的，有的系统甚至根本没有提供播放音频的API。这时，移植者就要根据目标平台的实现情况替换或自己实现音频的播放接口。

Windows的音频播放接口（win32/native/MMATONE.C）：

Java_javax_microedition_media_Manager_nPlayTone(KNITRAPS)

{

……

chn1=getMidiChnl();

if(chnl==-1){

KNI_ReturnInt(0)；

}

tones[chn].msg=((note&0xff)<<8)|0x00000090|(chnl&0xf);

msg=((vol&0xff)<<16)|((note&0xff)<<8)|0x90|(chnl &0xf);

midiOutShortMsg(midiOut,msg);

timerID=timeSetEvent(dur,TIMERES,(LPTIME CALLBACK)timeToneProc,(DWORD)chnl,TIME_ONESHOT);

tones[chnl].timerID=timerID;

……

}

事件传递的移植：MIDP中音频播放结束的事件（EOM）是专门通过系统的消息机制传递，而不是通过MIDP的事件传递，因此也需要移植：

Windows---OM的传递（win32/native/MMAEVT.C）:void injectNativeEvent(int pID,int curMTime){

PostMessage(hMain Window,WM_APP,(WPARAM)(pID),(LPARAM)(curMTime));

return;

}

3 总结

综上所述，MID2.0的移植要以两个方面为出发点：①兼容性。移植后的MIDP实现必须能够在目标平台上正常运行，所有与目标平台不兼容的调用都必须替换为能完成相同功能且兼容的目标平台的系统调用或过程。②高效性。移植后的MIDP实现必须能充分发挥目标平台的效率和特性，用最小的代价完成MIDP的功能。另外，MIDP的移植还要分满足最终用户的个性化要求，为它们设计出丰富多彩的界面网络。

Java性能的优化

class Input{
     //Read a Sring from kedboard
        public static String getString()
        {
            String string="";
            BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
            try
            {
                string=br.readLine();
            }
            catch(IOException iox)
            {
                System.err.println(iox);
            }
        return string;
        }
       
        // read a char from keyboard
        public static char getChar()throws java.io.IOException
        {
                char cookie;

                while(true){
                        String string=getString();//Reads the next line of text from the input stream

                        //Check the input
                        if (string.length()>1)
                        {
                            System.err.println("Sorry,You should input a character,");
                            System.err.println("Please input again");
                            continue;
                        }
                        else {
                                cookie=string.charAt(0) ;
                                return cookie;
                        }
                }
        }
       
       
        //read a double number from keyboard
        public static double getDouble( ) 
        {
            double cookie;

            while(true)
            {
                    String string = getString();
                    try
                    {
                        cookie=Double.parseDouble(string);
                        return cookie;
                    }
                    //Check the number
                    catch(NumberFormatException nfe)
                    {
                        System.err.println("Sorry,this is not a double number,plz input again");
                        continue;
                    }
            }
           
        }
       
        //Read a int number from keyboard
        public static int getInt( ) 
        {
            int cookie;
            while(true)
            {
                String string = getString();
                try
                {
                    cookie=Integer.parseInt(string);
                    return cookie;
                }
                //Check the input number
                catch(NumberFormatException nfe)
                {
                    System.err.println("Sorry,this is not a integer number,plz input again");
                    continue;
                }
            }
        }
       
        //Read a float number from keyboard
        public static float getFloat()
        {
            float cookie;
            while(true)
            {
                String string = getString();
                try
                {
                    cookie=Float.parseFloat(string);
                    return cookie;
                }
                //Check the input number
                catch(NumberFormatException nfe)
                {
                    System.err.println("Sorry,this is not a float number,plz input again");
                    continue;
                }
            }
           
        }

}

package com.faintbear;
import com.faintbear.Input;
public class Class1
{
 public static void main(String[] args)
 {
  System.out.println("请输入数据");
  System.out.println("******************");
  int kk=Input.getInt();
  System.out.println("l1====="+kk);
 }
}

   package com.faintbear;

public class test
{
int i = 0;

public test()
{
 
 
          i=i ++;
 
   System.out.println(i);
}

public static void main(String argsp[]) {
new test();
}
}

结果是0,为什么呢 ?

	回复人： blackhost(剑心) ( ) 信誉：98	2005-3-27 16:42:06	得分: 0
	java的编译器搞的鬼!在遇到++和--操作符的时候会重新为原变量分配一块内存空间，以存放原始的值，而在完成了赋值运算之后，就将这块内存释放掉。由于i的原始值存放在后开辟的内存中，这样i=i++后，由于是先赋值,i就会得到i的原始值(存放在新内存中的数椐)，而原来内存位置的i自加后只保留在原来的位置,由于此时i指向已经是新开辟出来的内存地址，所以i的值没有发送变化! 换句话说, while(true){    i=i++; } 永远执行i的值恒等于i的初始值,即使不是0也一样!下面我把过程写一下 i=0;//假设此时内存地址为0x12345678 i=i++;//系统新开内存地址0x99999999,存放i原始值0,然后0x12345678的存放数据+1操作       //此时0x12345678=1,0x99999999=0,但是上一步是先给值,所以i的内存地址是0x99999999=0; 所以i=0, 但是,如果是 i=0; i++; 此时i=1,因为0x99999999处新开辟的内存地址没有给任何引用,所以被丢弃了!i继续使用0x12345678处值 你在栈上没有计算，正确的过程是 你把i的值0放到栈上 然后把i变成1，但是栈上还是0 最后把栈上的0弹出来赋值给i,结果把刚才iinc的结果给冲掉了,i又变成了0

实际上还有第三个参数，true/false，如果为true则返回值还包含分隔符本身。可以加以省略。

StringTokenizer的构造函数:
StringTokenizer(String str)
StringTokenizer(String str,String delimiters)
StringTokenizer(String str,String delimiters,boolean delimiAsToken)


关于Token的另一些方法，如public  String  nextToken(),  public  bolean  hasMoreTokens(),  public  int  countTokens()等，请参考有关java书籍手册。

一个例子:
     实现把一个特殊结构的字符串转变成字符串数组

public class CCStrTools
{
  public static String[] str2Array(String str, String separator)
    {
        if (str == null || separator == null || (str.trim()).length() == 0)
            return null;

        if (str.substring(str.length() - separator.length(),
                          str.length()).equals(separator))
            str = str.substring(0, str.length() - separator.length());
            //if(str.charAt(str.length()-1)==',')
            //str=str.substring(0,str.length()-1);

        StringTokenizer token = new StringTokenizer(str, separator);
        String[] array = new String[token.countTokens()];

        int i = 0;

        while (token.hasMoreTokens())
        {
            array[i] = token.nextToken(separator);
            i++;
        }

        return array;
    }


    public static void main(String []args)
  {
          
     String s3 ="3@4@5@6@7@";
     
     String w1[] =CCStrTools.str2Array(s3,"@");
     for(int i=0;i<w1.length;i++)
     {
       System.out.println(w1[i]);
     }
    // System.out.println(w1.length);
    
       
     
  }


}

本篇旨在帮助准备学习Java以及刚接触Java的朋友认识、掌握和使用static、this、super、final这几个关键字的使用。Java博大精深，我也是一位正在学习和使用Java的爱好者，文中难免有不妥之处，欢迎指正。

一、static

　　请先看下面这段程序：

  public class Hello{
    public static void main(String[] args){ //(1)
      System.out.println("Hello,world!");   //(2)
    }
  }

　　看过这段程序，对于大多数学过Java 的从来说，都不陌生。即使没有学过Java，而学过其它的高级语言，例如C，那你也应该能看懂这段代码的意思。它只是简单的输出“Hello,world”，一点别的用处都没有，然而，它却展示了static关键字的主要用法。

　　在1处，我们定义了一个静态的方法名为main，这就意味着告诉Java编译器，我这个方法不需要创建一个此类的对象即可使用。你还得你是怎么运行这个程序吗？一般，我们都是在命令行下，打入如下的命令(加下划线为手动输入)：

javac Hello.java
java Hello
Hello,world!

　　这就是你运行的过程，第一行用来编译Hello.java这个文件，执行完后，如果你查看当前，会发现多了一个Hello.class文件，那就是第一行产生的Java二进制字节码。第二行就是执行一个Java程序的最普遍做法。执行结果如你所料。在2中，你可能会想，为什么要这样才能输出。好，我们来分解一下这条语句。（如果没有安装Java文档，请到Sun的官方网站浏览J2SE API）首先，System是位于java.lang包中的一个核心类，如果你查看它的定义，你会发现有这样一行：public static final PrintStream out;接着在进一步，点击PrintStream这个超链接，在METHOD页面，你会看到大量定义的方法，查找println，会有这样一行：

public void println(String x)。

　　好了，现在你应该明白为什么我们要那样调用了，out是System的一个静态变量，所以可以直接使用，而out所属的类有一个println方法。

静态方法

　　通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。如下所示：

class Simple{
   static void go(){
     System.out.println("Go...");
   }
}
public class Cal{
  public static void main(String[] args){
    Simple.go();
  }
}

　　调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。

静态变量

　　静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了。看下面这段代码：

class Value{
  static int c=0;
  static void inc(){
    c++;
  }
}
class Count{
  public static void prt(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    Value v1,v2;
    v1=new Value();
    v2=new Value();
    prt("v1.c="+v1.c+"  v2.c="+v2.c);
    v1.inc();
    prt("v1.c="+v1.c+"  v2.c="+v2.c); 
  }
}

　　结果如下：

v1.c=0  v2.c=0
v1.c=1  v2.c=1

由此可以证明它们共享一块存储区。static变量有点类似于C中的全局变量的概念。值得探讨的是静态变量的初始化问题。我们修改上面的程序：

class Value{
  static int c=0;
  Value(){
    c=15;
  }
  Value(int i){
    c=i;
  }
  static void inc(){
    c++;
  }
}
class Count{
  public static void prt(String s){
    System.out.println(s);
  }
    Value v=new Value(10);
    static Value v1,v2;
    static{
      prt("v1.c="+v1.c+"  v2.c="+v2.c);
      v1=new Value(27);
      prt("v1.c="+v1.c+"  v2.c="+v2.c);
      v2=new Value(15);
      prt("v1.c="+v1.c+"  v2.c="+v2.c);
    }

  public static void main(String[] args){
    Count ct=new Count();
    prt("ct.c="+ct.v.c);
    prt("v1.c="+v1.c+"  v2.c="+v2.c);
    v1.inc();
    prt("v1.c="+v1.c+"  v2.c="+v2.c);
    prt("ct.c="+ct.v.c);
  }
}

运行结果如下：

v1.c=0  v2.c=0
v1.c=27  v2.c=27
v1.c=15  v2.c=15
ct.c=10
v1.c=10  v2.c=10
v1.c=11  v2.c=11
ct.c=11

　　这个程序展示了静态初始化的各种特性。如果你初次接触Java，结果可能令你吃惊。可能会对static后加大括号感到困惑。首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对static关键字的认识。在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。非静态变量不是本文的主题，在此不做详细讨论，请参考Think in Java中的讲解。

静态类

　　通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。如下代码所示：

public class StaticCls{
  public static void main(String[] args){
    OuterCls.InnerCls oi=new OuterCls.InnerCls();
  }
}
class OuterCls{
  public static class InnerCls{
    InnerCls(){
      System.out.println("InnerCls");
    }
   }
}

　　输出结果会如你所料：

InnerCls

　　和普通类一样。内部类的其它用法请参阅Think in Java中的相关章节，此处不作详解。

二、this & super

　　在上一篇拙作中，我们讨论了static的种种用法，通过用static来定义方法或成员，为我们编程提供了某种便利，从某种程度上可以说它类似于C语言中的全局函数和全局变量。但是，并不是说有了这种便利，你便可以随处使用，如果那样的话，你便需要认真考虑一下自己是否在用面向对象的思想编程，自己的程序是否是面向对象的。好了，现在开始讨论this&super这两个关键字的意义和用法。

　　在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，这些马上就要讨论。如果你想引用父类的某种东西，则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某种关系，所以我们在这一块儿来讨论，希望能帮助你区分和掌握它们两个。

在一般方法中

　　最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法：

public class DemoThis{
  private String name;
  private int age;
  DemoThis(String name,int age){
    setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的
    setAge(age);
    this.print();
  }  
  public void setName(String name){
    this.name=name;//此处必须指明你要引用成员变量
  }
  public void setAge(int age){
    this.age=age;
  }
  public void print(){
    System.out.println("Name="+name+" Age="+age);//在此行中并不需要用this，因为没有会导致混淆的东西
  }
  public static void main(String[] args){
    DemoThis dt=new DemoThis("Kevin","22");
  }
}

　　这段代码很简单，不用解释你也应该能看明白。在构造函数中你看到用this.print(),你完全可以用print()来代替它，两者效果一样。下面我们修改这个程序，来演示super的用法。

class Person{
  public int c;
  private String name;
  private int age;
  protected void setName(String name){
    this.name=name;
  }
  protected void setAge(int age){
    this.age=age;
  }
  protected void print(){
    System.out.println("Name="+name+" Age="+age);
  }
}
public class DemoSuper extends Person{
  public void print(){
    System.out.println("DemoSuper:");
    super.print();
  }
  public static void main(String[] args){
    DemoSuper ds=new DemoSuper();
    ds.setName("kevin");
    ds.setAge(22);
    ds.print();
  }
}

　　在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。输出结果说明了这一点：

DemoSuper:
Name=kevin Age=22

　　这样的使用方法是比较常用的。另外如果父类的成员可以被子类访问，那你可以像使用this一样使用它，用“super.父类中的成员名”的方式，但常常你并不是这样来访问父类中的成员名的。

在构造函数中

　　构造函数是一种特殊的方法，在对象初始化的时候自动调用。在构造函数中，this和super也有上面说的种种使用方式，并且它还有特殊的地方，请看下面的例子：

class Person{
  public static void prt(String s){
    System.out.println(s);
  }
  Person(){
    prt("A Person.");
  }
  Person(String name){
    prt("A person name is:"+name);
  }
}
public class Chinese extends Person{
  Chinese(){
    super();  //调用父类构造函数（1）
    prt("A chinese.");//(4)
  }
  Chinese(String name){
    super(name);//调用父类具有相同形参的构造函数（2）
    prt("his name is:"+name);
  }
  Chinese(String name,int age){
    this(name);//调用当前具有相同形参的构造函数（3）
    prt("his age is:"+age);
  }
  public static void main(String[] args){
    Chinese cn=new Chinese();
    cn=new Chinese("kevin");
    cn=new Chinese("kevin",22);
  }
}

　　在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。

　　最后，写了这么多，如果你能对“this通常指代当前对象，super通常指代父类”这句话牢记在心，那么本篇便达到了目的，其它的你自会在以后的编程实践当中慢慢体会、掌握。另外关于本篇中提到的继承，请参阅相关Java教程。

三、final

　　final在Java中并不常用，然而它却为我们提供了诸如在C语言中定义常量的功能，不仅如此，final还可以让你控制你的成员、方法或者是一个类是否可被覆写或继承等功能，这些特点使final在Java中拥有了一个不可或缺的地位，也是学习Java时必须要知道和掌握的关键字之一。

final成员

　　当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。下面这段代码演示了这一点：

import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class Bat{
    final PI=3.14;          //在定义时便给址值
    final int i;            //因为要在构造函数中进行初始化，所以此处便不可再给值
    final List list;        //此变量也与上面的一样
    Bat(){
        i=100;
        list=new LinkedList();
    }
    Bat(int ii,List l){
        i=ii;
        list=l;
    }
    public static void main(String[] args){
        Bat b=new Bat();
        b.list.add(new Bat());
        //b.i=25;
        //b.list=new ArrayList();
        System.out.println("I="+b.i+" List Type:"+b.list.getClass());
        b=new Bat(23,new ArrayList());
        b.list.add(new Bat());
        System.out.println("I="+b.i+" List Type:"+b.list.getClass());
    }
}

　　此程序很简单的演示了final的常规用法。在这里使用在构造函数中进行初始化的方法，这使你有了一点灵活性。如Bat的两个重载构造函数所示，第一个缺省构造函数会为你提供默认的值，重载的那个构造函数会根据你所提供的值或类型为final变量初始化。然而有时你并不需要这种灵活性，你只需要在定义时便给定其值并永不变化，这时就不要再用这种方法。在main方法中有两行语句注释掉了，如果你去掉注释，程序便无法通过编译，这便是说，不论是i的值或是list的类型，一旦初始化，确实无法再更改。然而b可以通过重新初始化来指定i的值或list的类型，输出结果中显示了这一点：

I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList

　　还有一种用法是定义方法中的参数为final，对于基本类型的变量，这样做并没有什么实际意义，因为基本类型的变量在调用方法时是传值的，也就是说你可以在方法中更改这个参数变量而不会影响到调用语句，然而对于对象变量，却显得很实用，因为对象变量在传递时是传递其引用，这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量，当你在方法中不需要改变作为参数的对象变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法。
另外方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用，如下代码所示：

public class INClass{
   void innerClass(final String str){
        class IClass{
            IClass(){
                System.out.println(str);
            }
        }
        IClass ic=new IClass();
    }
  public static void main(String[] args){
      INClass inc=new INClass();
      inc.innerClass("Hello");
  }
}

final方法

　　将方法声明为final，那就说明你已经知道这个方法提供的功能已经满足你要求，不需要进行扩展，并且也不允许任何从此类继承的类来覆写这个方法，但是继承仍然可以继承这个方法，也就是说可以直接使用。另外有一种被称为inline的机制，它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进行例行的方法调用，例如保存断点，压栈等，这样可能会使你的程序效率有所提高，然而当你的方法主体非常庞大时，或你在多处调用此方法，那么你的调用主体代码便会迅速膨胀，可能反而会影响效率，所以你要慎用final进行方法定义。

final类

　　当你将final用于类身上时，你就需要仔细考虑，因为一个final类是无法被任何人继承的，那也就意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了final型的。你也可以明确的给final类中的方法加上一个final，但这显然没有意义。

　　下面的程序演示了final方法和final类的用法：

final class final{
    final String str="final Data";
    public String str1="non final data";
    final public void print(){
        System.out.println("final method.");
    }
    public void what(){
        System.out.println(str+"\n"+str1);
    }
}
public class FinalDemo {   //extends final 无法继承
    public static void main(String[] args){
        final f=new final();
        f.what();
        f.print();
    }
}

　　从程序中可以看出，final类与普通类的使用几乎没有差别，只是它失去了被继承的特性。final方法与非final方法的区别也很难从程序行看出，只是记住慎用。

final在设计模式中的应用

　　在设计模式中有一种模式叫做不变模式，在Java中通过final关键字可以很容易的实现这个模式，在讲解final成员时用到的程序Bat.java就是一个不变模式的例子。如果你对此感兴趣，可以参考阎宏博士编写的《Java与模式》一书中的讲解。

　　到此为止，this,static,supert和final的使用已经说完了，如果你对这四个关键字已经能够大致说出它们的区别与用法，那便说明你基本已经掌握。然而，世界上的任何东西都不是完美无缺的，Java提供这四个关键字，给程序员的编程带来了很大的便利，但并不是说要让你到处使用，一旦达到滥用的程序，便适得其反，所以在使用时请一定要认真考虑。

 基本异常
 
  异常条件是一种能阻止正在运行的方法或其某一部分继续运行下去的问题。
  把异常条件同普通问题区分开来，这点很重要，遇到普通问题的时候，你在
  当前的运行环境下有足够的信息来处理这个困难，对于异常条件，由于你得不到
  足够得用以处理这个问题得信息，因此不能在当前得运行环境下继续运行下去，
  你只能跳出当前得运行环境，并且把问题交到上层得运行环境，这就是抛出异常的
  时候所发生的事情。

  当你抛出异常对象的时候，首先会象创建其他java对象那样，创建一个异常对象，
  在堆里，用new ,然后停下当前的执行路径，再将异常对象的reference从当前的运行
  环境中弹出去，现在异常处理机制开始接管程序了，

 创建自己的异常
            
       

package com.faintbear;

class SimpleException  extends Exception {}

public class SimpleExceptionDemo 
{
    public void f() throws SimpleException 
    {
        System.out.println(" Throwing SimpleException from f()");
        throw new SimpleException ();
        
    }
    
    public static void main(String[]args)
    {
         SimpleExceptionDemo sed = new SimpleExceptionDemo();
         try{
             sed.f();
             
         }catch (SimpleException e){
            System.err.println("caught it");
            e.printStackTrace();
         }
    }
    
    

}

  异常说明

  异常说明属于方法声明的一部分，要列在参数表的后面。
  异常说明要用throws关键词语，后面跟上所有可能抛出异常类型的清单。

  捕捉任意类型的异常

  要想创建一个“能处理任意类型异常的”异常处理程序是完全可能的，要做到这点，
  你就必须去捕捉异常的基类Exception，

  由于Exception只是那些跟程序员有关的异常类的基类，因此你不能从它那里得到更多的
  关于异常的具体信息，不过你也可以调用Exception的基类Throwable的方法，

  String getMessage()

  String getLocalizedMessage()

  String toString()

  void printStackTrace()
  void printStackTrace(PrintStream)
  void printStackTrace(java.io.PrintWriter)

  Throwable fillInStackTrace()

  用finally进行清理

   你会时常碰到”无论try区块有没有抛出异常“，程序都必须执行的代码。一般来说
   这些代码都是执行恢复内存之外的操作的（因为恢复内存是垃圾回收器的活）
   当你需要把内存以外的东西恢复到原先状态的时候finally就显得必要了。
   

Java异常处理之陋习展播（ZT） (Marilyn manson)

java 异常 

你觉得自己是一个Java专家吗？是否肯定自己已经全面掌握了Java的异常处理机制？在下面这段代码中，你能够迅速找出异常处理的六个问题吗？ 

[code:1:48e2a3bb92]
1 OutputStreamWriter out = ...

2 java.sql.Connection conn = ...

3 try { // ⑸

4    Statement stat = conn.createStatement();                                                                          

5    ResultSet rs = stat.executeQuery(

6    "select uid, name from user");

7    while (rs.next())

8    {

9       out.println("ID：" + rs.getString("uid") // ⑹

10     "，姓名：" + rs.getString("name"));

11   }

12   conn.close(); // ⑶

13   out.close();

14 }

15 catch(Exception ex) // ⑵

16 {

17    ex.printStackTrace(); //⑴，⑷

18 }
[/code:1:48e2a3bb92]

　　作为一个Java程序员，你至少应该能够找出两个问题。但是，如果你不能找出全部六个问题，请继续阅读本文。 

　　本文讨论的不是Java异常处理的一般性原则，因为这些原则已经被大多数人熟知。我们要做的是分析各种可称为“反例”（anti-pattern）的违背优秀编码规范的常见坏习惯，帮助读者熟悉这些典型的反面例子，从而能够在实际工作中敏锐地察觉和避免这些问题。 

　　反例之一：丢弃异常

　　代码：15行-18行。 

　　这段代码捕获了异常却不作任何处理，可以算得上Java编程中的杀手。从问题出现的频繁程度和祸害程度来看，它也许可以和C/C++程序的一个恶名远播的问题相提并论——不检查缓冲区是否已满。如果你看到了这种丢弃（而不是抛出）异常的情况，可以百分之九十九地肯定代码存在问题（在极少数情况下，这段代码有存在的理由，但最好加上完整的注释，以免引起别人误解）。 

　　这段代码的错误在于，异常（几乎）总是意味着某些事情不对劲了，或者说至少发生了某些不寻常的事情，我们不应该对程序发出的求救信号保持沉默和无动于衷。调用一下printStackTrace算不上“处理异常”。不错，调用printStackTrace对调试程序有帮助，但程序调试阶段结束之后，printStackTrace就不应再在异常处理模块中担负主要责任了。 

　　丢弃异常的情形非常普遍。打开JDK的ThreadDeath类的文档，可以看到下面这段说明：“特别地，虽然出现ThreadDeath是一种‘正常的情形’，但ThreadDeath类是Error而不是Exception的子类，因为许多应用会捕获所有的Exception然后丢弃它不再理睬。”这段话的意思是，虽然ThreadDeath代表的是一种普通的问题，但鉴于许多应用会试图捕获所有异常然后不予以适当的处理，所以JDK把ThreadDeath定义成了Error的子类，因为Error类代表的是一般的应用不应该去捕获的严重问题。可见，丢弃异常这一坏习惯是如此常见，它甚至已经影响到了Java本身的设计。 

　　那么，应该怎样改正呢？主要有四个选择： 

　　1、处理异常。针对该异常采取一些行动，例如修正问题、提醒某个人或进行其他一些处理，要根据具体的情形确定应该采取的动作。再次说明，调用printStackTrace算不上已经“处理好了异常”。 

　　2、重新抛出异常。处理异常的代码在分析异常之后，认为自己不能处理它，重新抛出异常也不失为一种选择。 

　　3、把该异常转换成另一种异常。大多数情况下，这是指把一个低级的异常转换成应用级的异常（其含义更容易被用户了解的异常）。 

　　4、不要捕获异常。 

　　结论一：既然捕获了异常，就要对它进行适当的处理。不要捕获异常之后又把它丢弃，不予理睬。 

　　反例之二：不指定具体的异常 

　　代码：15行。 

　　许多时候人们会被这样一种“美妙的”想法吸引：用一个catch语句捕获所有的异常。最常见的情形就是使用catch(Exception ex)语句。但实际上，在绝大多数情况下，这种做法不值得提倡。为什么呢？ 

　　要理解其原因，我们必须回顾一下catch语句的用途。catch语句表示我们预期会出现某种异常，而且希望能够处理该异常。异常类的作用就是告诉Java编译器我们想要处理的是哪一种异常。由于绝大多数异常都直接或间接从java.lang.Exception派生，catch(Exception ex)就相当于说我们想要处理几乎所有的异常。 

　　再来看看前面的代码例子。我们真正想要捕获的异常是什么呢？最明显的一个是SQLException，这是JDBC操作中常见的异常。另一个可能的异常是IOException，因为它要操作OutputStreamWriter。显然，在同一个catch块中处理这两种截然不同的异常是不合适的。如果用两个catch块分别捕获SQLException和IOException就要好多了。这就是说，catch语句应当尽量指定具体的异常类型，而不应该指定涵盖范围太广的Exception类。 

　　另一方面，除了这两个特定的异常，还有其他许多异常也可能出现。例如，如果由于某种原因，executeQuery返回了null，该怎么办？答案是让它们继续抛出，即不必捕获也不必处理。实际上，我们不能也不应该去捕获可能出现的所有异常，程序的其他地方还有捕获异常的机会——直至最后由JVM处理。 

　　结论二：在catch语句中尽可能指定具体的异常类型，必要时使用多个catch。不要试图处理所有可能出现的异常。 

　　反例之三：占用资源不释放 

　　代码：3行-14行。 

　　异常改变了程序正常的执行流程。这个道理虽然简单，却常常被人们忽视。如果程序用到了文件、Socket、JDBC连接之类的资源，即使遇到了异常，也要正确释放占用的资源。为此，Java提供了一个简化这类操作的关键词finally。 

　　finally是样好东西：不管是否出现了异常，Finally保证在try/catch/finally块结束之前，执行清理任务的代码总是有机会执行。遗憾的是有些人却不习惯使用finally。 

　　当然，编写finally块应当多加小心，特别是要注意在finally块之内抛出的异常——这是执行清理任务的最后机会，尽量不要再有难以处理的错误。 

　　结论三：保证所有资源都被正确释放。充分运用finally关键词。 

　　反例之四：不说明异常的详细信息 

　　代码：3行-18行。 

　　仔细观察这段代码：如果循环内部出现了异常，会发生什么事情？我们可以得到足够的信息判断循环内部出错的原因吗？不能。我们只能知道当前正在处理的类发生了某种错误，但却不能获得任何信息判断导致当前错误的原因。 

　　printStackTrace的堆栈跟踪功能显示出程序运行到当前类的执行流程，但只提供了一些最基本的信息，未能说明实际导致错误的原因，同时也不易解读。 

　　因此，在出现异常时，最好能够提供一些文字信息，例如当前正在执行的类、方法和其他状态信息，包括以一种更适合阅读的方式整理和组织printStackTrace提供的信息。 

　　结论四：在异常处理模块中提供适量的错误原因信息，组织错误信息使其易于理解和阅读。 

　　反例之五：过于庞大的try块 

　　代码：3行-14行。 

　　经常可以看到有人把大量的代码放入单个try块，实际上这不是好习惯。这种现象之所以常见，原因就在于有些人图省事，不愿花时间分析一大块代码中哪几行代码会抛出异常、异常的具体类型是什么。把大量的语句装入单个巨大的try块就象是出门旅游时把所有日常用品塞入一个大箱子，虽然东西是带上了，但要找出来可不容易。 

　　一些新手常常把大量的代码放入单个try块，然后再在catch语句中声明Exception，而不是分离各个可能出现异常的段落并分别捕获其异常。这种做法为分析程序抛出异常的原因带来了困难，因为一大段代码中有太多的地方可能抛出Exception。 

　　结论五：尽量减小try块的体积。 

　　反例之六：输出数据不完整 

　　代码：7行-11行。 

　　不完整的数据是Java程序的隐形杀手。仔细观察这段代码，考虑一下如果循环的中间抛出了异常，会发生什么事情。循环的执行当然是要被打断的，其次，catch块会执行——就这些，再也没有其他动作了。已经输出的数据怎么办？使用这些数据的人或设备将收到一份不完整的（因而也是错误的）数据，却得不到任何有关这份数据是否完整的提示。对于有些系统来说，数据不完整可能比系统停止运行带来更大的损失。 

　　较为理想的处置办法是向输出设备写一些信息，声明数据的不完整性；另一种可能有效的办法是，先缓冲要输出的数据，准备好全部数据之后再一次性输出。 

　　结论六：全面考虑可能出现的异常以及这些异常对执行流程的影响。 

　　改写后的代码 

　　根据上面的讨论，下面给出改写后的代码。也许有人会说它稍微有点啰嗦，但是它有了比较完备的异常处理机制。 

[code:1:48e2a3bb92]
OutputStreamWriter out = ...

java.sql.Connection conn = ...

try {

   Statement stat = conn.createStatement();

   ResultSet rs = stat.executeQuery(

   "select uid, name from user");

   while (rs.next())

   {

      out.println("ID：" + rs.getString("uid") +

      "，姓名: " + rs.getString("name"));

   }

}

catch(SQLException sqlex)

{

   out.println("警告：数据不完整");

   throw new ApplicationException(

   "读取数据时出现SQL错误", sqlex);

}

catch(IOException ioex)

{

   throw new ApplicationException(

   "写入数据时出现IO错误", ioex);

}

finally

{

   if (conn != null) {

      try {

         conn.close();

      }

      catch(SQLException sqlex2)

      {

          System.err(this.getClass().getName() +

          ".mymethod - 不能关闭数据库连接: " +

          sqlex2.toString());

      }

   }

   if (out != null) {

      try {

         out.close();

      }

      catch(IOException ioex2)

      {

         System.err(this.getClass().getName() +

         ".mymethod - 不能关闭输出文件" +

         ioex2.toString());

      }

   }

}
[/code:1:48e2a3bb92]

　　本文的结论不是放之四海皆准的教条，有时常识和经验才是最好的老师。如果你对自己的做法没有百分之百的信心，务必加上详细、全面的注释。 
　　另一方面，不要笑话这些错误，不妨问问你自己是否真地彻底摆脱了这些坏习惯。即使最有经验的程序员偶尔也会误入歧途，原因很简单，因为它们确确实实带来了“方便”。所有这些反例都可以看作Java编程世界的恶魔，它们美丽动人，无孔不入，时刻诱惑着你。也许有人会认为这些都属于鸡皮蒜毛的小事，不足挂齿，但请记住：勿以恶小而为之，勿以善小而不为。
 

1、java数据库操作基本流程

　　2、几个常用的重要技巧：

　　可滚动、更新的记录集

　　批量更新

　　事务处理

　　java数据库操作基本流程：取得数据库连接 - 执行sql语句 - 处理执行结果 - 释放数据库连接

　　1、取得数据库连接

　　1）用DriverManager取数据库连接

　　例子：

String className,url,uid,pwd;
className = "oracle.jdbc.driver.OracleDriver";
url = "jdbc:oracle:thin:@127.0.0.1:1521:orasvr;
uid = "system";
pwd = "manager";
Class.forName(className);
Connection cn = DriverManager.getConnection(url,uid,pwd);

　　2）用jndi(java的命名和目录服务)方式

　　例子

String jndi = "jdbc/db";
Context ctx = (Context) new InitialContext().lookup("java:comp/env");
DataSource ds = (DataSource) ctx.lookup(jndi);
Connection cn = ds.getConnection();

　　多用于jsp中

　　2、执行sql语句

　　1）用Statement来执行sql语句

String sql;
Statement sm = cn.createStatement();
sm.executeQuery(sql); // 执行数据查询语句（select）
sm.executeUpdate(sql); // 执行数据更新语句（delete、update、insert、drop等）statement.close();

　　2）用PreparedStatement来执行sql语句

String sql;
sql = "insert into user (id,name) values (?,?)";
PreparedStatement ps = cn.prepareStatement(sql);
ps.setInt(1,xxx);
ps.setString(2,xxx);
...
ResultSet rs = ps.executeQuery(); // 查询
int c = ps.executeUpdate(); // 更新

　　3、处理执行结果

　　查询语句，返回记录集ResultSet。

　　更新语句，返回数字，表示该更新影响的记录数。

　　ResultSet的方法：

　　1、next()，将游标往后移动一行，如果成功返回true；否则返回false。

　　2、getInt("id")或getSting("name")，返回当前游标下某个字段的值。

　　3、释放连接。

cn.close();

　　一般，先关闭ResultSet，然后关闭Statement（或者PreparedStatement）；最后关闭Connection

　　可滚动、更新的记录集

　　1、创建可滚动、更新的Statement

Statement sm = cn.createStatement(ResultSet.TYPE_SCROLL_ENSITIVE,ResultSet.CONCUR_READ_ONLY);

　　该Statement取得的ResultSet就是可滚动的

　　2、创建PreparedStatement时指定参数

PreparedStatemet ps = cn.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);

ResultSet.absolute(9000);

　　批量更新

　　1、Statement

Statement sm = cn.createStatement();
sm.addBatch(sql1);
sm.addBatch(sql2);
...
sm.executeBatch()

　　一个Statement对象，可以执行多个sql语句以后，批量更新。这多个语句可以是delete、update、insert等或兼有

　　2、PreparedStatement

PreparedStatement ps = cn.preparedStatement(sql);
{
　ps.setXXX(1,xxx);
　...
　ps.addBatch();
}
ps.executeBatch();

　　一个PreparedStatement，可以把一个sql语句，变换参数多次执行，一次更新。

　　事务的处理

　　1、关闭Connection的自动提交

cn.setAutoCommit(false);

　　2、执行一系列sql语句

　　要点：执行每一个新的sql语句前，上一次执行sql语句的Statement（或者PreparedStatemet）必须先close

Statement sm ;
sm = cn.createStatement(insert into user...);
sm.executeUpdate();
sm.close();

sm = cn.createStatement("insert into corp...);
sm.executeUpdate();
sm.close();

　　3、提交

cn.commit();

　　4、如果发生异常，那么回滚

cn.rollback();
　

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)
匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。
Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见
http: //www.frontfree.net/articles/services/view.asp?id=704&page=1
注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

第四，&和&&的区别。
&是位运算符。&&是布尔逻辑运算符。

第五，HashMap和Hashtable的区别。
都属于Map接口的类，实现了将惟一键映射到特定的值上。
HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。
Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

第六，Collection 和 Collections的区别。
Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口，它是各种集合结构的父接口。

第七，什么时候用assert。
断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 AssertionError。它用于调试目的：
assert(a > 0); // throws an AssertionError if a <= 0
断言可以有两种形式：
assert Expression1 ;
assert Expression1 : Expression2 ;
Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。
断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：
javac -source 1.4 Test.java
要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。
可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

第八，GC是什么? 为什么要有GC? (基础)。
GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：
System.gc()
Runtime.getRuntime().gc()

第九，String s = new String("xyz");创建了几个String Object?
两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;
第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
都不能

第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

第二十三，启动一个线程是用run()还是start()?
启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

第二十四，构造器Constructor是否可被override?
构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

第二十五，是否可以继承String类?
String类是final类故不可以继承。

第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
不能，一个对象的一个synchronized方法只能由一个线程访问。

第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
会执行，在return前执行。

第二十八，编程题: 用最有效率的方法算出2乘以8等於几?
有C背景的程序员特别喜欢问这种问题。

2 << 3

第二十九，两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
不对，有相同的hash code。

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

第三十二，编程题: 写一个Singleton出来。
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
　　private Singleton(){}
　　//在自己内部定义自己一个实例，是不是很奇怪？
　　//注意这是private 只供内部调用
　　private static Singleton instance = new Singleton();
　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}
第二种形式:
public class Singleton {
　　private static Singleton instance = null;
　　public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　}
}
其他形式:
定义一个类，它的构造函数为

public class Outer4
{
  private int size = 5;
  public Object makeTheInner( final int localVar )
               {
                   final int finalLocalVar = 6;
                   class Inner
                       {
                          public String toString()
                              {
                            return ( "localVar=" + localVar + ">" );
                              }//end public String toString()
                        }//end class Inner
                  return new Inner();
               }//end public Object makeTheInner( int localVar )
              
public static void main( String args[] )
{
 Outer4 outer = new Outer4();
 Object obj = outer.makeTheInner( 47 );
 System.out.println( "The object is " + obj );
}
}

Inner的toString会被调用,这是肯定的.
你的 final int finalLocalVar = 6; 可以加个static,这样可以节省一定的内存和CPU开销. 不过好像没有用到么,那就删除吧.

同意楼上的
Object obj = outer.makeTheInner( 47 );
System.out.println( "The object is " + obj );
这时其实是System.out.println( "The object is " + obj.toString());

Object obj = outer.makeTheInner( 47 );
等同与
Object obj =new Inner();/////////示意一下
toString方法已经在Inner类中被重写了
所以输出应该是The object is localvar=47>

基本型别	大小	最小值	最大值
boolean	-----	-----	------
char	16-bit	Unicode 0	Unicode 2^16-1
byte	8-bit	-128	+127
short	16-bit	-2^15	+2^15-1
int	32-bit	-2^31	+2^31-1
long	64-bit	-2^63	+2^63-1
float	32-bit	IEEE754	IEEE754
double	64-bit	IEEE754	IEEE754
void

注意！：表格里的^代表的是次方哈～

使用 Float 类 节省开发时间 
作者： Builder.com
2004-11-16 11:50 AM
 

即使你可能知道 IEEE 浮点数，你可能也从来没有逐个比特地处理过这类数据。下面我将向你展示如何逐个比特地处理 IEEE 浮点数，下次在你的 Java 项目需要从比特序列创建浮点数时，或者从浮点数创建比特序列时，你就知道Float 类可以为完成这一工作。

IEEE 浮点数介绍

IEEE 754 浮点单精度数字格式定义了一个用于存储浮点数的比特布局。在空比特布局中，一个比特留作符号位，八个比特留作指数，23个比特留作尾数。这些比特是按最重要比特到最不重要比特进行排列的，如下例所示：

 
31                             0
|                              |                     
SEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMM

其中：

S = 符号位
E = 指数
M = 尾数

你可以从 IEEE 的站点购买一份 IEEE 浮点数的完整解释。（如果在线搜索 IEEE 754，你应该可以找到免费的版本。）

Float 对 Java 社区的贡献

下面的示例程序使用 Float 的两个方法将一个浮点数转成比特，然后又将这些比特转成一个浮点数。

使用Float.floatToIntBits(float f) 方法可以将一个浮点数转成一个比特序列。这个方法返回一个32位整数，表示你作为参数提供的浮点数的 IEEE 754 比特排列。

使用Float.intBitsToFloat(int bits) 方法可以进行反方向转换。这个方法接受传入的整数作为参数，将这些比特转成一个 IEEE 浮点数。

下面是示例程序：

public class BitsTip {
    public static void main(String args[]) {
        float f = Float.parseFloat(args[0]);
        int bits = Float.floatToIntBits(f);

        System.out.println("bits: " + bits);
        System.out.println("back to float: " + Float.intBitsToFloat(bits));
    }
}

如果你曾经必须要手工进行这种转换，那么你就会很欣赏这两个简单的方法为你节省的工作。如果你正在处理64位数，那么可以选择使用Double 包装器（wrapper）类。这个类提供同样的方法处理IEEE 754 双精度浮点数。

最好选择阅读一下javadoc，查阅里面有关浮点数与比特序列之间的转换的部分，以便完整地了解这些方法都能为你些做什么。