BlogJava-爱女孩的小火柴-文章分类-java

Java程序异常处理的特殊情况ZT

my — Tue, 19 Jun 2007 08:25:00 GMT

1、不能在finally块中执行return,continue等语句，否则会把异常“吃掉”;

　　2、在try，catch中如果有return语句，则在执行return之前先执行finally块

　　请大家仔细看下面的例子：

以下是引用片段：
public class TryTest {
    public static void main(String[] args) {
        try {
            System.out.println(TryTest.test());// 返回结果为true其没有任何异常
        } catch (Exception e) {
            System.out.println("Exception from main");
            e.printStackTrace();
        }
        doThings(0);
    }

    public static boolean test() throws Exception {
        try {
            throw new Exception("Something error");// 第1步.抛出异常
        } catch (Exception e) {// 第2步.捕获的异常匹配(声明类或其父类），进入控制块
            System.out.println("Exception from e");// 第3步.打印
            return false;// 第5步. return前控制转移到finally块,执行完后再返回（这一步被吃掉了，不执行）
        } finally {
            return true; // 第4步. 控制转移，直接返回，吃掉了异常
        }
    }

    public static void doThings(int i)
    {
     try
     {
      if(i==0)
      {
       //在执行return之前会先执行finally
       return;
      }
      int t=100/i;
      System.out.println(t);
     }catch(Exception ex)
     {
      ex.printStackTrace();
     }
     finally
     {
      System.out.println("finally");
     }
    }
}

my 2007-06-19 16:25 发表评论

对synchronized(this)的一些理解 ZT

my — Fri, 08 Jun 2007 09:12:00 GMT

synchronized
　　Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.

举例说明：

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

package ths;

public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();
}
}

结果：

A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4

二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

package ths;

public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt2.m4t1();
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt2.m4t2();
}
}, "t2"
);
t1.start();
t2.start();
}
}

结果：

t1 : 4
t2 : 4
t1 : 3
t2 : 3
t1 : 2
t2 : 2
t1 : 1
t2 : 1
t1 : 0
t2 : 0

三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

//修改Thread2.m4t2()方法：

public void m4t2() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}

}

结果：

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

//修改Thread2.m4t2()方法如下：

public synchronized void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}

结果：

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

五、以上规则对其它对象锁同样适用:

package ths;

public class Thread3 {
class Inner {
private void m4t1() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
private void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
}
private void m4t1(Inner inner) {
synchronized(inner) { //使用对象锁
inner.m4t1();
}
}
private void m4t2(Inner inner) {
inner.m4t2();
}
public static void main(String[] args) {
final Thread3 myt3 = new Thread3();
final Inner inner = myt3.new Inner();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt3.m4t1(inner);
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt3.m4t2(inner);
}
}, "t2"
);
t1.start();
t2.start();
}
}

结果：

尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。

t1 : Inner.m4t1()=4
t2 : Inner.m4t2()=4
t1 : Inner.m4t1()=3
t2 : Inner.m4t2()=3
t1 : Inner.m4t1()=2
t2 : Inner.m4t2()=2
t1 : Inner.m4t1()=1
t2 : Inner.m4t2()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=0

现在在Inner.m4t2()前面加上synchronized：

private synchronized void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}

结果：

尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法。

t1 : Inner.m4t1()=4
t1 : Inner.m4t1()=3
t1 : Inner.m4t1()=2
t1 : Inner.m4t1()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=4
t2 : Inner.m4t2()=3
t2 : Inner.m4t2()=2
t2 : Inner.m4t2()=1
t2 : Inner.m4t2()=0

my 2007-06-08 17:12 发表评论

Java同步机制浅谈――synchronized ZT

my — Fri, 08 Jun 2007 09:09:00 GMT

Java对多线程的支持与同步机制深受大家的喜爱，似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如何？――还得对synchronized关键字的作用进行深入了解才可定论。

总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。

在进一步阐述之前，我们需要明确几点：

A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。

B．每个对象只有一个锁（lock）与之相关联。

C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

接着来讨论synchronized用到不同地方对代码产生的影响：

假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都可以调用它们。

1．把synchronized当作函数修饰符时，示例代码如下：

Public synchronized void methodAAA()

{

//….

}

这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。

上边的示例代码等同于如下代码：

public void methodAAA()

{

synchronized (this) // (1)

{

//…..

}

(1)处的this指的是什么呢？它指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：（

2．同步块，示例代码如下：

public void method3(SomeObject so)

{

synchronized(so)

{

//…..

}

这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：

class Foo implements Runnable

{

private byte[] lock = new byte[0]; // 特殊的instance变量

Public void methodA()

{

synchronized(lock) { //… }

}

//…..

}

注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。

3．将synchronized作用于static 函数，示例代码如下：

Class Foo

{

public synchronized static void methodAAA() // 同步的static 函数

{

//….

}

public void methodBBB()

{

synchronized(Foo.class) // class literal(类名称字面常量)

}

代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。

记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不一样，不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。

可以推断：如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，因为它们的锁都不一样。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。

小结如下：

搞清楚synchronized锁定的是哪个对象，就能帮助我们设计更安全的多线程程序。

还有一些技巧可以让我们对共享资源的同步访问更加安全：

1．定义private 的instance变量+它的 get方法，而不要定义public/protected的instance变量。如果将变量定义为public，对象在外界可以绕过同步方法的控制而直接取得它，并改动它。这也是JavaBean的标准实现方式之一。

2．如果instance变量是一个对象，如数组或ArrayList什么的，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。这个时候就需要将get方法也加上synchronized同步，并且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了。

my 2007-06-08 17:09 发表评论

转 Java RunTime类

my — Fri, 08 Jun 2007 04:02:00 GMT

RunTime

Java的类库日益庞大，所包含的类和接口也不计其数。但其中有一些非常重要的类和接口，是Java类库中的核心部分。常见的有String、Object、Class、Collection、ClassLoader、Runtime、Process...，熟悉这些类是学好Java的基础。而这些类一般不容易理解，需要做深入的研究和实践才能掌握。下面是我对这些类理解和使用的一些总结。欢迎你在阅读后将你宝贵的意见和读后感留下！

leizhimin 51cto技术博客

leizhimin 51cto技术博客
一、概述
      Runtime类封装了运行时的环境。每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
      一般不能实例化一个Runtime对象，应用程序也不能创建自己的 Runtime 类实例，但可以通过 getRuntime 方法获取当前Runtime运行时对象的引用。
      一旦得到了一个当前的Runtime对象的引用，就可以调用Runtime对象的方法去控制Java虚拟机的状态和行为。
      当Applet和其他不被信任的代码调用任何Runtime方法时，常常会引起SecurityException异常。

leizhimin 51cto技术博客

leizhimin 51cto技术博客
二、API预览
    addShutdownHook(Thread hook)
      注册新的虚拟机来关闭挂钩。
    availableProcessors()
      向 Java 虚拟机返回可用处理器的数目。
    exec(String command)
      在单独的进程中执行指定的字符串命令。
    exec(String[] cmdarray)
      在单独的进程中执行指定命令和变量。
    exec(String[] cmdarray, String[] envp)
      在指定环境的独立进程中执行指定命令和变量。
    exec(String[] cmdarray, String[] envp, File dir)
      在指定环境和工作目录的独立进程中执行指定的命令和变量。
    exec(String command, String[] envp)
      在指定环境的单独进程中执行指定的字符串命令。
    exec(String command, String[] envp, File dir)
      在有指定环境和工作目录的独立进程中执行指定的字符串命令。
    exit(int status)
      通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机。
    freeMemory()
      返回 Java 虚拟机中的空闲内存量。
    gc()
      运行垃圾回收器。
    InputStream getLocalizedInputStream(InputStream in)
      已过时。从 JDK 1.1 开始，将本地编码字节流转换为 Unicode 字符流的首选方法是使用 InputStreamReader 和 BufferedReader 类。
    OutputStream getLocalizedOutputStream(OutputStream out)
      已过时。从 JDK 1.1 开始，将 Unicode 字符流转换为本地编码字节流的首选方法是使用 OutputStreamWriter、BufferedWriter 和 PrintWriter 类。
    getRuntime()
      返回与当前 Java 应用程序相关的运行时对象。
    halt(int status)
      强行终止目前正在运行的 Java 虚拟机。
    load(String filename)
      加载作为动态库的指定文件名。
    loadLibrary(String libname)
      加载具有指定库名的动态库。
    maxMemory()
      返回 Java 虚拟机试图使用的最大内存量。
    removeShutdownHook(Thread hook)
      取消注册某个先前已注册的虚拟机关闭挂钩。
    runFinalization()
      运行挂起 finalization 的所有对象的终止方法。
    runFinalizersOnExit(value)
      已过时。此方法本身具有不安全性。它可能对正在使用的对象调用终结方法，而其他线程正在操作这些对象，从而导致不正确的行为或死锁。
    totalMemory()
      返回 Java 虚拟机中的内存总量。
    traceInstructions(on)
      启用／禁用指令跟踪。
    traceMethodCalls(on)
      启用／禁用方法调用跟踪。

leizhimin 51cto技术博客

leizhimin 51cto技术博客
三、常见的应用

leizhimin 51cto技术博客
1、内存管理：
Java提供了无用单元自动收集机制。通过totalMemory()和freeMemory()方法可以知道对象的堆内存有多大，还剩多少。
Java会周期性的回收垃圾对象（未使用的对象），以便释放内存空间。但是如果想先于收集器的下一次指定周期来收集废弃的对象，可以通过调用gc()方法来根据需要运行无用单元收集器。一个很好的试验方法是先调用gc()方法，然后调用freeMemory()方法来查看基本的内存使用情况，接着执行代码，然后再次调用freeMemory()方法看看分配了多少内存。下面的程序演示了这个构想。

leizhimin 51cto技术博客
//此实例来自《java核心技术》卷一
class MemoryDemo{
    public static void main(String args[]){
        Runtime r = Runtime.getRuntime();
        long mem1,mem2;
        Integer someints[] = new Integer[1000];
        System.out.println("Total memory is ：" + r.totalMemory());
        mem1 = r.freeMemory();
        System.out.println("Initial free is : " + mem1);
        r.gc();
        mem1 = r.freeMemory();
        System.out.println("Free memory after garbage collection : " + mem1);
        //allocate integers
        for(int i=0; i<1000; i++) someints[i] = new Integer(i);

leizhimin 51cto技术博客
        mem2 = r.freeMemory();
        System.out.println("Free memory after allocation : " + mem2);
        System.out.println("Memory used by allocation : " +(mem1-mem2));

leizhimin 51cto技术博客
        //discard Intergers
        for(int i=0; i<1000; i++) someints[i] = null;
        r.gc(); //request garbage collection
        mem2 = r.freeMemory();
        System.out.println("Free memory after collecting " + "discarded integers : " + mem2);
    }
}

leizhimin 51cto技术博客
编译后运行结果如下（不同的机器不同时间运行的结果也不一定一样）：
Total memory is ：2031616
Initial free is : 1818488
Free memory after garbage collection : 1888808
Free memory after allocation : 1872224
Memory used by allocation : 16584
Free memory after collecting discarded integers : 1888808

leizhimin 51cto技术博客

leizhimin 51cto技术博客
2、执行其他程序
在安全的环境中，可以在多任务操作系统中使用Java去执行其他特别大的进程（也就是程序）。ecec()方法有几种形式命名想要运行的程序和它的输入参数。ecec()方法返回一个Process对象，可以使用这个对象控制Java程序与新运行的进程进行交互。ecec()方法本质是依赖于环境。
下面的例子是使用ecec()方法启动windows的记事本notepad。这个例子必须在Windows操作系统上运行。

leizhimin 51cto技术博客
//此实例来自《Java核心技术》卷一
class ExecDemo {
    public static void main(String args[]){
        Runtime r = Runtime.getRuntime();
        Process p = null;
        try{
            p = r.exec("notepad");
        } catch (Exception e) {
            System.out.println("Error executing notepad.");
        }
    }
}

leizhimin 51cto技术博客
ecec()还有其他几种形式，例子中演示的是最常用的一种。ecec()方法返回Process对象后，在新程序开始运行后就可以使用Process的方法了。可以用destory()方法杀死子进程，也可以使用waitFor()方法等待程序直到子程序结束，exitValue()方法返回子进程结束时返回的值。如果没有错误，将返回0，否则返回非0。下面是关于ecec()方法的例子的改进版本。例子被修改为等待，直到运行的进程退出：

leizhimin 51cto技术博客
//此实例来自《Java核心技术》卷一
class ExecDemoFini {
    public static void main(String args[]){
        Runtime r = Runtime.getRuntime();
        Process p = null;
        try{
            p = r.exec("notepad");
            p.waitFor();
        } catch (Exception e) {
            System.out.println("Error executing notepad.");
        }
        System.out.println("Notepad returned " + p.exitValue());
    }
}
下面是运行的结果（当关闭记事本后，会接着运行程序，打印信息）：
Notepad returned 0
请按任意键继续. . .

当子进程正在运行时，可以对标准输入输出进行读写。getOutputStream()方法和getInPutStream()方法返回对子进程的标准输入和输出。

my 2007-06-08 12:02 发表评论

Java程序员面试三十二问

my — Wed, 30 May 2007 03:24:00 GMT

第一，谈谈final， finally， finalize的区别。
第二，Anonymous Inner Class （匿名内部类）是否可
以extends（继承）其它类，是否可以
implements（实现）interface（接口）？
第三，Static Nested Class 和 Inner Class的不同，说得
越多越好（面试题有的很笼统）。
第四，&和&&的区别。
第五，HashMap和Hashtable的区别。
第六，Collection 和 Collections的区别。
第七，什么时候用assert.
第八，GC是什么？为什么要有GC？
第九，String s = new String（"xyz"）；创建了几个String
Object？
第十，Math.round（11.5）等於多少？
Math.round（-11.5）等於多少？
第十一，short s1 = 1； s1 = s1 + 1；有什么错？ short
s1 = 1； s1 += 1；有什么错？
第十二，sleep（）和 wait（）有什么区别？
第十三，Java有没有goto？
第十四，数组有没有length（）这个方法？ String有没
有length（）这个方法？
第十五，Overload和Override的区别。Overloaded的方
法是否可以改变返回值的类型？
第十六，Set里的元素是不能重复的，那么用什么方法
来区分重复与否呢？是用==还是equals（）？
它们有何区别？
第十七，给我一个你最常见到的runtime exception.
第十八，error和exception有什么区别？
第十九，List， Set， Map是否继承自Collection接口？
第二十，abstract class和interface有什么区别？
第二十一，abstract的method是否可同时是static，是否
可同时是native，是否可同时是
synchronized？
第二十二，接口是否可继承接口？抽象类是否可实现（
implements）接口？抽象类是否可继承实体
类（concrete class）？
第二十三，启动一个线程是用run（）还是start（）？
第二十四，构造器Constructor是否可被override？
第二十五，是否可以继承String类？
第二十六，当一个线程进入一个对象的一
个synchronized方法后，其它线程是否可进入此对象的其它
方法？
第二十七，try {}里有一个return语句，那么紧跟在这
个try后的finally {}里的code会不会被执行
，什么时候被执行，在return前还是后？
第二十八，编程题：用最有效率的方法算出2乘以8等於
几？
第二十九，两个对象值相同（x.equals（y） == true），
但却可有不同的hash code，这句话对不对
？
第三十，当一个对象被当作参数传递到一个方法后，此
方法可改变这个对象的属性，并可返回变化后
的结果，那么这里到底是值传递还是引用传递？
第三十一，swtich是否能作用在byte上，是否能作用
在long上，是否能作用在String上？
第三十二，编程题：写一个Singleton出来。
以下是答案
第一，谈谈final， finally， finalize的区别。
final？修饰符（关键字）如果一个类被声明为final，意
味着它不能再派生出新的子类，不能作为父类被继承。因此
一个类不能既被声明为 abstract的，又被声明为final的。将
变量或方法声明为final，可以保证它们在使用中不被改变。
被声明为final的变量必须在声明时给定初值，而在以后的引
用中只能读取，不可修改。被声明为final的方法也同样只能
使用，不能重载。finally？再异常处理时提供 finally 块来执行
任何清除操作。如果抛出一个异常，那么相匹配的 catch 子
句就会执行，然后控制就会进入 finally 块（如果有的话）。
finalize？方法名。Java 技术允许使用 finalize（）方法在垃
圾收集器将对象从内存中清除出去之前做必要的清理工作。
这个方法是由垃圾收集器在确定这个对象没有被引用时对这
个对象调用的。它是在 Object 类中定义的，因此所有的类
都继承了它。子类覆盖 finalize（）方法以整理系统资源或
者执行其他清理工作。finalize（）方法是在垃圾收集器删
除对象之前对这个对象调用的。
第二，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;
第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1
+= 1;有什么错?
short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不
能显式转化为short型。可修改为 s1 =(short)(s1 + 1) 。short
s1 = 1; s1 += 1正确。
第十二，sleep() 和 wait() 有什么区别? 搞线程的最爱
sleep()方法是使线程停止一段时间的方法。在sleep 时间间
隔期满后，线程不一定立即恢复执行。这是因为在那个时刻
，其它线程可能正在运行而且没有被调度为放弃执行，除
非(a)"醒来"的线程具有更高的优先级，(b)正在运行的线程因
为其它原因而阻塞。
wait()是线程交互时，如果线程对一个同步对象x 发出一
个wait()调用，该线程会暂停执行，被调对象进入等待状态，
直到被唤醒或等待时间到。
第十三，Java有没有goto?
Goto?java中的保留字，现在没有在java中使用。
第十四，数组有没有length()这个方法? String有没有length()
这个方法？
数组没有length()这个方法，有length的属性。
String有有length()这个方法。

第十五，Overload和Override的区别。Overloaded的方法是
否可以改变返回值的类型?
方法的重写Overriding和重载Overloading是Java多态性的不
同表现。重写Overriding是父类与子类之间多态性的一种表
现，重载Overloading是一个类中多态性的一种表现。如果在
子类中定义某方法与其父类有相同的名称和参数，我们说该
方法被重写 (Overriding)。子类的对象使用这个方法时，将调
用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了
。如果在一个类中定义了多个同名的方法，它们或有不同的
参数个数或有不同的参数类型，则称为方法的重
载(Overloading)。Overloaded的方法是可以改变返回值的类
型。
第十六，Set里的元素是不能重复的，那么用什么方法来区
分重复与否呢? 是用==还是equals()? 它们有何区别?
Set里的元素是不能重复的，那么用iterator()方法来区分重复
与否。equals()是判读两个Set是否相等。
equals()和==方法决定引用值是否指向同一对象equals()在类
中被覆盖，为的是当两个分离的对象的内容和类型相配的话
，返回真值。
第十七，给我一个你最常见到的runtime exception。
ArithmeticException, ArrayStoreException,
BufferOverflowException,
BufferUnderflowException, CannotRedoException,
CannotUndoException, ClassCastException,
CMMException, ConcurrentModificationException,
DOMException, EmptyStackException,
IllegalArgumentException, IllegalMonitorStateException,
IllegalPathStateException,
IllegalStateException, ImagingOpException,
IndexOutOfBoundsException,
MissingResourceException, NegativeArraySizeException,
NoSuchElementException,
NullPointerException, ProfileDataException,
ProviderException, RasterFormatException,
SecurityException, SystemException,
UndeclaredThrowableException, UnmodifiableSetException,
UnsupportedOperationException
第十八，error和exception有什么区别?
error 表示恢复不是不可能但很困难的情况下的一种严重问题
。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果
程序运行正常，从不会发生的情况。
第十九，List, Set, Map是否继承自Collection接口?
List，Set是
Map不是
第二十，abstract class和interface有什么区别?
声明方法的存在而不去实现它的类被叫做抽象类（abstract
class），它用于要创建一个体现某些基本行为的类，并为该
类声明方法，但不能在该类中实现该类的情况。不能创
建abstract 类的实例。然而可以创建一个变量，其类型是一
个抽象类，并让它指向具体子类的一个实例。不能有抽象构
造函数或抽象静态方法。Abstract 类的子类为它们父类中的
所有抽象方法提供实现，否则它们也是抽象类为。取而代之
，在子类中实现该方法。知道其行为的其它类可以在类中实
现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都
是抽象的。多继承性可通过实现这样的接口而获得。接口中
的所有方法都是抽象的，没有一个有程序体。接口只可以定
义static final成员变量。接口的实现与子类相似，除了该实现
类不能从接口定义中继承行为。当类实现特殊接口时，它定
义（即将程序体给予）所有这种接口的方法。然后，它可以
在实现了该接口的类的任何对象上调用接口的方法.由于有抽
象类，它允许使用接口名作为引用变量的类型。通常的动态
联编将生效。引用可以转换到接口类型或从接口类型转
换，instanceof 运算符可以用来决定某对象的类是否实现了
接口。
第二十一，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; }
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的
。
一般认为第一种形式要更加安全些
第三十三 Hashtable和HashMap
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的
Map interface的一个实现
HashMap允许将null作为一个entry的key或
者value，而Hashtable不允许
还有就是，HashMap把Hashtable的contains方法去掉了，改
成containsvalue和containsKey。因为 contains方法容易让人
引起误解。
最大的不同是，Hashtable的方法
是Synchronize的，而HashMap不是，在多个线程访
问Hashtable时，不需要自己为它的方法实现同
步，而HashMap就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，
所以性能不会有很大的差异

my 2007-05-30 11:24 发表评论

详细解析Java中抽象类和接口的区别转帖

my — Wed, 30 May 2007 02:07:00 GMT

在Java语言中， abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。其实，两者之间还是有很大的区别的，对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析，试图给开发者提供一个在二者之间进行选择的依据。

理解抽象类
abstract class和interface在Java语言中都是用来进行抽象类（本文中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分）定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢？

在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。

在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。

从语法定义层面看abstract class 和 interface
在语法层面，Java语言对于abstract class和interface给出了不同的定义方式，下面以定义一个名为Demo的抽象类为例来说明这种不同。

使用abstract class的方式定义Demo抽象类的方式如下：

abstract class Demo｛
     abstract void method1();
     abstract void method2();
     …
｝

使用interface的方式定义Demo抽象类的方式如下：

interface Demo{
     void method1();
     void method2();
     …
}

在abstract class方式中，Demo可以有自己的数据成员，也可以有非 abstract的成员方法，而在interface方式的实现中，Demo只能够有静态的不能被修改的数据成员（也就是必须是static final 的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的 abstract class。

从编程的角度来看，abstract class和interface都可以用来实现 "design by contract" 的思想。但是在具体的使用上面还是有一些区别的。

首先，abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系(因为Java不支持多继承 -- 转注)。但是，一个类却可以实现多个interface。也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。

其次，在abstract class的定义中，我们可以赋予方法的默认行为。但是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，但是这会增加一些复杂性，有时会造成很大的麻烦。

在抽象类中不能定义默认行为还存在另一个比较严重的问题，那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面（一般通过 abstract class 或者interface来表示）以适应新的情况（比如，添加新的方法或者给已用的方法中添加新的参数）时，就会非常的麻烦，可能要花费很多的时间（对于派生类很多的情况，尤为如此）。但是如果界面是通过abstract class来实现的，那么可能就只需要修改定义在abstract class中的默认行为就可以了。

同样，如果不能在抽象类中定义默认行为，就会导致同样的方法实现出现在该抽象类的每一个派生类中，违反了 "one rule，one place" 原则，造成代码重复，同样不利于以后的维护。因此，在abstract class和interface间进行选择时要非常的小心。

从设计理念层面看 abstract class 和 interface
上面主要从语法定义和编程的角度论述了abstract class和interface的区别，这些层面的区别是比较低层次的、非本质的。本小节将从另一个层面：abstract class和interface所反映出的设计理念，来分析一下二者的区别。作者认为，从这个层面进行分析才能理解二者概念的本质所在。

前面已经提到过，abstract class在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a"关系，即父类和派生类在概念本质上应该是相同的（参考文献〔3〕中有关于"is-a"关系的大篇幅深入的论述，有兴趣的读者可以参考）。对于interface来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。为了使论述便于理解，下面将通过一个简单的实例进行说明。

考虑这样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：

使用abstract class方式定义Door：

abstract class Door{
abstract void open();
abstract void close()；
}

使用interface方式定义Door：

interface Door{
void open();
void close();
}

其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示 abstract class 和interface 反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）？下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。

解决方案一：

简单的在Door的定义中增加一个alarm方法，如下：

abstract class Door{
     abstract void open();
     abstract void close()；
     abstract void alarm();
}

或者

interface Door{
     void open();
     void close();
     void alarm();
}

那么具有报警功能的AlarmDoor的定义方式如下：

class AlarmDoor extends Door{
     void open(){…}
     void close(){…}
     void alarm(){…}
}

或者

class AlarmDoor implements Door｛
     void open(){…}
     void close(){…}
     void alarm(){…}
｝

这种方法违反了面向对象设计中的一个核心原则 ISP (Interface Segregation Principle)，在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变（比如：修改alarm方法的参数）而改变，反之依然。

解决方案二：

既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用 abstract class 方式定义；两个概念都使用interface方式定义；一个概念使用 abstract class 方式定义，另一个概念使用interface方式定义。

显然，由于Java语言不支持多重继承，所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

如果两个概念都使用interface方式来定义，那么就反映出两个问题：1、我们可能没有理解清楚问题领域，AlarmDoor在概念本质上到底是Door还是报警器？2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么我们在实现时就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上（均使用 interface方式定义）反映不出上述含义。

如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在Java语言中表示一种继承关系，而继承关系在本质上是"is-a"关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：

abstract class Door{
     abstract void open();
     abstract void close()；
}
interface Alarm{
     void alarm();
}
class Alarm Door extends Door implements Alarm{
     void open(){…}
     void close(){…}
     void alarm(){…}
}

这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。

小结
1.abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。
2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。
3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。
4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。
5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。
6.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。
7.接口中的方法默认都是 public,abstract 类型的。
结论

abstract class 和 interface 是 Java语言中的两种定义抽象类的方式，它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理，因为它们表现了概念间的不同的关系（虽然都能够实现需求的功能）。这其实也是语言的一种的惯用法，希望读者朋友能够细细体会。

参考文献
[1] Thinking in Java, Bruce Eckel
[2] Design Patterns Explained: A New Perspective on Object-Oriented Design, Alan Shalloway and James R. Trott
[3] Effective C++: 50 Specific Ways to Improve Your Programs and Design, Scott Meyers

my 2007-05-30 10:07 发表评论

区分引用类型和原始类型

my — Tue, 29 May 2007 03:35:00 GMT

Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。另外，Java 还为每个原始类型提供了封装类(Wrapper)。如果需要一个整型变量，是使用基本的 int 型呢，还是使用 Integer 类的一个对象呢？如果需要声明一个布尔类型，是使用基本的 boolean，还是使用Boolean 类的一个对象呢？本文可帮助您作出决定。

下面列出了原始类型以及它们的对象封装类。

原始类型封装类
booleanBoolean
char Character
byte Byte
shortShort
intInteger
long Long
floatFloat
double Double

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。例如，假定一个方法中有两个局部变量，一个变量为 int 原始类型，另一个变量是对一个 Integer 对象的对象引用：

int i = 5; // 原始类型
Integer j = new Integer(10); // 对象引用

这两个变量都存储在局部变量表中，并且都是在 Java 操作数堆栈中操作的，但对它们的表示却完全不同。（本文中以下部分将用通用术语堆栈代替操作数堆栈或局部变量表。）原始类型 int 和对象引用各占堆栈的 32 位。（要表示一个 int 或一个对象引用，Java 虚拟机实现至少需要使用 32 位存储。）Integer 对象的堆栈项并不是对象本身，而是一个对象引用。

Java 中的所有对象都要通过对象引用访问。对象引用是指向对象存储所在堆中的某个区域的指针。当声明一个原始类型时，就为类型本身声明了存储。前面的两行代码表示如下：

引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。

许多程序的代码将同时包含原始类型以及它们的对象封装。当检查它们是否相等时，同时使用这两种类型并了解它们如何正确相互作用和共存将成为问题。程序员必须了解这两种类型是如何工作和相互作用的，以避免代码出错。

例如，不能对原始类型调用方法，但可以对对象调用方法：

int j = 5;
j.hashCode(); // 错误
//...
Integer i = new Integer(5);
i.hashCode(); // 正确

使用原始类型无须调用 new，也无须创建对象。这节省了时间和空间。混合使用原始类型和对象也可能导致与赋值有关的意外结果。看起来没有错误的代码可能无法完成您希望做的工作。例如：

import java.awt.Point;
class Assign
{
public static void main(String args)
{
   int a = 1;
   int b = 2;
   Point x = new Point(0,0);
   Point y = new Point(1,1);                  // 1
   System.out.println("a is " + a);
   System.out.println("b is " + b);
   System.out.println("x is " + x);
   System.out.println("y is " + y);
   System.out.println("Performing assignment and " +
                      "setLocation...");
   a = b;
   a++;
   x = y;                                    // 2
   x.setLocation(5,5);                       // 3
   System.out.println("a is "+a);
   System.out.println("b is "+b);
   System.out.println("x is "+x);
   System.out.println("y is "+y);
}
}

这段代码生成以下输出：

a is 1
b is 2
x is java.awt.Point
y is java.awt.Point
Performing assignment and setLocation...
a is 3
b is 2
x is java.awt.Point
y is java.awt.Point

修改整数 a 和 b 的结果没什么意外的地方。b 的值被赋予整型变量 a，结果 a 的值增加了 1。这一输出反映了我们希望发生的情况。但是，令人感到意外的，是在赋值并调用 setLocation之后 x 和 y 对象的输出。我们在完成 x = y 赋值之后特意对 x 调用了 setLocation，x 和 y 的值怎么会相同呢？我们毕竟将 y 赋予 x，然后更改了 x，这与我们对整数 a 和 b 进行的操作没什么不同。

这种混淆是由原始类型和对象的使用造成的。赋值对这两种类型所起的作用没什么不同。但它可能看起来所有不同。赋值使等号 (=) 左边的值等于右边的值。这一点对于原始类型（如前面的 int a 和 b）是显而易见的。对于非原始类型（如 Point 对象），赋值修改的是对象引用，而不是对象本身。因此，在语句 x = y; 之后，x 等于 y。换句话说，因为 x 和 y 是对象引用，它们现在引用同一个对象。因此，对 x 所作的任何更改也会更改 y。

因为 x 和 y 引用同一个对象，所以对 x 执行的所有方法与对 y 执行的方法都作用于同一个对象。

区分引用类型和原始类型并理解引用的语义是很重要的。若做不到这一点，则会使编写的代码无法完成预定工作。

=========================================================================

Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java

为每个原始类型提供了封装类。
原始类型封装类,booleanBoolean,charCharacter,byteByte,shortShort,intInteger,longLong,floatFloat,doubleDouble
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，

这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，

而原始类型实例变量的缺省值与它们的类型有关

在java中一切都是以类为基础的，并且java对基本的数据类型也进行了封装，如下所示，将介绍几个基本的数据类型及其封装类：

1 Boolean VS boolean

public final class Boolean
extends Object
implements Serializable, Comparable<Boolean>
extends Object
implements Serializable, Comparable<Boolean>

Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。

此外，此类还为 boolean 和 String 的相互转换提供了许多方法，并提供了处理 boolean 时非常有用的其他一些常量和方法。
.............
Byte ，Character ，Double 等等都是一样

表A Java原始数据类型

简单类型大小范围/精度

float 4 字节 32位IEEE 754单精度

double 8 字节 64位IEEE 754双精度

byte 1字节 -128到127

short 2 字节 -32,768到32,767

int 4 字节 -2,147,483,648到2,147,483,647

long 8 字节 -9,223,372,036,854,775,808到9,223,372,036, 854,775,807

char 2 字节整个Unicode字符集

boolean 1 位 True或者false

my 2007-05-29 11:35 发表评论

java.util.Date 构造函数

my — Wed, 23 May 2007 10:12:00 GMT

1. Date = new Date();
不介绍了
2. Date = new Date(107, 0, 1);
三个参数是year,month,day,都是int型，
107代表2007，是减去1900得到的数，比如要new一个2005年的，就是105，1999年的就是99
0代表1月，这里月份是0-11的数字，0代表1月，1代表2月，依此类推
1表示天数，数字范围1-31
3. Date = new Date(65, 2, 6, 9, 30, 15, 0);
public Date([yearOrTimevalue:Number], [month:Number], [date:Number], [hour:Number], [minute:Number], [second:Number], [millisecond:Number])
精确到毫秒

my 2007-05-23 18:12 发表评论

一些基础的精华

my — Wed, 10 Jan 2007 01:54:00 GMT

1、对象的初始化
(1) 非静态对象的初始化
在创建对象时，对象所在类的所有数据成员会首先进行初始化。
基本类型：int型，初始化为0。
如果为对象：这些对象会按顺序初始化。
※在所有类成员初始化完成之后，才调用本类的构造方法创建对象。
构造方法的作用就是初始化。
(2) 静态对象的初始化
程序中主类的静态变量会在main方法执行前初始化。
不仅第一次创建对象时，类中的所有静态变量都初始化，并且第一次访问某类（注意此时
未创建此类对象）的静态对象时，所有的静态变量也要按它们在类中的顺序初始化。
2、继承时，对象的初始化过程
(1) 主类的超类由高到低按顺序初始化静态成员，无论静态成员是否为private。
(2) 主类静态成员的初始化。
(3) 主类的超类由高到低进行默认构造方法的调用。注意，在调用每一个超类的默认构造
方法前，先进行对此超类进行非静态对象的初始化。
(4) 主类非静态成员的初始化。
(5) 调用主类的构造方法。
3、关于构造方法
(1) 类可以没有构造方法，但如果有多个构造方法，就应该要有默认的构造方法，否则在继承此类时，需要在子类中显式调用父类的某一个非默认的构造方法了。
(2) 在一个构造方法中，只能调用一次其他的构造方法，并且调用构造方法的语句必须是
第一条语句。
4、有关public、private和protected
(1) 无public修饰的类，可以被其他类访问的条件是：a.两个类在同一文件中，b.两个类
在同一文件夹中，c.两个类在同一软件包中。
(2) protected：继承类和同一软件包的类可访问。
(3) 如果构造方法为private，那么在其他类中不能创建该类的对象。
5、抽象类
(1) 抽象类不能创建对象。
(2) 如果一个类中一个方法为抽象方法，则这个类必须为abstract抽象类。
(3) 继承抽象类的类在类中必须实现抽象类中的抽象方法。
(4) 抽象类中可以有抽象方法，也可有非抽象方法。抽象方法不能为private。
(5) 间接继承抽象类的类可以不给出抽象方法的定义。
6、 final关键字
(1) 一个对象是常量，不代表不能转变对象的成员，仍可以其成员进行操作。
(2) 常量在使用前必须赋值，但除了在声明的同时初始化外，就只能在构造方法中初始化
。
(3) final修饰的方法不能被重置（在子类中不能出现同名方法）。
(4) 如果声明一个类为final，则所有的方法均为final，无论其是否被final修饰，但数据
成员可为final也可不是。
7、接口interface （用implements来实现接口）
(1) 接口中的所有数据均为 static和final即静态常量。尽管可以不用这两个关键字修饰
，但必须给常量赋初值。
(2) 接口中的方法均为public，在实现接口类中，实现方法必须可public关键字。
(3) 如果使用public来修饰接口，则接口必须与文件名相同。
8、多重继承
(1) 一个类继承了一个类和接口，那么必须将类写在前面，接口写在后面，接口之间用逗
号分隔。
(2) 接口之间可多重继承，注意使用关键字extends。
(3) 一个类虽只实现了一个接口，但不仅要实现这个接口的所有方法，还要实现这个接口
继承的接口的方法，接口中的所有方法均须在类中实现。
9、接口的嵌入
(1) 接口嵌入类中，可以使用private修饰。此时，接口只能在所在的类中实现，其他类不
能访问。
(2) 嵌入接口中的接口一定要为public。
10、类的嵌入
(1) 类可以嵌入另一个类中，但不能嵌入接口中。
(2) 在静态方法或其他方法中，不能直接创建内部类对象，需通过手段来取得。
手段有两种：
class A {
class B {}
B getB() {
B b = new B();
return b;
}
}
static void m() {
A a = new A();
A.B ab = a.getB(); // 或者是 A.B ab = a.new B();
}
(3) 一个类继承了另一个类的内部类，因为超类是内部类，而内部类的构造方法不能自动
被调用，这样就需要在子类的构造方法中明确的调用超类的构造方法。
接上例：
class C extends A.B {
C() {
new A().super(); // 这一句就实现了对内部类构造方法的调用。
}
}
构造方法也可这样写：
C(A a) {
a.super();
} // 使用这个构造方法创建对象，要写成C c = new C(a); a是A的对象。
11、异常类
JAVA中除了RunTimeException 类，其他异常均须捕获或抛出

my 2007-01-10 09:54 发表评论

java中的一些常用词汇

my — Tue, 21 Nov 2006 07:49:00 GMT

Abstract class 抽象类:抽象类是不允许实例化的类，因此一般它需要被进行扩展继承。

　　Abstract method 抽象方法:抽象方法即不包含任何功能代码的方法。

　　Access modifier 访问控制修饰符:访问控制修饰符用来修饰Java中类、以及类的方法和变量的访问控制属性。

　　Anonymous class 匿名类:当你需要创建和使用一个类，而又不需要给出它的名字或者再次使用的使用，就可以利用匿名类。

　　Anonymous inner classes 匿名内部类:匿名内部类是没有类名的局部内部类。

　　API 应用程序接口:提供特定功能的一组相关的类和方法的集合。

　　Array 数组:存储一个或者多个相同数据类型的数据结构，使用下标来访问。在Java中作为对象处理。

　　Automatic variables 自动变量:也称为方法局部变量method local variables，即声明在方法体中的变量。

　　Base class 基类:即被扩展继承的类。

　　Blocked state 阻塞状态:当一个线程等待资源的时候即处于阻塞状态。阻塞状态不使用处理器资源

　　Call stack 调用堆栈:调用堆栈是一个方法列表，按调用顺序保存所有在运行期被调用的方法。

　　Casting 类型转换 :即一个类型到另一个类型的转换，可以是基本数据类型的转换，也可以是对象类型的转换。

　　char 字符:容纳单字符的一种基本数据类型。

　　Child class 子类:见继承类Derived class

　　Class 类:面向对象中的最基本、最重要的定义类型。

　　Class members 类成员:定义在类一级的变量，包括实例变量和静态变量。

　　Class methods 类方法:类方法通常是指的静态方法，即不需要实例化类就可以直接访问使用的方法。

　　Class variable 类变量:见静态变量Static variable

　　Collection 容器类:容器类可以看作是一种可以储存其他对象的对象，常见的容器类有Hashtables和Vectors。

　　Collection interface 容器类接口:容器类接口定义了一个对所有容器类的公共接口。

　　Collections framework 容器类构架:接口、实现和算法三个元素构成了容器类的架构。

　　Constructor 构造函数:在对象创建或者实例化时候被调用的方法。通常使用该方法来初始化数据成员和所需资源。

　　Containers容器:容器是一种特殊的组件，它可以容纳其他组件。

　　Declaration 声明:声明即是在源文件中描述类、接口、方法、包或者变量的语法。

　　Derived class 继承类:继承类是扩展继承某个类的类。

　　Encapsulation 封装性:封装性体现了面向对象程序设计的一个特性，将方法和数据组织在一起，隐藏其具体实现而对外体现出公共的接口。

　　Event classes 事件类:所有的事件类都定义在java.awt.event包中。

　　Event sources 事件源:产生事件的组件或对象称为事件源。事件源产生事件并把它传递给事件监听器event listener*。

　　Exception 异常:异常在Java中有两方面的意思。首先，异常是一种对象类型。其次，异常还指的是应用中发生的一种非标准流程情况，即异常状态。

　　Extensibility扩展性:扩展性指的是面向对象程序中，不需要重写代码和重新设计，能容易的增强源设计的功能。

　　Finalizer 收尾:每个类都有一个特殊的方法finalizer，它不能被直接调用，而被JVM在适当的时候调用，通常用来处理一些清理资源的工作，因此称为收尾机制。

　　Garbage collection 垃圾回收机制:当需要分配的内存空间不再使用的时候，JVM将调用垃圾回收机制来回收内存空间。

　　Guarded region 监控区域:一段用来监控错误产生的代码。

　　Heap堆:Java中管理内存的结构称作堆。

　　Identifiers 标识符:即指定类、方法、变量的名字。注意Java是大小写敏感的语言。

　　Import statement 引入语法:引入语法允许你可以不使用某个类的全名就可以参考这个类。

　　Inheritance 继承:继承是面向对象程序设计的重要特点，它是一种处理方法，通过这一方法，一个对象可以获得另一个对象的特征。

　　Inner classes 内部类:内部类与一般的类相似，只是它被声明在类的内部，或者甚至某个类方法体中。

　　Instance 实例:类实例化以后成为一个对象。

　　Instance variable 实例变量:实例变量定义在对象一级，它可以被类中的任何方法或者其他类的中方法访问，但是不能被静态方法访问。

　　Interface 接口:接口定义的是一组方法或者一个公共接口，它必须通过类来实现。

　　Java source file Java源文件:Java源程序包含的是Java程序语言计算机指令。

　　Java Virtual Machine (JVM) Java虚拟机:解释和执行Java字节码的程序，其中Java字节码由Java编译器生成。

　　javac Java编译器:Javac是Java编译程序的名称。

　　JVM Java虚拟机:见Java虚拟机

　　Keywords 关键字:即Java中的保留字，不能用作其他的标识符。

　　Layout managers 布局管理器:布局管理器是一些用来负责处理容器中的组件布局排列的类。

　　Local inner classes 局部内部类:在方法体中，或者甚至更小的语句块中定义的内部类。

　　Local variable 局部变量:在方法体中声明的变量

　　Member inner classes 成员内部类:定义在封装类中的没有指定static修饰符的内部类。

　　Members 成员:类中的元素，包括方法和变量。

　　Method 方法:完成特定功能的一段源代码，可以传递参数和返回结果，定义在类中。

　　Method local variables 方法局部变量:见自动变量Automatic variables

　　Modifier 修饰符:用来修饰类、方法或者变量行为的关键字。

　　Native methods 本地方法:本地方法是指使用依赖平台的语言编写的方法，它用来完成Java无法处理的某些依赖于平台的功能。

　　Object 对象:一旦类实例化之后就成为对象。

　　Overloaded methods 名称重载方法:方法的名称重载是指同一个类中具有多个方法，使用相同的名称而只是其参数列表不同。

　　Overridden methods 覆盖重载方法:方法的覆盖重载是指父类和子类使用的方法采用同样的名称、参数列表和返回类型。

　　Package 包:包即是将一些类聚集在一起的一个实体。

　　Parent class 父类:被其他类继承的类。也见基类。

　　Private members 私有成员:私有成员只能在当前类被访问，其他任何类都不可以访问之。

　　Public members 公共成员:公共成员可以被任何类访问，而不管该类属于那个包。

　　Runtime exceptions 运行时间异常:运行时间异常是一种不能被你自己的程序处理的异常。通常用来指示程序BUG。

　　Source file 源文件:源文件是包含你的Java代码的一个纯文本文件。

　　Stack trace 堆栈轨迹:如果你需要打印出某个时间的调用堆栈状态，你将产生一个堆栈轨迹。

　　Static inner classes 静态内部类:静态内部类是内部类最简单的形式，它于一般的类很相似，除了被定义在了某个类的内部。

　　Static methods 静态方法:静态方法声明一个方法属于整个类，即它可以不需要实例化一个类就可以通过类直接访问之。

　　Static variable 静态变量:也可以称作类变量。它类似于静态方法，也是可以不需要实例化类就可以通过类直接访问。

　　Superclass 超类:被一个或多个类继承的类。

　　Synchronized methods 同步方法:同步方法是指明某个方法在某个时刻只能由一个线程访问。

　　Thread 线程:线程是一个程序内部的顺序控制流。

　　Time-slicing 时间片:调度安排线程执行的一种方案。

　　Variable access 变量访问控制:变量访问控制是指某个类读或者改变一个其他类中的变量的能力。

　　Visibility 可见性: 可见性体现了方法和实例变量对其他类和包的访问控制。

my 2006-11-21 15:49 发表评论

将JAVA编译为EXE的几种方法

my — Fri, 27 Oct 2006 01:51:00 GMT

将JAVA编译为EXE的几种方法
--------------------------------------------------------------------------------

将Java应用程序本地编译为EXE的几种方法(建议使用JOVE和JET)　

a. 利用微软的SDK-Java 4.0所提供的jexegen.exe创建EXE文件，这个软件可以　
从微软的网站免费下载，地址如下：　
http://www.microsoft.com/java/download/dl_sdk40.htm　
jexegen的语法如下：　
jexegen /OUT:exe_file_name　
/MAIN:main_class_name main_class_file_name.class　
[and other classes]　
b. Visual Cafe提供了一个能够创建EXE文件的本地编译器。你需要安装该光盘　
上提供的EXE组件。　
c. 使用InstallAnywhere创建安装盘。　
d. 使用IBM AlphaWorks提供的一个高性能Java编译器，该编译器可以从下面的　
地址获得：　
http://www.alphaworks.ibm.com/tech/hpc　
e. JET是一个优秀的Java语言本地编译器。该编译器可以从这个网站获得一个　
测试版本：　
http://www.excelsior-usa.com/jet.html　
f. Instantiations公司的JOVE　
http://www.instantiations.com/jove/...ejovesystem.htm　
JOVE公司合并了以前的SuperCede，一个优秀的本地编译器，现在SuperCede　
已经不复存在了。　
g. JToEXE　
Bravo Zulu Consulting, Inc开发的一款本地编译器，本来可以从该公司的　
网页上免费下载的，不过目前在该公司的主页上找不到了。
h. 从www.towerj.com获得一个TowerJ编译器，该编译器可以将你的CLASS文件　
编译成EXE文件。　

h......exe4j，，呵呵不用说了吧。

my 2006-10-27 09:51 发表评论

Java中常见的异常

my — Thu, 12 Oct 2006 02:13:00 GMT

1. java.lang.NullPointerException
　　这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话）

　　2. java.lang.ClassNotFoundException
　　这个异常是很多原本在JB等开发环境中开发的程序员，把JB下的程序包放在WTk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在JB下做的程序包，一般都是默认加上Package的，所以转到WTK下后要注意把Package的路径加上。

　　3. java.lang.ArithmeticException
　　这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。

　　4. java.lang.ArrayIndexOutOfBoundsException
　　这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。

　　5. java.lang.IllegalArgumentException
　　这个异常的解释是"方法的参数错误"，很多J2ME的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setColor(int red,int green,int blue)这个方法中的三个值，如果有超过２５５的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。

　　6. java.lang.IllegalAccessException
　　这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了Package的情况下要注意这个异常。

my 2006-10-12 10:13 发表评论

查看自己机器上可以使用的字体

my — Thu, 12 Oct 2006 02:10:00 GMT

又学到一个方法
import java.awt.*;
class Ziti
{
    public static void main(String args[])
    {
        String s1[] = GraphicsEnvironment.getLocalGraphicsEnvironment()
        .getAvailableFontFamilyNames();
        for(int i=0;i        {
            System.out.println(s1[i]);
        }
    }
}

my 2006-10-12 10:10 发表评论

一个最简单的计算器

my — Thu, 12 Oct 2006 02:09:00 GMT

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

class MyFrame extends JFrame implements ActionListener
{
        private JButton ButtonNum[]=new JButton[16];
        private String countCode[]={"/","*","-","+","=","."};

        private JTextField displayField=new JTextField();
        private JPanel pan=new JPanel();

        private String displayStr="";
        private double firstNum=0,secondNum=0;
        private int countNum;
        private boolean start=false,end=false;

    public MyFrame()
    {
        super("模拟简便计算器");
        setSize(400,400);
        Container c=getContentPane();
        c.setLayout(new BorderLayout());

        displayField.setHorizontalAlignment(JTextField.RIGHT);
        displayField.setFont(new Font("TimesRoman",Font.BOLD,50));
        displayField.setBackground(Color.gray);
        displayField.setEditable(false);
        displayField.addActionListener(this);
        c.add(displayField,"North");
        c.add(pan,"Center");

        pan.setLayout(new GridLayout(4,4));

        for(int n=0;n<16;n++)  //定义按键属性
        {
            if(n<10)
            {
                ButtonNum[n]=new JButton(n+"");
                ButtonNum[n].setFont(new Font("TimesRoman",Font.BOLD,50));
                ButtonNum[n].setBackground(Color.lightGray);
                ButtonNum[n].addActionListener(this);
                pan.add(ButtonNum[n]);
            }

            else
            {
                ButtonNum[n]=new JButton(countCode[15-n]);
                ButtonNum[n].setFont(new Font("TimesRoman",Font.BOLD,50));
                ButtonNum[n].addActionListener(this);
                pan.add(ButtonNum[n]);
            }
        }
        setVisible(true);
    }

    public static void main(String args[])
    {
        MyFrame myFrame=new MyFrame();
    }

    public void windowClosing(WindowEvent e)
    {
        dispose();
        System.exit(0);
    }

    public void actionPerformed(ActionEvent e)
    {
        for(int i=0;i<16;i++)
        {
            if(i<=10)   //算数按钮输入事件处理  判断并显示输入的运算数字
            {
                if(e.getSource()==ButtonNum[i] && start==false)
                {
                    displayStr=displayStr+ButtonNum[i].getLabel();
                    displayField.setText(displayStr);

                }

                if(e.getSource()==ButtonNum[i] && start==true)
                {
                    displayStr=displayStr+ButtonNum[i].getLabel();
                    displayField.setText(displayStr);
                    end=true;
                }
            }

            if(i>=12 && i<=15)     //运算按钮事件处理  判断并接受输入的运算数字
            {
                if(e.getSource()==ButtonNum[i] && start==false)
                {
                    firstNum=Double.valueOf(displayField.getText()).doubleValue();
                    countNum=i;
                    displayField.setText("");
                    displayStr="";
                    start=true;
                }

                else
                {    if(e.getSource()==ButtonNum[i] )
                    {
                        countNum=0;
                        displayField.setText("");
                        displayStr="";
                        firstNum=0;
                        secondNum=0;
                        end=false;
                    }
                }
            }

            if(e.getSource()==ButtonNum[11])    //等号按钮事件处理
            {
                secondNum=Double.valueOf(displayField.getText()).doubleValue();

                if(start=true && end==true)
                {
                    if(countNum==12)
                        displayField.setText(firstNum+secondNum+"");
                    if(countNum==13)
                        displayField.setText(firstNum-secondNum+"");
                    if(countNum==14)
                        displayField.setText(firstNum*secondNum+"");
                    if(countNum==15 && secondNum!=0)
                        displayField.setText(firstNum/secondNum+"");
                }

                countNum=0;
                displayStr="";
                firstNum=0;
                secondNum=0;
                start=false;
                end=false;
            }
        }
    }
}

my 2006-10-12 10:09 发表评论

对String的深刻理解

my — Fri, 18 Aug 2006 07:41:00 GMT

1、"abc"与new String("abc"); 经常会问到的面试题：String s = new String("abc");创建了几个String Object?【如这里创建了多少对象? 和一道小小的面试题】这个问题比较简单，涉及的知识点包括：引用变量与对象的区别；字符串文字"abc"是一个String对象；文字池[pool of literal strings]和堆[heap]中的字符串对象。一、引用变量与对象：除了一些早期的Java书籍和现在的垃圾书籍，人们都可以从中比较清楚地学习到两者的区别。A aa;语句声明一个类A的引用变量aa[我常常称之为句柄]，而对象一般通过new创建。所以题目中s仅仅是一个引用变量，它不是对象。[ref 句柄、引用与对象] 二、Java中所有的字符串文字[字符串常量]都是一个String的对象。有人[特别是C程序员]在一些场合喜欢把字符串"当作/看成"字符数组，这也没有办法，因为字符串与字符数组存在一些内在的联系。事实上，它与字符数组是两种完全不同的对象。 System.out.println("Hello".length()); char[] cc={'H','i'}; System.out.println(cc.length); 三、字符串对象的创建:由于字符串对象的大量使用[它是一个对象，一般而言对象总是在heap分配内存]，Java中为了节省内存空间和运行时间[如比较字符串时，==比equals()快]，在编译阶段就把所有的字符串文字放到一个文字池[pool of literal strings]中，而运行时文字池成为常量池的一部分。文字池的好处，就是该池中所有相同的字符串常量被合并，只占用一个空间。我们知道，对两个引用变量，使用==判断它们的值[引用]是否相等，即指向同一个对象： String s1 = "abc" ;String s2 = "abc" ;if( s1 == s2 ) System.out.println("s1,s2 refer to the same object");else System.out.println("trouble"); 这里的输出显示，两个字符串文字保存为一个对象。就是说，上面的代码只在pool中创建了一个String对象。现在看String s = new String("abc");语句，这里"abc"本身就是pool中的一个对象，而在运行时执行new String()时，将pool中的对象复制一份放到heap中，并且把heap中的这个对象的引用交给s持有。ok，这条语句就创建了2个String对象。 String s1 = new String("abc") ;String s2 = new String("abc") ;if( s1 == s2 ){ //不会执行的语句} 这时用==判断就可知，虽然两个对象的"内容"相同[equals()判断]，但两个引用变量所持有的引用不同， BTW：上面的代码创建了几个String Object? [三个，pool中一个，heap中2个。] [Java2 认证考试学习指南 (第4版)( 英文版)p197-199有图解。] 2、字符串的+运算和字符串转换字符串转换和串接是很基础的内容，因此我以为这个问题简直就是送分题。事实上，我自己就答错了。 String str = new String("jf"); // jf是接分 str = 1+2+str+3+4; 一共创建了多少String的对象？[我开始的答案：5个。jf、new、3jf、3jf3、3jf34] 首先看JLS的有关论述：一、字符串转换的环境[JLS 5.4 String Conversion] 字符串转换环境仅仅指使用双元的+运算符的情况，其中一个操作数是一个String对象。在这一特定情形下，另一操作数转换成String，表达式的结果是这两个String的串接。二、串接运算符[JLS 15.18.1 String Concatenation Operator + ] 如果一个操作数/表达式是String类型，则另一个操作数在运行时转换成一个String对象，并两者串接。此时，任何类型都可以转换成String。[这里，我漏掉了"3"和"4"] 如果是基本数据类型，则如同首先转换成其包装类对象，如int x视为转换成Integer(x)。现在就全部统一到引用类型向String的转换了。这种转换如同[as if]调用该对象的无参数toString方法。[如果是null则转换成"null"]。因为toString方法在Object中定义，故所有的类都有该方法，而且Boolean, Character, Integer, Long, Float, Double, and String改写了该方法。关于+是串接还是加法，由操作数决定。1+2+str+3+4 就很容易知道是"3jf34"。[BTW :在JLS的15.18.1.3中举的一个jocular little example，真的很无趣。] 下面的例子测试了改写toString方法的情况.。 class A{ int i = 10; public static void main(String []args){ String str = new String("jf"); str += new A(); System.out.print(str); } public String toString(){ return " a.i ="+i+"\n"; }} 三、字符串转换的优化按照上述说法，str = 1+2+str+3+4;语句似乎应该就应该生成5个String对象： 1+2 ＝3，then 3→Integer(3)→"3" in pool? [假设如此] "3"+str(in heap) = "3jf" (in heap) "3jf" +3 ,first 3→Integer(3)→"3" in pool? [则不创建] then "3jf3" "3jf3"+4 create "4" in pool then "3jf34" 这里我并不清楚3、4转换成字符串后是否在池中，所以上述结果仍然是猜测。为了减少创建中间过渡性的字符串对象，提高反复进行串接运算时的性能，a Java compiler可以使用StringBuffer或者类似的技术，或者把转换与串接合并成一步。例如：对于 a + b + c ，Java编译器就可以将它视为[as if] new StringBuffer().append(a).append(b).append(c).toString(); 注意，对于基本类型和引用类型，在append(a)过程中仍然要先将参数转换，从这个观点看，str = 1+2+str+3+4;创建的字符串可能是"3"、"4"和"3jf34"[以及一个StringBuffer对象]。现在我仍然不知道怎么回答str = 1+2+str+3+4;创建了多少String的对象，。或许，这个问题不需要过于研究，至少SCJP不会考它。 3、这又不同：str = "3"+"jf"+"3"+"4"; 如果是一个完全由字符串文字组成的表达式，则在编译时，已经被优化而不会在运行时创建中间字符串。测试代码如下： String str1 ="3jf34"; String str2 ="3"+"jf"+"3"+"4"; if(str1 == str2) { System.out.println("str1 == str2"); }else { System.out.println("think again"); } if(str2.equals(str1)) System.out.println("yet str2.equals(str1)"); 可见，str1与str2指向同一个对象，这个对象在pool中。所有遵循Java Language Spec的编译器都必须在编译时对constant expressions 进行简化。JLS规定：Strings computed by constant expressions (ý15.28) are computed at compile time and then treated as if they were literals. 对于String str2 ="3"+"jf"+"3"+"4";我们说仅仅创建一个对象。注意，“创建多少对象”的讨论是说运行时创建多少对象。 BTW：编译时优化 String x = "aaa " + "bbb "; if (false) { x = x + "ccc "; } x += "ddd "; 等价于： String x = "aaa bbb "; x = x + "ddd "; 4、不变类 String对象是不可改变的(immutable)。有人对str = 1+2+str+3+4;语句提出疑问,怎么str的内容可以改变？其实仍然是因为不清楚：引用变量与对象的区别。str仅仅是引用变量，它的值——它持有的引用可以改变。你不停地创建新对象，我就不断地改变指向。[参考TIJ的Read-only classes。] 不变类的关键是，对于对象的所有操作都不可能改变原来的对象[只要需要，就返回一个改变了的新对象]。这就保证了对象不可改变。为什么要将一个类设计成不变类？有一个OOD设计的原则：Law of Demeter。其广义解读是：使用不变类。只要有可能，类应当设计为不变类。

my 2006-08-18 15:41 发表评论

BlogJava-爱女孩的小火柴-文章分类-java

Java程序异常处理的特殊情况ZT

对synchronized(this)的一些理解 ZT

Java同步机制浅谈――synchronized ZT

转 Java RunTime类

Java程序员面试三十二问

详细解析Java中抽象类和接口的区别 转帖

区分引用类型和原始类型

java.util.Date 构造函数

一些基础的精华

java中的一些常用词汇

将JAVA编译为EXE的几种方法

Java中常见的异常

查看自己机器上可以使用的 字体

一个最简单的计算器

对String的深刻理解

详细解析Java中抽象类和接口的区别转帖

查看自己机器上可以使用的字体