BlogJava-路漫漫其修远兮，吾将上下而求索-随笔分类-Java编程

t.interrupt(),t.isInterrupted(),Thread.interrupted()

Frank_Fang — Sat, 22 Aug 2009 03:07:00 GMT

摘要: 在学校的论坛Java版发现很多问关于这样的问题，比如这几个方法有什么区别，想看t.interrupt()方法后线程的中断状态；如何终止一个线程其实之前已经大部分提及到。现总结一下，然后加上例子，毕竟例子容易理解 http://www.blogjava.net/fhtdy2004/archive/2009/06/08/280728.html中有关interrupt()的解释已经很清楚了 ... 阅读全文

Frank_Fang 2009-08-22 11:07 发表评论

【转】线程中的默认异常处理

Frank_Fang — Fri, 07 Aug 2009 05:15:00 GMT

http://www.ibm.com/developerworks/cn/java/j-tiger08104/

跟踪无法预期的运行时异常可能是一件又慢又费力的事情，只获得默认线程名称和堆栈跟踪通常是不够的。在 驯服 Tiger 这一期专栏中，Java 开发人员 John Zukowski 向您展示了如何通过替代默认行为来定制输出。他还对比了通过细分 ThreadGroup 定制输出的老方法与通过提供自己的 UncaughtExceptionHandler 定制输出的新方法。

虽然我们不想创建在无法预期时抛出运行时异常的程序，但这种情况还是会发生——尤其是第一次运行复杂程序时。通常是使用默认行为、打印堆栈溢出和结束线程的生命来处理这些异常。

从哪里发现默认行为？每个线程都属于一个由 java.lang.ThreadGroup 类表示的线程组。顾名思义，线程组允许您将线程组合在一起。您可能是为了方便而将线程组合，例如，一个线程池中的所有线程都属于组 X，而另一个池的所有线程则属于组 Y，或者是为了访问控制而将线程进行组合。组 X 中的线程无权访问或改变组 Y 中的线程，除非它们都在同一线程组内（或在一个子组内）。

在 Tiger 之前， ThreadGroup 类提供了一种处理未捕获异常的方法： ThreadGroup 的 uncaughtException() 方法。如果异常不是 ThreadDeath ，则将线程的名称和堆栈回溯（stack backtrace）发送到 System.err 。但是 Tiger 添加了另一种方法： Thread.UncaughtExceptionHandler 接口。细分 ThreadGroup 或安装该新接口的实现都允许您更改默认行为。我们将对 Tiger 之前和之后提供的方法都进行研究。

使用 ThreadGroup 的定制行为

发生未捕获的异常时，默认行为是将堆栈溢出打印输出到系统错误（ System.err ）中，如清单 1 中所示。不需要使用任何命令参数来启动程序。

清单 1. 线程溢出示例

public class SimpleDump {
            public static void main(String args[]) {
            System.out.println(args[0]);
            }
            }

不使用任何参数运行该程序将生成清单 2 中的输出。尽管它不是一个很长的堆栈跟踪，但它是一个完整的堆栈跟踪。

清单 2. 默认线程溢出输出

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
            at SimpleDump.main(SimpleDump.java:3)

正如 Java 平台的许多东西一样，如果不喜欢默认行为，您可以对其进行更改。在 Java 平台的 Tiger 版以前的版本中，不能替代所有线程的默认行为，但是可以创建一个新的 ThreadGroup ，并更改在该组内创建的任何线程的默认行为。您可以重写 uncaughtException(Thread t, Throwable e) 方法来定制该行为。然后，当发生未预料的运行时异常时，该线程组内创建的任何线程都将获得新的行为。不过，最好是修复基础问题，我将提供一个简单的示例，说明更改默认行为所必需的步骤。清单 3 展示了将执行代码放入新线程的调整过的测试程序：

清单 3. 调整过的线程溢出示例

public class WindowDump {
            public static void main(String args[]) throws Exception {
            ThreadGroup group = new LoggingThreadGroup("Logger");
            new Thread(group, "myThread") {
            public void run() {
            System.out.println(1 / 0);
            }
            }.start();
            }
            }

LoggingThreadGroup 类是一个新的内容，清单 4 中显示了它的定义。为了进行说明，通过重写 uncaughtException() 方法实现的特殊行为将在一个弹出窗口中显示该异常，这项操作是在特殊 Handler 的帮助下使用 Java Logging API 来完成的。

清单 4. LoggingThreadGroup 的定义

import java.util.logging.*;
            public class LoggingThreadGroup extends ThreadGroup {
            private static Logger logger;
            public LoggingThreadGroup(String name) {
            super(name);
            }
            public void uncaughtException(Thread t, Throwable e) {
            // Initialize logger once
            if (logger == null) {
            logger = Logger.getLogger("example");
            Handler handler = LoggingWindowHandler.getInstance();
            logger.addHandler(handler);
            }
            logger.log(Level.WARNING, t.getName(), e);
            }
            }

这里创建的定制 Handler 的类型为 LoggingWindowHandler ，该类型的定义在清单 5 中。处理程序使用了一个支持类 LoggingWindow ，该类将异常显示在屏幕上。清单 6 中显示了该类的定义。 Handler 的 public void publish(LogRecord record) 方法实现了一些重要操作。其余操作大部分只与配置有关。

清单 5. LoggingWindowHandler 的定义

import java.util.logging.*;
            public class LoggingWindowHandler extends Handler {
            private static LoggingWindow window;
            private static LoggingWindowHandler handler;
            private LoggingWindowHandler() {
            configure();
            window = new LoggingWindow("Logging window...", 400, 200);
            }
            public static synchronized LoggingWindowHandler getInstance() {
            if (handler == null) {
            handler = new LoggingWindowHandler();
            }
            return handler;
            }
            /**
            * Get any configuration properties set
            */
            private void configure() {
            LogManager manager = LogManager.getLogManager();
            String className = getClass().getName();
            String level = manager.getProperty(className + ".level");
            setLevel((level == null) ? Level.INFO : Level.parse(level));
            String filter = manager.getProperty(className + ".filter");
            setFilter(makeFilter(filter));
            String formatter =
            manager.getProperty(className + ".formatter");
            setFormatter(makeFormatter(formatter));
            }
            private Filter makeFilter(String name) {
            Filter f = null;
            try {
            Class c = Class.forName(name);
            f = (Filter)c.newInstance();
            } catch (Exception e) {
            if (name != null) {
            System.err.println("Unable to load filter: " + name);
            }
            }
            return f;
            }
            private Formatter makeFormatter(String name) {
            Formatter f = null;
            try {
            Class c = Class.forName(name);
            f = (Formatter)c.newInstance();
            } catch (Exception e) {
            f = new SimpleFormatter();
            }
            return f;
            }
            // Overridden abstract Handler methods
            public void close() {
            }
            public void flush() {
            }
            /**
            * If record is loggable, format it and add it to window
            */
            public void publish(LogRecord record) {
            String message = null;
            if (isLoggable(record)) {
            try {
            message = getFormatter().format(record);
            } catch (Exception e) {
            reportError(null, e, ErrorManager.FORMAT_FAILURE);
            return;
            }
            try {
            window.addLogInfo(message);
            } catch (Exception e) {
            reportError(null, e, ErrorManager.WRITE_FAILURE);
            }
            }
            }
            }

清单 6. LoggingWindow 的定义

import java.awt.*;
            import javax.swing.*;
            public class LoggingWindow extends JFrame {
            private JTextArea textArea;
            public LoggingWindow(String title, final int width,
            final int height) {
            super(title);
            EventQueue.invokeLater(new Runnable() {
            public void run() {
            setSize(width, height);
            textArea = new JTextArea();
            JScrollPane pane = new JScrollPane(textArea);
            textArea.setEditable(false);
            getContentPane().add(pane);
            setVisible(true);
            }
            });
            }
            public void addLogInfo(final String data) {
            EventQueue.invokeLater(new Runnable() {
            public void run() {
            textArea.append(data);
            }
            });
            }
            }

执行清单 3 中的 WindowDump 程序将出现图 1 中的屏幕。因为没有从 Logger 中删除控制台处理程序，所以堆栈溢出仍将出现在控制台上。

图 1. 记录的堆栈跟踪

发生运行时异常时，可能要做许多工作来更改发生的问题。该代码的大部分都是 Logging Handler，但是，要执行更改，就必须细分 ThreadGroup ，重写 uncaughtException() ，然后在该线程组中执行您的线程。不过，让我们通过只安装 Thread.UncaughtExceptionHandler ，来看一看 Tiger 的处理方式。

回页首

使用 UncaughtExceptionHandler 的定制行为

对于 Tiger， Thread 类定义中添加了一个新的公共内部类 UncaughtExceptionHandler ，更完整的名称为 Thread.UncaughtExceptionHandler （其他类访问内部类时需要使用完整名称）。接口的定义是一个方法，如图 7 中所示：

清单 7. UncaughtExceptionHandler 的定义

public interface Thread.UncaughtExceptionHandler {
            public void uncaughtException(Thread, Throwable);
            }

您可能没有注意到，清单 7 中的方法与我们前面重写的 ThreadGroup 的方法相同。实际上，现在由 ThreadGroup 类实现该接口。

新的内部类可以帮助我们了解下列两对新方法，并有助于我们在 Thread 中使用它们：

getUncaughtExceptionHandler() 和 setUncaughtExceptionHandler() 。
getDefaultUncaughtExceptionHandler() 和 setDefaultUncaughtExceptionHandler() 。

第一对方法是 getUncaughtExceptionHandler() 和 setUncaughtExceptionHandler() ，它们允许您为当前线程及其后代定制行为，从而允许二十或更多的线程拥有自己的定制行为。不过，您更可能使用第二对方法 getDefaultUncaughtExceptionHandler() 和 setDefaultUncaughtExceptionHandler() 。如果使用第二对方法设置默认处理程序，那么没有自己的异常处理程序的所有线程都将使用默认处理程序。

听起来好像很简单。为了进行说明，清单 8 转换了清单 3 中的 ThreadGroup 友好的程序，使用新的 UncaughtExceptionHandler 接口：

清单 8. UncaughtExceptionHandler 示例

public class HandlerDump {
            public static void main(String args[]) throws Exception {
            Thread.UncaughtExceptionHandler handler = new LoggingThreadGroup("Logger");
            Thread.currentThread().setUncaughtExceptionHandler(handler);
            System.out.println(1 / 0);
            }
            }

该程序只是将 LoggingThreadGroup 重用为 UncaughtExceptionHandler ，并没有创建新的处理程序实现。请注意，与原来的代码相比，新代码要简洁得多。

回页首

其他线程更改

Thread 类不仅支持使用 Tiger 添加的未捕获异常处理程序，它还支持使用 getAllStackTraces() 获得所有有效线程的堆栈跟踪，或者支持使用 getStackTrace() 来只获得当前线程的堆栈跟踪。这两种堆栈跟踪都返回类型为 java.lang.StackTraceElement 的对象， java.lang.StackTraceElement 是 Java 1.4 平台中添加的一个类，它可以让您生成自己的堆栈跟踪。同时，Java 5 平台新添加的功能是一个惟一线程标识符（可以使用 getId() 获得该标识符）和一个新的 Thread.State 类，以及与该类相关的 getThreadState() 方法。最后一个线程更改是一个状态枚举表，该表是用来监视系统状态，而不是用来同步状态的。

回页首

结束语

像添加未捕获的异常处理程序这样的简单库更改，可以极大地增加原代码的可理解性。虽然在线程组级别上，新的库代码的功能与原来库代码的相同，但新模型中的易用性和灵活性远远超出了将代码调整为更新的方式所需的时间。当然，老方法仍然可以使用，但最好将代码更新为最新的库功能。

Frank_Fang 2009-08-07 13:15 发表评论

Java中主线程如何捕获子线程抛出的异常

Frank_Fang — Fri, 07 Aug 2009 04:38:00 GMT

这么来看待这个问题。首先明确线程代码的边界。其实很简单，Runnable接口的run方法所界定的边界就可以看作是线程代码的边界。Runnable接口中run方法原型如下：
<<
public void run();
>>
而所有的具体线程都实现这个方法，所以这里就明确了一点，线程代码不能抛出任何checked异常。所有的线程中的checked异常都只能被线程本身消化掉。:) 这样本身也是符合线程的设计理念的，线程本身就是被看作独立的执行片断，它应该对自己负责，所以由它来消化所有的checked异常是很正常的。
这样就回答了楼主的第一个问题：checked异常一定要在线程内部消化。

但是，线程代码中是可以抛出错误(Error)和运行级别异常(RuntimeException)的。Error俺们可以忽略，因为通常Error是应该留给vm的，而RuntimeException确是比较正常的，如果在运行过程中满足了某种条件导致线程必须中断，可以选择使用抛出运行级别异常来处理，如下：
<<
public void run() {
if (...) throw new RuntimeException();
}
>>
当线程代码抛出运行级别异常之后，线程会中断。:)这点java中解释得很清楚：
<< @see Thread
All threads that are not daemon threads have died, either by returning from the call to the run method or "by throwing an exception that propagates beyond the run method".
>>
但是对于invoke此线程的主线程会产生什么影响呢？主线程不受这个影响，不会处理这个RuntimeException，而且根本不能catch到这个异常。会继续执行自己的代码 :)
所以得到结论：线程方法的异常只能自己来处理。

关于最后一点，不相信的话大家可以做这么一个试验：
<<
public class TestThreadException extends Thread {
public void run() {
throw new RuntimeException();
}

public static void main(String[] args) throws InterruptedException {
try {
new TestThreadException().start();
} catch(RuntimeException ex) {
// 看看能不能到达这里？ :)
}

Thread.sleep(1000);
// 看看能不能到达这里？ :)
}
}
>>

记不得在哪里看到的代码，可以处理到线程中抛出的RuntimeException：

public class ApplicationLoader extends ThreadGroup
{
private ApplicationLoader()
{

super("ApplicationLoader");

}

public static void main(String[] args)
{

Runnable appStarter = new Runnable()
{

public void run()
{
//invoke your application (i.e.MySystem.main(args)

throw new NullPointerException(); //example, throw a runtime exception
}
};

new Thread(new ApplicationLoader(), appStarter).start();
}

//We overload this method from our parent
//ThreadGroup , which will make sure that it
//gets called when it needs to be. This is
//where the magic occurs.
public void uncaughtException(Thread thread, Throwable exception)
{
//Handle the error/exception.
//Typical operations might be displaying a
//useful dialog, writing to an event log, etc.

exception.printStackTrace();//example, print stack trace
}
}

呵呵，uncaughtException好像是唯一能够处理线程抛出的uncaught异常的入口。看来还是有细心人啊。确实如此，通过ThreadGroup的uncaughtException方法还是有处理的机会。当线程抛出uncaughtException的时候，JVM会调用ThreadGroup的此方法。默认的处理如下：
<<
public void uncaughtException(Thread t, Throwable e) {
if (parent != null) {
parent.uncaughtException(t, e);
} else if (!(e instanceof ThreadDeath)) {
e.printStackTrace(System.err);
}
}
>>
每个Thread都会有一个ThreadGroup对象，可以通过Thread.getThreadGroup()方法得到，提供了上述默认的uncaught异常处理方法。
上面没有提这点，因为俺认为在正常的情况下，这个方法的处理情况就已经足够了。还是那个线程设计的理念：“线程的问题应该线程自己本身来解决，而不要委托到外部。”通常情况下，外部不需要处理线程的异常。当然也有例外。:)

Frank_Fang 2009-08-07 12:38 发表评论

【转】Java1.5泛型指南中文版(Java1.5 Generic Tutorial)

Frank_Fang — Mon, 27 Jul 2009 12:50:00 GMT

摘要: Java1.5泛型指南中文版(Java1.5 Generic Tutorial) 英文版pdf下载链接：http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf 终于翻译完了，感觉挺累！译文有些地方可能有误或者不准确，所以保留了一些原文，对于重要的地方，也保留原文以助理解，欢迎来信指正或讨论，mailto:chengchengji@163.c... 阅读全文

Frank_Fang 2009-07-27 20:50 发表评论

Java集合类小结

Frank_Fang — Wed, 15 Jul 2009 16:01:00 GMT

Java集合类小结

Frank_Fang 2009-07-16 00:01 发表评论

Java反射机制学习小结

Frank_Fang — Thu, 09 Jul 2009 02:08:00 GMT

先留着

Frank_Fang 2009-07-09 10:08 发表评论

Java Hashtable分析

Frank_Fang — Fri, 03 Jul 2009 05:24:00 GMT

摘要: Hashtable的结构，采用的是数据结构中所说的链地址法处理冲突的方法从上面的结构图可以看出，Hashtable的实质就是一个数组＋链表。图中的Entry就是链表的实现，Entry的结构中包含了对自己的另一个实例的引用next，用以指向另外一个Entry。而图中标有数字的部分是一个Entry数组，数字就是这个Entry数组的index。那么往Hashtable增加键值对的时候，ind... 阅读全文

Frank_Fang 2009-07-03 13:24 发表评论

Java 内存模型及 volatile关键字语义

Frank_Fang — Sat, 27 Jun 2009 16:50:00 GMT

http://www.javaeye.com/topic/109150

http://itchaser.javaeye.com/blog/440335

http://www.javaeye.com/topic/11315

还得了解一下Java内存模型。。。

看了一下Java虚拟机规范，就比较清楚了

Frank_Fang 2009-06-28 00:50 发表评论

[转]J2EE项目异常处理

Frank_Fang — Wed, 24 Jun 2009 02:29:00 GMT

摘要: 被ibm给鄙视后，好好看了一下Java的异常机制，的确自己太弱了，很多东西之前都没有仔细的去了解研究。同时自己也确实没有什么special的地方。下一步准备在放假之前好好研究一下Java网络编程，nio,mina以前虽然用了下也没有深入。暑期不找实习了，学学Linux编程和ACE，再复习一下基础好好充一下电，现在是笔试都过不了。转帖地址 http://www.javaeye.com/to... 阅读全文

Frank_Fang 2009-06-24 10:29 发表评论

Java transient关键字

Frank_Fang — Sat, 20 Jun 2009 10:23:00 GMT

Volatile修饰的成员变量在每次被线程访问时，都强迫从主内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到主内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。

这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。

而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。

由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

java关键字Transient

转自http://horst.sun.blog.163.com/blog/static/348849612007614494492/

翻译自http://www.devx.com/tips/Tip/13726。

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想
用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。
transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
注意static变量也是可以串行化的

首先，让我们看一些Java serialization的代码：
public class LoggingInfo implements java.io.Serializable
{
    private Date loggingDate = new Date();
    private String uid;
    private transient String pwd;

    LoggingInfo(String user, String password)
    {
        uid = user;
        pwd = password;
    }
    public String toString()
    {
        String password=null;
        if(pwd == null)
        {
        password = "NOT SET";
        }
        else
        {
            password = pwd;
        }
        return "logon info: \n   " + "user: " + uid +
            "\n   logging date : " + loggingDate.toString() +
            "\n   password: " + password;
    }
}

现在我们创建一个这个类的实例，并且串行化(serialize)它 ,然后将这个串行化对象写如磁盘。

LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");
System.out.println(logInfo.toString());
try
{
   ObjectOutputStream o = new ObjectOutputStream(
                new FileOutputStream("logInfo.out"));
   o.writeObject(logInfo);
   o.close();
}
catch(Exception e) {//deal with exception}

To read the object back, we can write

try
{
   ObjectInputStream in =new ObjectInputStream(
                new FileInputStream("logInfo.out"));
   LoggingInfo logInfo = (LoggingInfo)in.readObject();
   System.out.println(logInfo.toString());
}
catch(Exception e) {//deal with exception}

如果我们运行这段代码，我们会注意到从磁盘中读回(read——back (de-serializing))的对象打印password为"NOT SET"。这是当我们定义pwd域为transient时，所期望的正确结果。
现在，让我们来看一下粗心对待transient域可能引起的潜在问题。假设我们修改了类定义，提供给transient域一个默认值，
代码如下：

public class GuestLoggingInfo implements java.io.Serializable
{
    private Date loggingDate = new Date();
    private String uid;
    private transient String pwd;

    GuestLoggingInfo()
    {
        uid = "guest";
        pwd = "guest";
    }
    public String toString()
    {
        //same as above
     }
}
现在，如果我们穿行化GuestLoggingInfo的一个实例，将它写入磁盘，并且再将它从磁盘中读出，我们仍然看到读回的对象打印password 为 "NOT SET"。当从磁盘中读出某个类的实例时，实际上并不会执行这个类的构造函数，
而是载入了一个该类对象的持久化状态，并将这个状态赋值给该类的另一个对象。

Frank_Fang 2009-06-20 18:23 发表评论

Java Serializable小结

Frank_Fang — Sat, 20 Jun 2009 10:00:00 GMT

Frank_Fang 2009-06-20 18:00 发表评论

java.io.Serializable与java.io.Externalizable的比较

Frank_Fang — Sat, 20 Jun 2009 09:43:00 GMT

摘要: 当两个进程在进行远程通信时，无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送，称为对象的序列化；接收方则需要把字节序列再恢复为Java对象，称为对象的反序列化。只有实现了Serializable和Externalizable接口的类的对象才能被序列化，而Extern... 阅读全文

Frank_Fang 2009-06-20 17:43 发表评论

【转】避免在Java中使用Checked Exception

Frank_Fang — Sat, 20 Jun 2009 07:49:00 GMT

Java 提供了两种Exception 的模式，一种是执行的时候所产生的Exception (Runtime Exception)，另外一种则是受控制的Exception (Checked Exception)。

所有的Checked Exception 均从java.lang.Exception 继承而来，而Runtime Exception 则继承java.lang.RuntimeException 或java.lang.Error (实际上java.lang.RuntimeException 的上一层也是java.lang.Exception，这说明作为exception两者并没有本质的区别，只是java语言本身从功能考虑有所区分，这才导致下面提到的不同点)。

一个函数如果会抛出Checked Exception ，（这里包含两种情况，一个是函数本身抛出，另外一种是它调用的函数会抛出Checked Exception 但是它并没有去catch这个exception），那在声明此函数的时候必须标明throws XXXException()。而Runtime Exception不需要如此声明。

逻辑上看，Runtime Exception 与Checked Exception 使用目的不一样。一般而言，Checked Exception 表示这个Exception 必须要被处理，也就是说程序设计者应该已经知道可能会收到某个Exception(因为要try catch住) ，所以程序设计者应该能也必须（或者标明throws XXXException()继续抛出去，或者try catch处理，不然是编译不过的）针对这些不同的Checked Exception 做出不同的处理。而Runtime Exception 通常会暗示着程序上的错误，这种错误会导致程序设计者无法处理，而造成程序无法继续执行下去（可以try catch处理而避免程序挂掉，但是这常常会掩盖问题所在）。

checked exception由于必须被处理，会给程序员带来额外的麻烦，试想一个函数a，它会调用到b1，b2...，b9一共9个函数，这些函数每个都会抛出checked exception，而a函数里面又没有办法处理这些exception，那在声明a函数的时候就必须连写9个throw xxxException，够累的！！然而这仅仅是问题的一个方面，所以下面这篇文章试图说服我们尽量使用runtime exception替代checked exception(前面提到可以try catch处理runtime exception，而避免程序挂掉，这也是这样做的一个前提)。

这篇文章指出了Java中checked Exception的一些缺点，提出应该在程序设计中避免使用checked Exception,对于需要处理checked Exception的代码，可以使用ExceptionAdapter这个类对checked Exception进行包装。这篇文章的概念和ExceptionAdapter这个类均源自Bruce Eckel的Does Java need Checked Exception。

Java的Exception分为两类，一类是RuntimeException及其子类，另外一类就是checked Exception。Java要求函数对没有被catch处理掉的checked Exception，需要将其写在函数的声明部分。然而，这一要求常常给程序员带来一些不必要的负担。

为了避免在函数声明中写throws部分，在Java项目里面常常可以看到以下代码用来‘吞掉’Exception：

try {
  //
} catch (Exception ex) {
           ex.printStackTrace();
  }

这显然不是一个好的处理Exception办法，事实上，catch并处理一个Exception意味着让程序从发生的错误(Exception)中恢复过来。从这种意义上说，已上的代码只可能在一些很简单的情况下工作而不带来问题。

对于很多Exception，往往没有去处理它并让程序从错误中恢复出来的办法，这时唯一能做的事情可能就是在界面上显示一些提示信息给用户。这种情况下让程序抛出遇到的Exception是更为合理的做法。然而，这样做会使得一些函数的声明急剧膨胀。一个函数可能需要声明会抛出的7、8个checked Exception，而且每个调用它的函数也需要同样的声明。

比这更糟糕的是，这有可能破坏类设计的open-close原则。简单来说，open-close原则是指当扩展一个模块的时候，可以不影响其现有的client。open-close原则是通过继承来实现的，当继承一个类的时候，我们既扩展了这个类，也不会影响原有的client（因为对这个类没有改动）。

现在考虑下面这种情况，有一个父类Base：

public class Base {
    public void foo() throws ExceptionA {
       //
    }
}

现在需要继承Base这个类并重载foo这个方法，在新的实现中，foo可能抛出ExceptionB：

public class Extend extends Base {
    public void foo() throws ExceptionB {
       //
    }
}

然而，这样写在Java里面是不合法的，尽管Java不会抛出的Exception看作函数特征的一部分，但子类声明抛出的Exception必须是父类的子集。
可以在Base类的foo方法中加入抛出ExceptionB的声明，然而，这样就破坏了open-close原则。而且，有时我们没有办法去修改父类，比如当重载一个Jdk里的类的时候。

另一个可能的做法是在Extend的foo方法中catch住ExceptionB，然后构造一个ExceptionA并抛出。这是个可行的办法但也只是一个权宜之计。

如果使用RuntimeException，这些问题都不会存在。这说明checked Exception并不是一个很实用的概念，也意味着在程序设计的时候，我们应该让自己的Exception类继承RuntimeException而不是Exception。（这和JDK的建议正好相反，但实践证明这样做代码的质量更好。）

对于那些需要处理checked Exception的代码，可以利用一个ExceptionAdapter的类把checked Exception包装成一个RuntimeException抛出。ExceptionAdapter来自Bruce Eckel的Does Java need Checked Exception这篇文章，

public class ExceptionAdapter extends RuntimeException {

    public ExceptionAdapter(Exception ex) {

       super(ex);

    }

    public void printStackTrace(java.io.PrintStream s) {

       getCause().printStackTrace(s);

    }

    public void printStackTrace(java.io.PrintWriter s) {
       getCause().printStackTrace(s);

    }

    // rethrow()的作用是把被包装的Exception再次抛出。

    public void rethrow()
       throws Exception
    {
       throw (Exception) getCause();
    }
}

Frank_Fang 2009-06-20 15:49 发表评论

Java Exception小结(二)

Frank_Fang — Thu, 18 Jun 2009 15:40:00 GMT

摘要: RuntimeException异常以及其子类异常，不需要异常说明就可以从任何地方抛出是uncheck exception。从程序的输出看出，无论有没有抛出异常，finally子句总会得到执行，这个程序也启发我们应该如何处理我们前面讲到过的,Java异常（和C++ 的异常一样）会阻止程序回到异常抛出的地方恢复执行这个问题。如果你把try块放进一个循环，你就能构建一个... 阅读全文

Frank_Fang 2009-06-18 23:40 发表评论

Java Exception小结

Frank_Fang — Thu, 18 Jun 2009 15:36:00 GMT

唉，今天ibm面试看来是被鄙视了，问及异常不知道是要问CheckedException和UncheckedException
thinking in java看的早忘了。
看了好几篇帖子，还是理解不够深刻
http://www.javaeye.com/topic/2038       主题：为什么 Java 中要使用 Checked Exceptions
http://www.javaeye.com/topic/14082     主题：我对Checked Exceptions的看法 (续为什么java引入Checked Ex...
http://www.javaeye.com/topic/10482     主题：我对Checked Exception观点的变化
 http://www.javaeye.com/topic/72170     主题：J2EE项目异常处理
 http://www.ibm.com/developerworks/cn/java/j-jtp05254/index.html

http://www.onjava.com/pub/a/onjava/2006/01/11/exception-handling-framework-for-j2ee.html?page=6&x-order=date

http://www.onjava.com/pub/a/onjava/2003/11/19/exceptions.html?page=2

本文是Exception处理的一篇不错的文章，从Java Exception的概念介绍起，依次讲解了Exception的类型（Checked/Unchecked），Exception处理的最佳实现：
1．选择Checked还是Unchecked的几个经典依据
2． Exception的封装问题
3．如无必要不要创建自己的Exception
4．不要用Exception来作流程控制
5．不要轻易的忽略捕获的Exception
6．不要简单地捕获顶层的Exception
原文地址：
http://www.onjava.com/pub/a/onjava/2003/11/19/exceptions.html

关于异常处理的一个问题就是要对何时（when）和如何（how）使用它们做到了然于心。在本文中我将介绍一些关于异常处理的最佳实践，同时我也会涉及到最近争论十分激烈的checked Exception的使用问题。

作为开发员，我们都希望能写出解决问题并且是高质量的代码。不幸的是，一些副作用（side effects）伴随着异常在我们的代码中慢慢滋生。无庸置疑，没有人喜欢副作用（side effects）,所以我们很快就用我们自己的方式来避免它，我曾经看到一些聪明的程序员用下面的方式来处理异常：

public void consumeAndForgetAllExceptions(){
try {
...some code that throws exceptions
} catch (Exception ex){
ex.printStacktrace();
}
}

上边的代码有什么问题么？

在回答以前让我们想想怎样才是正确的？是的，一旦程序碰到异常，它就该挂起程序而"做"点什么。那么上边的代码是这样子的么？看吧，它隐瞒了什么？它把所有的"苦水"往肚里咽（在控制台打印出异常信息），然后一切继续，从表面上看就像什么都没有发生过一样......，很显然，上边代码达到的效果并不是我们所期望的。

后来又怎样？

public void someMethod() throws Exception{
}

上边的代码又有什么问题？

很明显，上边的方法体是空的，它不实现任何的功能（没有一句代码），试问一个空方法体能抛出什么异常？当然Java并不阻止你这么干。最近，我也遇到类似的情景，方法声明会抛出异常，但是代码中并没有任何"机会"来"展示"异常。当我问开发员为什么要这样做的时候，他回答我说"我知道，它确实有点那个，但我以前就是这么干的并且它确实能为我工作。"

在C++社区曾经花了数年实践来实践如何使用异常，关于此类的争论在 java社区才刚刚开始。我曾经看到许多Java程序员针对使用异常的问题进行争论。如果对于异常处理不当的话，异常可以大大减慢应用程序的执行速度，因为它将消耗内存和CPU来创建、抛出并捕获异常。如果过分的依赖异常处理，代码对易读和易使用这两方面产生影响，以至于会让我们写出上边两处"糟糕"代码。

异常原理

大体上说，有三种不同的"情景"会导致异常的抛出：

l 编程错误导致异常（Exception due Programming errors）: 这种情景下，异常往往处于编程错误（如：NullPointerException 或者 IllegalArgumentException）,这时异常一旦抛出，客户端将变得无能为力。

l 客户端代码错误导致异常（Exception due client code errors）: 说白点就是客户端试图调用API不允许的操作。

l 资源失败导致异常（Exception due to resource failures）: 如内存不足或网络连接失败导致出现异常等。这些异常的出现客户端可以采取相应的措施来恢复应用程序的继续运行。

Java中异常的类型

Java 中定义了两类异常：

l Checked exception: 这类异常都是Exception的子类

l Unchecked exception: 这类异常都是RuntimeException的子类，虽然RuntimeException同样也是Exception的子类，但是它们是特殊的，它们不能通过client code来试图解决，所以称为Unchecked exception

举个例子，下图为NullPointerException的继承关系：

图中，NullPointerException继承自RuntimeException，所以它是Unchecked exception.

以往我都是应用checked exception多于Unchecked exception，最近，在java社区激起了一场关于checked exception和使用它们的价值的争论。这场争论起源于JAVA是第一个拥有Checked exception的主流OO语言这样一个事实，而C++和C#都是根本没有Checked exception，它们所有的异常都是unchecked。

一个checked exception强迫它的客户端可以抛出并捕获它，一旦客户端不能有效地处理这些被抛出的异常就会给程序的执行带来不期望的负担。
Checked exception还可能带来封装泄漏，看下面的代码：

public List getAllAccounts() throws
FileNotFoundException, SQLException{
...
}

上边的方法抛出两个异常。客户端必须显示的对这两种异常进行捕获和处理即使是在完全不知道这种异常到底是因为文件还是数据库操作引起的情况下。因此，此时的异常处理将导致一种方法和调用之间不合适的耦合。

接下来我会给出几种设计异常的最佳实践（Best Practises for Designing the API）

1．当要决定是采用checked exception还是Unchecked exception的时候，你要问自己一个问题，"如果这种异常一旦抛出，客户端会做怎样的补救？"
如果客户端可以通过其他的方法恢复异常，那么这种异常就是checked exception；如果客户端对出现的这种异常无能为力，那么这种异常就是Unchecked exception；从使用上讲，当异常出现的时候要做一些试图恢复它的动作而不要仅仅的打印它的信息，总来的来说，看下表：

Client's reaction when exception happens
Exception type

Client code cannot do anything
Make it an unchecked exception

Client code will take some useful recovery action based on information in exception
Make it a checked exception

此外，尽量使用unchecked exception来处理编程错误：因为unchecked exception不用使客户端代码显示的处理它们，它们自己会在出现的地方挂起程序并打印出异常信息。Java API中提供了丰富的unchecked excetpion，譬如：NullPointerException , IllegalArgumentException 和 IllegalStateException等，因此我一般使用这些标准的异常类而不愿亲自创建新的异常类，这样使我的代码易于理解并避免的过多的消耗内存。

2．保护封装性（Preserve encapsulation）

不要让你要抛出的checked exception升级到较高的层次。例如，不要让SQLException延伸到业务层。业务层并不需要（不关心？）SQLException。你有两种方法来解决这种问题：

l 转变SQLException为另外一个checked exception，如果客户端并不需要恢复这种异常的话；

l 转变SQLException为一个unchecked exception，如果客户端对这种异常无能为力的话；

多数情况下，客户端代码都是对SQLException无能为力的，因此你要毫不犹豫的把它转变为一个unchecked exception，看看下边的代码：
public void dataAccessCode(){
try{
..some code that throws SQLException
}catch(SQLException ex){
ex.printStacktrace();
}
}

上边的catch块紧紧打印异常信息而没有任何的直接操作，这是情有可原的，因为对于SQLException你还奢望客户端做些什么呢？（但是显然这种就象什么事情都没发生一样的做法是不可取的）那么有没有另外一种更加可行的方法呢？

public void dataAccessCode(){
try{
..some code that throws SQLException
}catch(SQLException ex){
throw new RuntimeException(ex);
}
}

上边的做法是把SQLException转换为RuntimeException，一旦SQLException被抛出，那么程序将抛出RuntimeException,此时程序被挂起并返回客户端异常信息。

如果你有足够的信心恢复它当SQLException被抛出的时候，那么你也可以把它转换为一个有意义的checked exception, 但是我发现在大多时候抛出RuntimeException已经足够用了。

3．不要创建没有意义的异常（Try not to create new custom exceptions if they do not have useful information for client code.）

看看下面的代码有什么问题？

public class DuplicateUsernameException
extends Exception {}

它除了有一个"意义明确"的名字以外没有任何有用的信息了。不要忘记Exception跟其他的Java类一样，客户端可以调用其中的方法来得到更多的信息。

我们可以为其添加一些必要的方法，如下：

public class DuplicateUsernameException
extends Exception {
public DuplicateUsernameException
(String username){....}
public String requestedUsername(){...}
public String[] availableNames(){...}
}

在新的代码中有两个有用的方法：reqeuestedUsername(),客户但可以通过它得到请求的名称；availableNames(),客户端可以通过它得到一组有用的usernames。这样客户端在得到其返回的信息来明确自己的操作失败的原因。但是如果你不想添加更多的信息，那么你可以抛出一个标准的Exception:

throw new Exception("Username already taken");
更甚的情况，如果你认为客户端并不想用过多的操作而仅仅想看到异常信息，你可以抛出一个unchecked exception:

throw new RuntimeException("Username already taken");

另外，你可以提供一个方法来验证该username是否被占用。

很有必要再重申一下，checked exception应该让客户端从中得到丰富的信息。要想让你的代码更加易读，请倾向于用unchecked excetpion来处理程序中的错误（Prefer unchecked exceptions for all programmatic errors）。

4． Document exceptions.

你可以通过Javadoc's @throws 标签来说明（document）你的API中要抛出checked exception或者unchecked exception。然而，我更倾向于使用来单元测试来说明（document）异常。不管你采用哪中方式，你要让客户端代码知道你的API中所要抛出的异常。这里有一个用单元测试来测试IndexOutOfBoundsException的例子：

public void testIndexOutOfBoundsException() {
ArrayList blankList = new ArrayList();
try {
blankList.get(10);
fail("Should raise an IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException success) {}
}

上边的代码在请求blankList.get(10)的时候会抛出IndexOutOfBoundsException,如果没有被抛出，将fail ("Should raise an IndexOutOfBoundsException")显示说明该测试失败。通过书写测试异常的单元测试，你不但可以看到异常是怎样的工作的，而且你可以让你的代码变得越来越健壮。

下面作者将介绍界中使用异常的最佳实践（Best Practices for Using Exceptions）
1．总是要做一些清理工作（Always clean up after yourself）

如果你使用一些资源例如数据库连接或者网络连接，请记住要做一些清理工作（如关闭数据库连接或者网络连接），如果你的API抛出Unchecked exception，那么你要用try-finally来做必要的清理工作：

public void dataAccessCode(){
Connection conn = null;
try{
conn = getConnection();
..some code that throws SQLException
}catch(SQLException ex){
ex.printStacktrace();
} finally{
DBUtil.closeConnection(conn);
}
}

class DBUtil{
public static void closeConnection
(Connection conn){
try{
conn.close();
} catch(SQLException ex){
logger.error("Cannot close connection");
throw new RuntimeException(ex);
}
}
}

DBUtil是一个工具类来关闭Connection.有必要的说的使用的finally的重要性是不管程序是否碰到异常，它都会被执行。在上边的例子中，finally中关闭连接，如果在关闭连接的时候出现错误就抛出RuntimeException.

2．不要使用异常来控制流程（Never use exceptions for flow control）

下边代码中，MaximumCountReachedException被用于控制流程：

public void useExceptionsForFlowControl() {
try {
while (true) {
increaseCount();
}
} catch (MaximumCountReachedException ex) {
}
//Continue execution
}

public void increaseCount()
throws MaximumCountReachedException {
if (count >= 5000)
throw new MaximumCountReachedException();
}

上边的useExceptionsForFlowControl()用一个无限循环来增加count直到抛出异常，这种做法并没有说让代码不易读，但是它是程序执行效率降低。

记住，只在要会抛出异常的地方进行异常处理。

3．不要忽略异常

当有异常被抛出的时候，如果你不想恢复它，那么你要毫不犹豫的将其转换为unchecked exception，而不是用一个空的catch块或者什么也不做来忽略它，以至于从表面来看象是什么也没有发生一样。

4．不要捕获顶层的Exception

unchecked exception都是RuntimeException的子类，RuntimeException又继承Exception,因此，如果单纯的捕获Exception,那么你同样也捕获了RuntimeException,如下代码：

try{
..
}catch(Exception ex){
}
一旦你写出了上边的代码（注意catch块是空的），它将忽略所有的异常，包括unchecked exception.

5． Log exceptions just once

Logging the same exception stack trace more than once can confuse the programmer examining the stack trace about the original source of exception. So just log it once.

Frank_Fang 2009-06-18 23:36 发表评论

[转]为什么不鼓励使用 Thread.stop、Thread.suspend和 Thread.resume及解决方法

Frank_Fang — Wed, 10 Jun 2009 13:57:00 GMT

摘要: 为什么不鼓励使用 Thread.stop、Thread.suspend和 Thread.resume及解决方法阅读全文

Frank_Fang 2009-06-10 21:57 发表评论

OWL实例描述

Frank_Fang — Wed, 10 Jun 2009 13:56:00 GMT

http://www.transwiki.org/wiki/index.php/OWL%E6%8C%87%E5%8D%97_%E6%8E%A8%E8%8D%90%E6%A0%87%E5%87%86-4#equivalentClass.2C_equivalentProperty （本体介绍）

http://imarine.blog.163.com/blog/static/5138018320071119110889/（本体查询）

http://bbs.w3china.org/dispbbs.asp?boardID=2&ID=74918/ (本体查询）

-------------------------------------------------------
rdfs:subClassOf 描述

   wine
   vin

Wine PotableLiquid
--------------------------------------------------------
ObjectProperty 描述 wine hasWinDescriptor WineDescriptor

-------------------------------------------------------
DatatypeProperty 描述 VintageYear is 1998

    1998

Vintage has VintageYear that is 1998 ------ 葡萄酒的年份是1998 或 1998的葡萄酒

--------------------------------------------------------
个体(individual) 描述

CabernetSauvignonGrape is WineGrape ---- 赤霞珠葡萄树

----------------------属性特性------------------------
TransitiveProperty 描述
SymmetricProperty 描述

   http://www.w3.org/2002/07/owl#Thing" />

--------------------------------------------
FunctionalProperty 描述一个给定的 Vintage个体只能使用hasVintageYear属性与单独一个年份相关联

---------------------------------------------
inverseOf 描述各种葡萄酒都有制造商

---------------------------------------------
InverseFunctionalProperty

owl:InverseFunctional意味着属性的值域中的元素为定义域中的每个元素提供了一个唯一的标识

---属性限制------
-------------------------
allValuesFrom 描述 Wine的制造商必须是Winery。
owl:someValuesFrom替换owl:allValuesFrom，那就意味着至少有一个Wine类实例的hasMaker属性是指向一个Winery类的个体的。

   ...







   ...

-------------------------------------------------------
owl:cardinality 描述允许对一个关系中的元素数目作出精确的限制

每瓶葡萄酒只有一个年度

-------------------------------------------------------
hasValue 描述一个个体只要至少有“一个”属性值等于hasValue的资源，这一个体就是该类的成员。

   ...

所有的Burgundy酒都是干(dry)的酒。也即，它们的hasSugar属性必须至少有一个是值等于Dry（干的）

------------------------------------------------------
本体映射
类和属性之间的等价关系－－equivalentClass, equivalentProperty

TexasThings指的是那些恰好位于TexasRegion的事物。使用owl:equivalentClass 和使用rdfs:subClassOf 的不同就像必要条件和充要条件的不同一样。如果是使用subClassOf的话，位于TexasRegion的事物不一定是TexasThings。但是，如果使用owl:equivalentClass，位于TexasRegion的事物一定属于TexasThings类。

------------------------------------------------------
个体间的同一性－sameAs

修饰（或引用）两个类用sameAs还是用equivalentClass效果是不同的。用sameAs的时候，把一个类解释为一个个体，就像在OWL Full中一样，这有利于对本体进行分类。

-----------------------------------------------------
不同的个体
------------------------------------------------------
differentFrom

---------------------------------------------------
AllDifferent

owl:distinctMembers属性声明只能和owl:AllDifferent属性声明一起结合使用。

-----------------------------------------------------
intersectionOf

WhiteWine恰好是类Wine与所有颜色是白色的事物的集合的交集

-----------------------------------------------------
unionOf

------------------------------------------------------
complementOf 从某个论域(domain of discourse)选出不属于某个类的所有个体

-----------------------------------------------------------
oneOf 枚举

有效的个体声明

-----------------------------------------------------------
disjointWith 不相交类保证了属于某一个类的个体不能同时又是另一个指定类的实例

Pasta与其它所有类是不相交的。例如，它并没有保证Meat和Fruit是不相交的

Frank_Fang 2009-06-10 21:56 发表评论

Java多线程sleep(),join(),interrupt(),wait(),notify()

Frank_Fang — Mon, 08 Jun 2009 13:01:00 GMT

关于Java多线程知识可以看看《Thinking in Java 》中的多线程部分和《Java网络编程》中第5章多线程的部分

以下是参考<>的
1. sleep() & interrupt()
    线程A正在使用sleep()暂停着: Thread.sleep(100000);
    如果要取消他的等待状态,可以在正在执行的线程里(比如这里是B)调用
        a.interrupt();
    令线程A放弃睡眠操作,这里a是线程A对应到的Thread实例
    执行interrupt()时,并不需要获取Thread实例的锁定.任何线程在任何时刻,都可以调用其他线程interrupt().当sleep中的线程被调用interrupt()时,就会放弃暂停的状态.并抛出InterruptedException.丢出异常的,是A线程.

2. wait() & interrupt()
    线程A调用了wait()进入了等待状态,也可以用interrupt()取消.
    不过这时候要小心锁定的问题.线程在进入等待区,会把锁定解除,当对等待中的线程调用interrupt()时(注意是等待的线程调用其自己的interrupt()),会先重新获取锁定,再抛出异常.在获取锁定之前,是无法抛出异常的.

3. join() & interrupt()
    当线程以join()等待其他线程结束时,一样可以使用interrupt()取消之.因为调用join()不需要获取锁定,故与sleep()时一样,会马上跳到catch块里. 注意是随调用interrupt()方法,一定是阻塞的线程来调用其自己的interrupt方法.如在线程a中调用来线程t.join().则a会等t执行完后在执行t.join后的代码,当在线程b中调用来a.interrupt()方法,则会抛出InterruptedException

4. interrupt()只是改变中断状态而已
    interrupt()不会中断一个正在运行的线程。这一方法实际上完成的是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。
    如果线程没有被阻塞，这时调用interrupt()将不起作用；否则，线程就将得到异常（该线程必须事先预备好处理此状况），接着逃离阻塞状态。
    线程A在执行sleep,wait,join时,线程B调用A的interrupt方法,的确这一个时候A会有InterruptedException异常抛出来.但这其实是在sleep,wait,join这些方法内部会不断检查中断状态的值,而自己抛出的InterruptedException。
    如果线程A正在执行一些指定的操作时如赋值,for,while,if,调用方法等,都不会去检查中断状态,所以线程A不会抛出InterruptedException,而会一直执行着自己的操作.当线程A终于执行到wait(),sleep(),join()时,才马上会抛出InterruptedException.
    若没有调用sleep(),wait(),join()这些方法,或是没有在线程里自己检查中断状态自己抛出InterruptedException的话,那InterruptedException是不会被抛出来的.

顺便加个与Thread.sleep()相同效果的代码:
public static void amethod(long x) throws InterruptedExcetion{
    if (x != 0) {
        Object o = new Object();
        synchronized (o) {
            o.wait(x);
        }
    }
}

Frank_Fang 2009-06-08 21:01 发表评论

正确理解ThreadLocal

Frank_Fang — Tue, 02 Jun 2009 06:18:00 GMT

摘要: ThreadLocal 不是用来解决共享对象的多线程访问问题的阅读全文

Frank_Fang 2009-06-02 14:18 发表评论

ThreadLocal和synchronized

Frank_Fang — Mon, 01 Jun 2009 13:57:00 GMT

摘要: ThreadLocal和synchronized 阅读全文

Frank_Fang 2009-06-01 21:57 发表评论

Java多线程小结

Frank_Fang — Mon, 01 Jun 2009 01:31:00 GMT

摘要: Java多线程小结阅读全文

Frank_Fang 2009-06-01 09:31 发表评论

Java内部类

Frank_Fang — Sun, 24 May 2009 14:52:00 GMT

摘要: 重点理解Java引入内部类的原因以及好处内部类能让你再逻辑上将相互从属的类组织起来，并且在类的内部控制访问权限。但是切记，内部类和合成时截然不同的，这一点非常重要。几个有代表性的代码块接口可以嵌套在类或其它接口中接口的嵌套 Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.Co... 阅读全文

Frank_Fang 2009-05-24 22:52 发表评论

java对象的实例化过程,成员变量的初始化顺序

Frank_Fang — Mon, 11 May 2009 13:16:00 GMT

JAVA中子类对象的实例化过程

Person.java

class Person
{
public String name = "not know";//4
public int age = -1 ;//5
public Person()
{
}
public Person(String name , int age)//3
{
  this.name = name ;//6
  this.age = age;//7
}
public void showInfo()
{
  System.out.println("Name is :"+name+" Age is :"+age);
}
}
class Student extends Person
{
public String school = "not konwn";//8
    public Student()
    {
     super();
    }
    public Student (String name ,int age, String school)  //1
    {
     super(name,age);  //2
     this.school = school;//9
    }
    public void showInfo()
    {
     super.showInfo();
     System.out.println("School is :"+school);
    }
}

AllTest.java

class AllTest
{
public static void main(String[]args)
{
Student stA = new Student("wanghao",20,"qinghuadaxue"); //0
}
}

其语句的执行顺序是怎样的呢？
java中，在使用new操作符创建一个类的实例对象的时候，开始分配空间并将成员变量初始化为默认的数值，注意这里并不是指将变量初始化为在变量定义处的初始值，而是给整形赋值0，给字符串赋值null 这一点于C++不同，（student.name = null , student.age = 0 ）
然后在进入类的构造函数。

在构造函数里面，首先要检查是否有this或者super调用，this调用是完成本类本身的构造函数之间的调用，super调用是完成对父类的调用。二者只能出现一个，并且只能作为构造函数的第一句出现。在调用this和super的时候实现程序的跳转，转而执行被调用的this构造函数或者super构造函数。
在this和super执行完毕，程序转而执行在类定义的时候进行的变量初始化工作。
这个执行完毕，才是构造函数中剩下的代码的执行。
执行顺序已经用绿色标出。

Order of initialization
Within a class, the order of initialization is determined by the order that the variables are defined within the class. The variable definitions may be scattered throughout and in between method definitions, but the variables are initialized before any methods can be called—even the constructor. For example: Feedback
//: c04:OrderOfInitialization.java
// Demonstrates initialization order.
import com.bruceeckel.simpletest.*;

// When the constructor is called to create a
// Tag object, you'll see a message:
class Tag {
Tag(int marker) {
System.out.println("Tag(" + marker + ")");
}
}

class Card {
Tag t1 = new Tag(1); // Before constructor
Card() {
    // Indicate we're in the constructor:
    System.out.println("Card()");
    t3 = new Tag(33); // Reinitialize t3
}
Tag t2 = new Tag(2); // After constructor
void f() {
    System.out.println("f()");
}
Tag t3 = new Tag(3); // At end
}

public class OrderOfInitialization {
static Test monitor = new Test();
public static void main(String[] args) {
    Card t = new Card();
    t.f(); // Shows that construction is done
    monitor.expect(new String[] {
      "Tag(1)",
      "Tag(2)",
      "Tag(3)",
      "Card()",
      "Tag(33)",
      "f()"
    });
}
} ///:~

//: c04:StaticInitialization.java
// Specifying initial values in a class definition.
class Bowl {
Bowl(int marker) {
System.out.println("Bowl(" + marker + ")");
}
void f(int marker) {
System.out.println("f(" + marker + ")");
}
}

class Table {
static Bowl b1 = new Bowl(1);
Table() {
    System.out.println("Table()");
    b2.f(1);
}
void f2(int marker) {
    System.out.println("f2(" + marker + ")");
}
static Bowl b2 = new Bowl(2);
}

class Cupboard {
Bowl b3 = new Bowl(3);
static Bowl b4 = new Bowl(4);
Cupboard() {
    System.out.println("Cupboard()");
    b4.f(2);
}
void f3(int marker) {
    System.out.println("f3(" + marker + ")");
}
static Bowl b5 = new Bowl(5);
}

public class StaticInitialization {
static Test monitor = new Test();
public static void main(String[] args) {
    System.out.println("Creating new Cupboard() in main");
    new Cupboard();
    System.out.println("Creating new Cupboard() in main");
    new Cupboard();
    t2.f2(1);
    t3.f3(1);
    monitor.expect(new String[] {
      "Bowl(1)",
      "Bowl(2)",
      "Table()",
      "f(1)",
      "Bowl(4)",
      "Bowl(5)",
      "Bowl(3)",
      "Cupboard()",
      "f(2)",
      "Creating new Cupboard() in main",
      "Bowl(3)",
      "Cupboard()",
      "f(2)",
      "Creating new Cupboard() in main",
      "Bowl(3)",
      "Cupboard()",
      "f(2)",
      "f2(1)",
      "f3(1)"
    });
}
static Table t2 = new Table();
static Cupboard t3 = new Cupboard();
} ///:~

继承情况下的初始化
了解一下包括继承在内的初始化的过程将是非常有益的，这样就能有个总
体的了解。看看下面这段代码：
//: c06:Beetle.java
// The full process of initialization.
class Insect {
protected static Test monitor = new Test();
private int i = 9;
protected int j;
Insect() {
    System.out.println("i = " + i + ", j = " + j);
    j = 39;
}
private static int x1 = print("static Insect.x1 initialized");
static int print(String s) {
    System.out.println(s);
    return 47;
}
}

public class Beetle extends Insect {
private int k = print("Beetle.k initialized");
public Beetle() {
    System.out.println("k = " + k);
    System.out.println("j = " + j);
}
private static int x2 = print("static Beetle.x2 initialized");
public static void main(String[] args) {
    System.out.println("Beetle constructor");
    Beetle b = new Beetle();
    monitor.expect(new String[] {
      "static Insect.x1 initialized",
      "static Beetle.x2 initialized",
      "Beetle constructor",
      "i = 9, j = 0",
      "Beetle.k initialized",
      "k = 47",
      "j = 39"
    });
}
} ///:~

当你用Java 运行Beetle 的时候，第一件事就是访问了Beetel.main( )(这是一个static 方法)，于是装载器(loader)就会为

你寻找经编译的Beetle 类的代码(也就是Beetle.class 文件)。在装载的过程中，装载器注意到它有一个基类(也就是extends 所要表示的意思)，于是它再装载基类。不管你创不创建基类对象，这个过程总会发生。(试试看，把创建对象的那句注释掉，看看会有什么结果。)如果基类还有基类，那么这第二个基类也会被装载，以此类推。下一步，它会执行“根基类(root bas e class)”(这里就是Insect)的static 初始化，然后是下一个派生类的static 初始化，以此类推。这个顺序非常重要，因为派生类的“静态初始化(即前面讲的static 初始化)”有可能要依赖基类成员的正确初始化。

现在所有必要的类都已经装载结束，可以创建对象了。首先，对象里的所有的primitive 都会被设成它们的缺省值，而reference 也会被设成null——这个过程是一瞬间完成的，对象的内存会被统一地设置成“两进制的零(binary zero)”。如果有对成员变量赋初值，则对成员变量进行赋值，然后调用基类的构造函数。调用是自动发生的，但是你可以使用super 来指定调用哪个构造函数(也就Beetle( )构造函数所做的第一件事)。基类的构造过程以及构造顺序，同派生类的相同。基类构造函数运行完毕之后，会按照各个变量的字面顺序进行初始化。最后会执行构造函数的其余部分。

Frank_Fang 2009-05-11 21:16 发表评论

C++虚函数声明为private也可以实现运行时多态

Frank_Fang — Thu, 07 May 2009 06:02:00 GMT

只有注册用户登录后才能阅读该文。阅读全文

Frank_Fang 2009-05-07 14:02 发表评论

Java方法覆盖Override

Frank_Fang — Thu, 07 May 2009 05:56:00 GMT

只有注册用户登录后才能阅读该文。阅读全文

Frank_Fang 2009-05-07 13:56 发表评论

Java对象的强、软、弱和虚引用

Frank_Fang — Thu, 30 Apr 2009 10:10:00 GMT

只有注册用户登录后才能阅读该文。阅读全文

Frank_Fang 2009-04-30 18:10 发表评论

java try return finally

Frank_Fang — Thu, 30 Apr 2009 08:04:00 GMT

由一个笔试题想到的
try有return,catch也有return,且有finally块
并且finally中对resutl进行的赋值并不影响之前的已经return 的result值
最后返回的result引用还是之前的result引用
finally其实也可以有return，一般eclipse会提示finally block does not complete normally,但不会报错
并且会忽略之前的返回和抛出的异常

package returnfinally;

public class TestReturnAfterFinally {

     public static void main(String[] args) {
      try {
       String result = testException();
       System.out.println();
       System.out.println(result);
      } catch (Exception e) {
      // System.out.println(result);
       System.out.println(e.toString());
      }
     }

    public static String testException() throws Exception {
      String result = "";
      try {
       // if (true) throw new MyException("异常！");
       //int i = 0;
       int i=0;
       int b = 10 / i;
       //函数不会正常的返回,在返回前已经抛出异常了，抛出异常即函数返回了
       /*
        * 相当于catch(Exception e){
        *    throw e;
        * }
        */
       /*
       result="in try";
       return result;
       */
       throw new Exception("h");
      }catch(Exception e){
          System.out.println(e);
          Exception ee = e;
          //throw ee;
          result="in catch";
          return result;
      }
      finally {
       result = "in finally！";
       System.out.println(result);
       //return result;
       //throw new Exception("ex cretated in finally");
      }

      //return result;
     }

    }

Frank_Fang 2009-04-30 16:04 发表评论

java的回调机制

Frank_Fang — Wed, 29 Apr 2009 14:31:00 GMT

只有注册用户登录后才能阅读该文。阅读全文

Frank_Fang 2009-04-29 22:31 发表评论

Java String笔试经常遇到的

Frank_Fang — Wed, 29 Apr 2009 13:04:00 GMT

java.lang.String的intern()方法
"abc".intern()方法的返回值还是字符串"abc"，表面上看起来好像这个方法没什么用处。但实际上，它做了个小动作：
检查字符串池里是否存在"abc"这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会把"abc"添加到字符串池中，然后再返回它的引用。
我们做个测试：
String str1 = "a";
String str2 = "bc";
String str3 = "a"+"bc";
String str4 = str1+str2;

System.out.println(str3==str4);
str4 = (str1+str2).intern();
System.out.println(str3==str4);
输出的结果将会是:
false
true
JDK的api文档是这么解释的：
=======================================================================
返回字符串对象的规范化表示形式。
一个初始时为空的字符串池，它由类 String 私有地维护。
当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。
它遵循对于任何两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。
所有字面值字符串和字符串赋值常量表达式都是内部的。字符串字面值在《Java Language Specification》的 §3.10.5 中已定义。

返回：
一个字符串，内容与此字符串相同，但它保证来自字符串池中。
=======================================================================

字符串字面池指的是常量池.

字符串对象的创建方式有两种

如下:

String s1 = new String(""); //第一种

String s2 = ""; //第二种

第一种始终不会入池的.

第二种要看情况而定(等号右边如果是常量则入池,非常量则不入池)

例:

String s3 = "a" + "b"; //"a"是常量,"b"是常量,常量+常量=常量,所以会入池.

String s4 = s1 + "b"; //s1是变量,"b"是常量,变量+常量!=常量,所以不会入池.
　　　　　　　　　//那引用s4所指的对象在哪里创建??????

一旦入池的话,就会先查找池中有无此对象.如果有此对象,则让对象引用指向此对象;如果无此对象,则先创建此对象,再让对象引用指向此对象.

例:

String s5 = "abc"; //先在池中查找有无"abc"对象,如果有,则让s5指向此对象;如果池中无"abc"对象,则在池中创建一个"abc"对象,然后让s5指向该对象.补充一下：

看了字节码后，发现
String str ="a"+"b";
完全等同于
String str="ab";

-----------------------------------------------------------------------------------------------------------------------------

Java虚拟机有一个字符串池，保存着几乎所有的字符串常量。字符串表达式总是指向字符串池中的一个对象。
public class Test...{
public static void main(String[] args)...{
String s1=new String("abc");
String s2="abc";//放入String池里
String s3=new String("abc");
System.out.println(s1==s2);//false
System.out.println(s1==s3);//false
System.out.println(s3==s2);//false
System.out.println(s1==s1.intern());//s1.intern()到String池里找，而s1是在堆中所以返回false
System.out.println(s2==s2.intern());//true
System.out.println(s1.intern()==s3.intern());//两个字符串同时到String池里查找，返回true

//以下三个都放到String池
String hello="hello";
String hel="hel";
String lo="lo";
System.out.println(hello=="hel"+"lo");//字符串相加以后，会到String池里找，有不产生，所以返回true
System.out.println(hello=="hello");//直接到String池里找，返回true
System.out.println(hello=="hel"+lo);//字符串加一个引用，将产生一个新的对象，所以返回false
System.out.println(hello==(hel+lo));//类似上面，返回false
System.out.println(hello==(hel+lo).intern());//产生新的对象，但是有intern()方法，将到String池中找，返回true
}
}

1package com._6617.fhs.weatherservice;
2
3import java.util.HashSet;
4import java.util.Set;
5
6public class Test {
7
8    /**
9     * @param args
10     */
11    public static void main(String[] args){
37
38        Set set = new HashSet();
39        set.add(new A());
40        set.add(new A());
41        set.add(new A());
42        System.out.println(set.size());
                //主要是看类A是否自己实现了hashcode和equals方法
43
44        String s = new String("abc");
45        System.out.println(s=="abc");//f
46        System.out.println(s=="a"+"bc");//f
47        String t ="abc";
48        System.out.println(s==t);//f
49        String r = "a"+"bc";
50        System.out.println(s==r);//f
51        System.out.println(t==r);//t
52        String u ="a"+new String("bc");
53        System.out.println(s==u);//f
54        System.out.println(r==u);//f
55
56        //String[] s = new String[3,4];
57        System.out.println("--------------");
58        String str1 = "a";
59        String str2 = "bc";
60        String str3 = "a"+"bc";
61        String str4 = str1+str2;
62        String str5 = "a"+str2;
63
64        System.out.println(str3==str4); //f
65        System.out.println(str3==str5); //f
66        System.out.println(str3==str5); //f
67        str4 = (str1+str2).intern();
68        System.out.println(str3==str4); //t
69        System.out.println(str3==str5.intern());//t
70
73
74    }
75
76}
77
78
79
80

Frank_Fang 2009-04-29 21:04 发表评论