2004年7月19日

JDK中的一个有趣的变量命名

命名对于编写代码来说，实在太重要了。良好的命名，起到代码自描述的作用，有时候比注释的效果还要好。

今天在阅读JDK 1.5 Beta2的源码，发现一个有趣的命名：
 //位于java.lang.Enum.class中
 Class clazz = getClass();
 Class zuper = clazz.getSuperclass();

在Java中,class和super都是关键字，如果是我，肯定这样写：
Class type = getClass();
Class superType = getSuperclass();

我因为曾编写过大量的C#代码，习惯使用type来表示类型，转向Java后，大多数编程习惯都已经入乡随俗，但还是习惯使用type类表示Class。

在阅读JDK其他部分代码时，也发现很多地方使用了clazz这样的变量命名

其实也没什么，只不过觉得clazz和zuper这两个变量的命名比较有趣罢了……

posted @ 2004-07-19 22:56 温少 阅读(611) 评论(1) 编辑

一个工具类Pair的实现

Pair类常用，基础类库中也有提供，但是都没有包括HashCode和Equals的处理，恰好需要用，便写了一个，代码如下，HashCode的地方有些拿不准，欢迎大家拍砖！

public class Pair
{
    // Fields
    public object First;
    public object Second;

    // Methods
    public Pair()
    {
    }

    public Pair(object first, object second)
    {
        this.First = first;
        this.Second = second;
    }

    public override int GetHashCode()
    {
        if (First == null)
        {
            return Second != null ? Second.GetHashCode() : 0;
        } else 
        {
            if (Second == null)
            {
                return First.GetHashCode();
            }
            else
            {
                long temp = First.GetHashCode() + Second.GetHashCode();

                //这里有些拿不准，参考JDK Long的实现的，但JDK中使用的无符号有移运算符>>>
                return (int)(temp ^ (temp >> 32)); 
            }
        }
    }

    public override bool Equals(object obj)
    {
        Pair cmpVal = obj as Pair;

        if (cmpVal == null)
        {
            return false;
        }

        if (this.First != null)
        {
            if (!this.First.Equals(cmpVal.First))
            {
                return false;
            }
        }
        else
        {
            if (cmpVal.First != null)
            {
                return false;
            }
        }

        if (this.Second != null)
        {
            return this.Second.Equals(cmpVal.Second);
        }
        else
        {
            return cmpVal.Second == null;
        }
    }

    public static bool operator ==(Pair lhs, Pair rhs)
    {
        if (lhs != null)
        {
            return lhs.Equals(rhs);
        }

        return rhs == null;
    }

    public static bool operator !=(Pair lhs, Pair rhs)
    {
        if (lhs != null)
        {
            return !lhs.Equals(rhs);
        }

        return rhs != null;
    }
}

posted @ 2004-07-19 21:41 温少 阅读(875) 评论(3) 编辑

C++、Java和C#中的异常处理

C++中异常：
1、可以抛出任何异常。虽然标准C++定义了std::exception类，但throw的对象可以是任何对象。包括int、char*等。例如：

throw 100;

try {
 // do something 
} catch (int num) {
 // do something 
}

但是，C++标准库中抛出的所有异常，都是派生自std::exception类。
std::exception定义如下:

class exception {
    public:
        exception( );
        exception(const char *const&);
        exception(const char *const&, int);
        exception(const exception&);
        exception& operator=(const exception&);
        virtual ~exception( );
        virtual const char *what( ) const;
};


2、标准C++中，是没有finally子句。熟悉Java和C#的朋友，也许会觉得奇怪！没有finally子句，使用的确不方便。

3、C++中，函数的声明，缺省时可以抛出任何异常的，也可以使用异常规范来约束函数抛出的异常，如：

//可以抛出任何异常
void f() {
 throw 100;
}

//描述该函数不会抛出任何异常
void f() throw() {
}

//描述该函数会抛出int或者char*类型的异常
void f() throw(int, char*) {
    // do something 
}

但是，C++中的异常规范不是很可靠。如下的代码也是可以编译通过的，但是编译器会给出警告。

void f() throw(int, char*) {
    throw "100";
}


4、C++的异常可以派生自多个异常基类。这一个特性使得难以分类的异常容易处理，例如网络文件的异常：

class file_exception {}
class network_exception {}
class newwork_file_exception : public file_exception, public network_exception {}


5、捕捉所有异常的语法。C++中，不是单根继承的，所以你不能，如同Java或者C#那样，通过捕捉某个基类来捕捉所有的异常。

try {
 // do something 
} catch () { //捕捉所有的异常
 // do something 
}

总结，C++中，命名空间和异常规范是作为针对大规模程序设计而引入的特性。但是由于C++中没有垃圾收集机制，异常造成了资源管理变得非常复杂。在C++中，编写异常安全的代码，是十分困难的。



Java中的异常：
1、可以抛出任何派生自了Throwable的类。Throwable类的定义如下：

public class Throwable implements Serializable {
 public Throwable();
 public Throwable(String message);
 public Throwable(String message, Throwable cause); //@since  1.4
 public Throwable(Throwable cause); //@since  1.4
 public String getMessage();
 public String getLocalizedMessage(); //@since   JDK1.1
 public Throwable getCause(); //@since 1.4
 public synchronized Throwable initCause(Throwable cause); //@since  1.4
 public String toString();
 public void printStackTrace();
 public void printStackTrace(PrintStream s);
 public void printStackTrace(PrintWriter s); //@since   JDK1.1
 private void printStackTraceAsCause(PrintWriter s,
                                        StackTraceElement[] causedTrace);
 public synchronized native Throwable fillInStackTrace(); 
  public StackTraceElement[] getStackTrace(); //@since  1.4
  public void setStackTrace(StackTraceElement[] stackTrace); //@since  1.4
}

Throwable下分Exception和Error。

public class Exception extends Throwable {}
public class Error extends Throwable {}

而Exception中，有一个特别的派生类，RuntimeException，如下：
public class RuntimeException extends Exception {}
类图如下：



2、Java中，也使用异常规范，并且在整个基础类库中都使用。Java是基于JVM运行，但是JVM本身就抛出异常，也就是，所有的方法都可能抛出异常。因此，Java编译器编译不检查Error和RuntimeException。与C++不同，没有异常规范，缺省不允许抛出任何非RuntimeException和Error的异常。如下：

public void f() {
 throw new RuntimeException(); //正确
}

public void f() {
 throw new Error(); //正确
}

以下的代码编译出错

public void f() {
 throw new Exception(); 
}

使用异常规范的正确例子：

public WfException extends Exception {}

public void f() throws WfException {
 throw new WfException();
}


3、Throwable、Exception、RuntimeException中部分成员，是在不同的JDK版本中添加的，编写代码的时候需要注意。如下的代码不能在JDK 1.3中编译通过：

public void f() throws WfException {
 try {
  // do something 
 } catch (Exception e) {
  throw new WfException ("", e);
 }
}


4、Java中的try语法，包括finally子句。如下：

try {
 // do something 
} catch (Exception e) {
 // do something 
} finally {
 // do something 
}

 

C#中的异常：
1、C#异常的局限性。C#是基于CLR运行的，由于CLR需要支持多种语言，其异常的实现受到了较大的局限。一个重要的特征就是没有异常规范，很多人对此很失望！Anders Hejlsberg曾专门发表过文章，说明为什么C#不支持异常规范，说得也很有道理。但是，没有异常规范的C#，变得简单，但也更容易犯错误，在这一点上，我更喜欢Java，而不喜欢C#的方式。没有异常规范，编译器就不会帮我们检查代码，是否做了try ... catch处理。

2、异常的结构。在.NET Framework中，所有的异常派生自System.Exception基类。其下有两个子类：SystemException和ApplicationException。自行编写异常类，不建议直接派生自Exception类，而是应该派生自ApplicationException。

3、C#犹如Java，也支持finally的写法。如：

try 
{
 // do something 
} 
catch (Exception e) 
{
 // do something 
} 
finally 
{
 // do something 
}

posted @ 2004-07-19 21:06 温少 阅读(2331) 评论(4) 编辑

名言警句

爱恩斯坦：
“时间是一架筛子，大多数一时耸人听闻的东西都已通过筛子，落进了默默无闻的海洋，即使是筛剩下来的，也不值得一提。”

评述：这么多年过去了，最喜欢的还是这一句。所有悲伤和欢喜，爱情与憎恨，都随着时间的过去而消逝！

皮埃尔·S·杜邦（1790）：

“先生们，尖刻的讨论很容易将人们引导到这样一种令人讨厌的习惯上去：即假定别人动机不良。在动机问题上宽宏大量是非常必要的；应该相信人们的本意都是好的，而且的确是这样。不高明的逻辑学家不自觉地犯下的罪过，比坏人有意地去干的还要多。”

评述：这段话说得太精彩！当被人质疑，产生愤恨之时，这句话如雷贯耳！

亚当·斯密,《国富论》(1776)：

“人人都善用他的资本以取得最大的收获。他既无意促进公共的利益，也对自己实际上为公共利益所作的贡献一无所知。他只知道关注自己的安全、自己的收获。而他就在这个过程中被一双看不见的手牵引着，为他所毫无察觉的目标作出了一份贡献。他追求自己的利益时所增进的公共利益，往往比他刻意这样做时要更大。”

评述：大学学的专业就是政治学，但一直没有读过亚当·斯密的《国富论》，实在是一件遗憾的事情。我对上述论点，深信不疑！！

《简明不列颠百科全书·死亡》：

死亡将生命力耗竭的生物移向自然循环的另一时相。因此，死亡的生物学意义在于它是自然界改进生物型式的一种手段，为自然选择提供一个机会来进行生物进化的新实验。

评述：死亡，似乎是一件普通而自然的事情。

posted @ 2004-07-19 07:51 温少 阅读(1839) 评论(0) 编辑