亚洲精品在线免费观看视频,亚洲综合国产欧洲丝袜,亚洲视频国产视频

Java 堆与栈的使用

水煮三国 — Fri, 27 Oct 2006 08:07:00 GMT

Java栈与�?-----------转自javaeye.com

----对这两个概念的不明好久，�l�于扑ֈ�一��好文，拿来�׃�n�Q�http://www.duduwolf.com/cmd.asp?act=tb&id=3 �Q?/p>

1. �?stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同�Q�Java自动��理栈和堆，�E�序员不能直接地讄��栈或堆�?

2. 栈的优势是，存取速度比堆要快�Q�仅�ơ于直接位于CPU中的寄存器。但�~�点是，存在栈中的数据大��与生存期必��L��定的，�~�Z��灉|��性。另外，栈数据可以共享，详见�W?炏V��堆的优势是可以动态地分配内存大小�Q�生存期也不必事先告诉编译器�Q�Java的垃圾收集器会自动收走这些不再��用的数据。但�~�点是，�׃��要在�q�行时动态分配内存，存取速度较慢�?/p>

3. Java中的数据�c�d��有两�U��?/p>

一�U�是基本�c�d��(primitive types), 共有8�U�，即int, short, long, byte, float, double, boolean, char(注意�Q��ƈ没有string的基本类�?。这�U�类型的定义是通过诸如int a = 3; long b = 255L;的�Ş式来定义的，�U�Cؓ自动变量。值得注意的是�Q�自动变量存的是字面��|��不是�cȝ��实例�Q�即不是�cȝ��引用�Q�这里�ƈ没有�cȝ��存在。如int a = 3; �q�里的a是一个指向int�c�d��的引用，指向3�q�个字面倹{��这些字面值的数据�Q�由于大��可知，生存期可�?�q�些字面值固定定义在某个�E�序块里面，�E�序块退出后�Q�字�D�值就消失�?�Q�出于追求速度的原因，��存在于栈中�?/p>

另外�Q�栈有一个很重要的特�D�性，��是存在栈中的数据可以共享。假设我们同时定义：

代码

						int
						a
						=
						3
						;
						

						int
						b
						=
						3�Q?/span>

�~�译器先处理int a = 3�Q�首先它会在栈中创徏一个变量�ؓa的引用，然后查找有没有字面��gؓ3的地址�Q�没扑ֈ��Q�就开辟一个存�?�q�个字面值的地址�Q�然后将a指向3的地址。接着处理int b = 3�Q�在创徏完b的引用变量后�Q�由于在栈中已经�?�q�个字面��|��便将b直接指向3的地址。这��P��出��C��a与b同时均指�?的情��c�?

特别注意的是�Q�这�U�字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了�q�个对象的内部状态，那么另一个对象引用变量也卛_��反映��个变化。相反，通过字面值的引用来修改其��|��不会��D��另一个指向此字面值的引用的��g��跟着改变的情��c��如上例�Q�我们定义完a与b的值后�Q�再令a=4�Q�那么，b不会�{�于4�Q�还是等�?。在�~�译器内部，遇到a=4�Q�时�Q�它��׃��重新搜烦栈中是否�?的字面��|��如果没有�Q�重新开辟地址存放4的��|��如果已经有了�Q�则直接��a指向�q�个地址。因此a值的改变不会影响到b的倹{�?/p>

另一�U�是包装�c�L��据，如Integer, String, Double�{�将相应的基本数据类型包装�v来的�c�R��这些类数据全部存在于堆中，Java用new()语句来显�C�地告诉�~�译器，在运行时才根据需要动态创建，因此比较灉|��Q�但�~�点是要占用更多的时间�?4. String是一个特�D�的包装�c�L��据。即可以用String str = new String("abc");的�Ş式来创徏�Q�也可以用String str = "abc"�Q�的形式来创�?作�ؓ�Ҏ��Q�在JDK 5.0之前�Q�你从未见过Integer i = 3;的表辑ּ��Q�因为类与字面值是不能通用的，除了String。而在JDK 5.0中，�q�种表达式是可以的！因�ؓ�~�译器在后台�q�行Integer i = new Integer(3)的�{�?。前者是规范的类的创��E�，卛_��Java中，一切都是对象，而对象是�cȝ��实例�Q�全部通过new()的�Ş式来创徏。Java中的有些�c�，如DateFormat�c�，可以通过该类的getInstance()�Ҏ��来返回一个新创徏的类�Q�似乎违反了此原则。其实不然。该�c�运用了单例模式来返回类的实例，只不�q�这个实例是在该�c�d��部通过new()来创建的�Q�而getInstance()向外部隐藏了此细节。那��Z��么在String str = "abc"�Q�中�Q��ƈ没有通过new()来创建实例，是不是违反了上述原则�Q�其实没有�?/p>

5. 关于String str = "abc"的内部工作。Java内部��此语句转化��Z��下几个步骤：

(1)先定义一个名为str的对String�cȝ��对象引用变量�Q�String str�Q?/p>

(2)在栈中查找有没有存放��gؓ"abc"的地址�Q�如果没有，则开辟一个存攑֭�面��gؓ"abc"的地址�Q�接着创徏一个新的String�cȝ��对象o�Q��ƈ��o的字�W�串值指向这个地址�Q�而且在栈中这个地址旁边��C��q�个引用的对象o。如果已�l�有了��gؓ"abc"的地址�Q�则查找对象o�Q��ƈ�q�回o的地址�?/p>

(3)��str指向对象o的地址�?/p>

值得注意的是�Q�一般String�c�M��字符串值都是直接存值的。但像String str = "abc"�Q�这�U�场合下�Q�其字符串值却是保存了一个指向存在栈中数据的引用�Q?/p>

��Z��更好地说明这个问题，我们可以通过以下的几个代码进行验证�?/p>

代码

Stringstr1="abc";
Stringstr2="abc";
System.out.println(str1==str2);//true

注意�Q�我们这里�ƈ不用str1.equals(str2)�Q�的方式�Q�因��比较两个字�W�串的值是否相�{��?=��P��Ҏ��JDK的说明，只有在两个引用都指向了同一个对象时才返回真倹{��而我们在�q�里要看的是�Q�str1与str2是否都指向了同一个对象�?
�l�果说明�Q�JVM创徏了两个引用str1和str2�Q�但只创��Z��一个对象，而且两个引用都指向了�q�个对象�?

我们再来更进一步，��以上代码改成：

代码

Stringstr1="abc";
Stringstr2="abc";
str1="bcd";
System.out.println(str1+","+str2);//bcd,abc
System.out.println(str1==str2);//false

�q�就是说�Q�赋值的变化��D��了类对象引用的变化，str1指向了另外一个新对象�Q�而str2仍旧指向原来的对象。上例中�Q�当我们��str1的值改�?bcd"�Ӟ��JVM发现在栈中没有存放该值的地址�Q�便开辟了�q�个地址�Q��ƈ创徏了一个新的对象，其字�W�串的值指向这个地址�?/p>

事实上，String�c�被设计成�ؓ不可改变(immutable)的类。如果你要改变其��|��可以�Q�但JVM在运行时�Ҏ��新值悄悄创��Z��一个新对象�Q�然后将�q�个对象的地址�q�回�l�原来类的引用。这个创��E�虽说是完全自动�q�行的，但它毕竟占用了更多的旉��。在�Ҏ��间要求比较敏感的环境中，会带有一定的不良影响�?/p>

再修改原来代码：

代码

Stringstr1="abc";
Stringstr2="abc";
str1="bcd";
Stringstr3=str1;
System.out.println(str3);//bcd
Stringstr4="bcd";
System.out.println(str1==str4);//true

str3�q�个对象的引用直接指向str1所指向的对�?注意�Q�str3�q�没有创建新对象)。当str1改完其值后�Q�再创徏一个String的引用str4�Q��ƈ指向因str1修改��D��创建的新的对象。可以发玎ͼ��q�回str4也没有创建新的对象，从而再�ơ实现栈中数据的�׃�n�?

我们再接着看以下的代码�?/p>

代码

Stringstr1=newString("abc");
Stringstr2="abc";
System.out.println(str1==str2);//false

创徏了两个引用。创��Z��两个对象。两个引用分别指向不同的两个对象�?/p>

String str1 = "abc";
String str2 = new String("abc");
System.out.println(str1==str2); //false

创徏了两个引用。创��Z��两个对象。两个引用分别指向不同的两个对象�?/p>

以上两段代码说明�Q�只要是用new()来新建对象的�Q�都会在堆中创徏�Q�而且其字�W�串是单独存值的�Q�即使与栈中的数据相同，也不会与栈中的数据共享�?/p>

6. 数据�c�d��包装�cȝ��g��可修攏V��不仅仅是String�cȝ��g��可修改，所有的数据�c�d��包装�c�都不能更改其内部的倹{�?7. �l�论与徏议：

(1)我们在��用诸如String str = "abc"�Q�的格式定义�c�L��Q��L��惛_��然地认�ؓ�Q�我们创��Z��String�cȝ��对象str。担心陷阱！对象可能�q�没有被创徏�Q�唯一可以肯定的是�Q�指向String�cȝ��引用被创��Z��。至于这个引用到底是否指向了一个新的对象，必须�Ҏ��上下文来考虑�Q�除非你通过new()�Ҏ��来显要地创徏一个新的对象。因此，更�ؓ准确的说法是�Q�我们创��Z��一个指向String�cȝ��对象的引用变量str�Q�这个对象引用变量指向了某个��gؓ"abc"的String�c�R��清醒地认识到这一点对排除�E�序中难以发现的bug是很有帮助的�?/p>

(2)使用String str = "abc"�Q�的方式�Q�可以在一定程度上提高�E�序的运行速度�Q�因为JVM会自动根据栈中数据的实际情况来决定是否有必要创徏新对象。而对于String str = new String("abc")�Q�的代码�Q�则一概在堆中创徏新对象，而不��其字符串值是否相�{�，是否有必要创建新对象�Q�从而加重了�E�序的负担。这个思想应该是��n元模式的思想�Q�但JDK的内部在�q�里实现是否应用了这个模式，不得而知�?/p>

(3)当比较包装类里面的数值是否相�{�时�Q�用equals()�Ҏ��Q�当��试两个包装�cȝ��引用是否指向同一个对象时�Q�用==�?/p>

(4)�׃��String�cȝ��immutable性质�Q�当String变量需要经常变换其值时�Q�应该考虑使用StringBuffer�c�，以提高程序效率�?/p>

水煮三国 2006-10-27 16:07 发表评论

NoClassDefDoundErr与ClassNotFoundException区别

水煮三国 — Fri, 27 Oct 2006 02:53:00 GMT

NoClassDefDoundErr与ClassNotFoundException区别

作�?langm

版权声明�Q�本文可以自��p�{载，转蝲时请务必以超链接形式标明文章原始出处和作者信息及本声�?
作�?langm
原文:http://www.matrix.org.cn/resource/article/44/44056_NoClassDefDoundErr.html
关键�?NoClassDefDoundErr ClassNotFoundException

在读�q�篇文章之前�Q�你最好了解一下Java的Exception机制�?/p>

也许你在开发的�q�程中经常地见到ClassNotFoundException和NoClassDefFoundErr�q�两个异常，每每看到之后�Q�都会一概而论的是�c�L��有找刎ͼ�但有些时候见��C��们的时候又有些疑惑�Q�至��我是这��P��Q��ؓ什么Java要用两个异常来表�C�类定义没有扑ֈ�那？他们之间有什么区别那�Q?/p>

正��y今天我又��到了这个问题，��Z��的仔�l�研�I�了一下这两个异常的区别�?
首先�Q?
ClassNotFoundException直接�l�承与Exception�Q�它是一个checked的异常�?
NoClassDefFoundErr �l�承自Error->LinkageError �Q�它是一个unchecked的异常�?/p>

下面让我们看一下两个异常在API文档中的说明

ClassNotFoundException�Q?
当应用尝试用字符串名�U�通过下面的方法装载一个类时这个类的定义却没有扑ֈ�时会抛出的异常�?
Class.forName
ClassLoader.findSystemClass
ClassLoader.loadClass

NoClassDefFoundErr�Q?
当JVM或者ClassLoader实例��试装蝲一个类的定义（�q�通常是一个方法调用或者new表达式创��Z��个实例过�E�的一部分�Q�而这个类定义�q�没有找时所抛出的错误�?
当编译的时候可以找到这个类的定义，但是以后�q�个�c�M��再存在�?/p>

�q�比较显而易见了吧，��d��文档是很重要的事情。这里我��p��一下我对这两个�cȝ��区别的理解�?/p>

ClassNotFoundException异常只出现在你的应用�E�序��d��的装载类的过�E�中�Q�这个异常很多时候出现在我们的应用框架在初始化或者运行中动态装载已配置的类的过�E�中。这�U�情况下我们应该首先��查我们的配置或者参数是否错误，是否企图装蝲一个�ƈ不存在的�c�，如果配置没有错误�Q�我们就应该查看Classpath是否配置错误而导致ClassLoader无法扑ֈ��q�个�c�，也应该检查要装蝲的类是否在一个jar包中而我们在引入�q�个jar包的�q�程中是否有遗漏或错误（�q�里jar包的版本也是一个需要格外注意的问题�Q�很多时候�؜��q��jar包版本会造成太多的麻烦）�?

NoClassDefFoundErr异常一般出现在我们�~�译环境和运行环境不一致的情况下，��是说我们有可能在编译过后更改了Classpath或者jar包所以导致在�q�行的过�E�中JVM或者ClassLoader无法扑ֈ��q�个�cȝ��定义�Q�我曄��在编译后作了一�ơjar包的清理�Q�然后应用就送给了我一个这��L��C�物�Q��?/p>

我们�l�常用SDK开发应用，开发的�q�程中要引入很多jar包，有些SDK也会讑֮�自己的Classpath。编译过�E�结束后在运行的�q�程中就要将已开发的应用和所有引入的jar包拷贝到应用服务器的相应目录下才可以�q�行�Q�而应用服务器使用的Classpath也很有可能与SDK的不同，在这个过�E�中��有很大的几率造成双方环境不一致。所以很多开发者就会遇到在SDK中可以编译，�q�行也没有问题，但是同样的程序放到应用服务器上就出现NoClassDefFoundErr�q�个异常�q�种情况�Q�这是让初学者很挠头的一个问题�?/p>

以上��是我对�q�两个异常的一点个人理解，希望对各位开发者有所帮助�Q�可以让各位开发者在以后的开发过�E�中能够更快的找到问题所在。祝开发顺�?/p>

水煮三国 2006-10-27 10:53 发表评论

澄清Java语言接口与��承的本质

水煮三国 — Thu, 26 Oct 2006 00:55:00 GMT

大多��C�h认�ؓ�Q�接口的意义在于��替多重�l�承。众所周知Java没有c++那样多重�l�承的机�Ӟ��但是却能够实作多个接口。其实这样做是很牵强的，接口和��承是完全不同的东西，接口没有能力代替多重�l�承�Q�也没有�q�个义务。接口的作用�Q�一�a�以蔽之，��是标志�cȝ��c�d��Q�type of class�Q�。把不同�c�d��的类归于不同的接口，可以更好的管理他们。OO的精髓，我以为，是对对象的抽象，最能体现这一点的��是接口。�ؓ什么我们讨��计模式都只针对具备了抽象能力的语�a��Q�比如c++、java、c#�{�）�Q�就是因��计模式所研究的，实际上就是如何合理的��L��象。（cowboy的名�a�是“抽象就是抽��d��的部分”，看似调侃�Q�实乃至理）�?br />
　　设计模式中最基础的是工厂模式�Q�Factory�Q�，在我最�q�的一个很��单的应用中，我想��量的让我的�E�序能够在多个数据库间移植，当然�Q�这涉及很多问题�Q�单是如何兼容不同DBMS的SQL��p��人头痛。我们不妨先把问题简单化�Q�只考虑如何�q�接不同的数据库�?br />
　　假设我有很多个类�Q�分别是Mysql.java、SQLServer.java、Oracle.java、DB2.java�Q�他们分别连接不同的数据库，�l�一�q�回一个Connection对象�Q��ƈ且都有一个close�Ҏ��Q�用于关闭连接。只需要针对你的DBMS�Q�选择不同的类�Q�就可以用了�Q�但是我的用户他会��用什么数据库�Q�我不知道，我希望的是尽量少的修改代码，��p��满��他的需要。我可以抽象如下接口�Q?br />
package org.bromon.test;
public interface DB
{
　　java.sql.Connection openDB(String url,String user,String password);
　　void close();
}

　　�q�个接口只定义两个方法，没有��M��有实际意义的代码�Q�具体的代码由实作这个接口的�c�L��l�出�Q�比如Mysql.java�Q?br />
Package org.bromon.test;
import java.sql.*;
public class Mysql implements DB
{
　　private String url=”jdbc:mysql:localhost:3306/test�?
　　private String user=”root�?
　　private String password=”�?
　　private Connection conn;
　　public Connection openDB(url,user,password)
　　{
　　　　//�q�接数据库的代码
　　}

　　public void close()
　　{
　　　　//关闭数据�?br />　　}
}

　　�c�M��的当然还有Oracle.java�{�等�Q�接口DB�l�这些类归了个类�Q�在应用�E�序中我们这样定义对象：

　　org.bromon.test.DB myDB;

　　使用myDB来操作数据库�Q�就可以不用��实际上我所使用的是哪个�c�，�q�就是所谓的“开-闭”原则。但是问题在于接口是不能实例化的�Q�myDB=new DB()�Q�这��L��代码是绝寚w��误的�Q�我们只能myDB=new Mysql()或者myDB=new Oracle()。麻烦了�Q�我�q�是需要指定具体实例化的是哪个�c�，用了接口跟没用一栗��所以我们需要一个工厂：

package org.bromon.test;
public class DBFactory
{
　　public static DB Connection getConn()
　　{
　　　　Return(new Mysql());
　　}
}

　　所以实例化的代码变成：myDB=DBFactory.getConn()�Q?br />
　　�q�就�?3�U�模式中最基础的普通工�?Factory)�Q�工厂类负责具体实例化哪个类�Q�而其他的�E�序逻辑都是针对DB�q�个接口�q�行操作�Q�这��是“针�Ҏ��口编�E�”。责任都被推卸给工厂�c�M��Q�当然你也可以��l�定义工厂接口，�l�箋把责��M��抛，�q�就演变成抽象工�?Abstract Factory)�?br />
　　整个�q�程中接口不负责��M��具体操作�Q�其他的�E�序要连接数据库的话�Q�只需要构造一个DB对象��OK�Q�而不��工厂类如何变化。这��是接口的意�?---抽象�?br />
　　�l�承的概念不用多��_��很好理解。�ؓ什么要�l�承呢？因�ؓ你想重用代码�Q�这�l�对不是理由�Q��承的意义也在于抽象，而不是代码重用。如果对象A有一个run()�Ҏ��Q�对象B也想有这个方法，所以有人就Class B extends A。这是不�l�大脑的做法。如果在B中实例化一个A�Q�调用A的Run()�Ҏ��Q�是不是可以辑ֈ�同样的目的？如下�Q?br />
Class B
{
　　A a=new A();
　　a.run();
}

　　�q�就是利用类的聚合来重用代码�Q�是委派模式的雏形，是GoF一贯倡导的做法�?br />
　　那么�l�承的意义何在？其实�q�是历史原因造成的，最开始的OO语言只有�l�承�Q�没有接口，所以只能以�l�承来实现抽象，请一定注意，�l�承的本意在于抽象，而非代码重用�Q�虽然��承也有这个作用）�Q�这是很多Java烂书最严重的错误之一�Q�它们所造成的阴影，我至今还没有完全摆脱�Q�坏书害人啊�Q�尤其是入门�cȝ��Q�流毒太大。什么时候应该��用��承？只在抽象�c�M��使用�Q�其他情况下��量不��用。抽象类也是不能实例化的�Q�它仅仅提供一个模版而已�Q�这��很能说明问题�?br />
　　软�g开发的万恶之源�Q�一是重复代码而不是重用代码，二是烂用�l�承�Q�尤以c++�E�序员�ؓ甚。Java中取�~�多重��承，目的��是制止烂用�l�承�Q�实是非常明智的做法�Q�不�q�很多�h都不理解。Java能够更好的体现设计，�q�是让我入迷的原因之一�?img src ="http://www.tkk7.com/os586/aggbug/77316.html" width = "1" height = "1" />

水煮三国 2006-10-26 08:55 发表评论

关键字new和newInstance�Ҏ��区别

水煮三国 — Fri, 22 Sep 2006 01:08:00 GMT

在初始化一个类�Q�生成一个实例的时候，newInstance()�Ҏ��和new关键字除了一个是�Ҏ��Q�一个是关键字外�Q�最主要有什么区别？它们的区别在于创建对象的方式不一��P��前者是使用�c�d��载机�Ӟ��后者是创徏一个新�c�R��那么�ؓ什么会有两�U�创建对象方式？�q�主要考虑到��Y件的可�׾~�、可扩展和可重用�{��Y件设计思想。�?br />
    Java中工厂模式经�怋�用newInstance()�Ҏ��来创建对象，因此从�ؓ什么要使用工厂模式上可以找到具体答案。例如：
    class c = Class.forName(“Example�?;
    factory = (ExampleInterface)c.newInstance();

    其中ExampleInterface是Example的接口，可以写成如下形式�Q��?br />    String className = "Example";
    class c = Class.forName(className);
    factory = (ExampleInterface)c.newInstance();

    �q�一步可以写成如下�Ş式：
    String className = readfromXMlConfig;//从xml 配置文�g中获得字�W�串
    class c = Class.forName(className);
    factory = (ExampleInterface)c.newInstance();

    上面代码已经不存在Example的类名称�Q�它的优�Ҏ��Q�无论Example�c�L��么变化�Q�上�q�C��码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们�l�承ExampleInterface��可以�?br />
    从JVM的角度看�Q�我们��用关键字new创徏一个类的时候，�q�个�c�d��以没有被加蝲。但是��用newInstance()�Ҏ��的时候，��必��M��证：1、这个类已经加蝲�Q?、这个类已经�q�接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，�q�个静态方法调用了启动�c�d��载器�Q�即加蝲java API的那个加载器�?br />
    现在可以看出�Q�newInstance()实际上是把new�q�个方式分解��Z��步，即首先调用Class加蝲�Ҏ��加蝲某个�c�，然后实例化。这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灉|��性，提供�l�了一�U�降耦的手段�?br />
    最后用最��单的描述来区分new关键字和newInstance()�Ҏ��的区别：
    newInstance: ��q��型。低效率。只能调用无参构造。�?br />    new: 强类型。相寚w��效。能调用��M��public构造�?br />

水煮三国 2006-09-22 09:08 发表评论

水煮三国 — Fri, 22 Sep 2006 01:02:00 GMT

我们在��用List,Set的时�?��Z��实现对其数据的遍�?我们�l�常使用��C��Iterator(跌代�?�?br />使用跌代器，你不需要干涉其遍历的过�E�，只需要每�ơ取��Z��个你惌��的数据进行处理就可以了。但是在使用的时候也是有不同的�?br />List和Set都有iterator()来取得其�q�代器。对List来说�Q�你也可以通过listIterator()取得其�P代器�Q�两�U��P代器在有些时候是不能通用的，Iterator和ListIterator主要区别在以下方面：
1. ListIterator有add()�Ҏ��Q�可以向List中添加对象，而Iterator不能
2. ListIterator和Iterator都有hasNext()和next()�Ҏ��Q�可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()�Ҏ��Q�可以实现逆向�Q�顺序向前）遍历。Iterator��׃��可以�?br />3. ListIterator可以定位当前的烦引位�|�，nextIndex()和previousIndex()可以实现。Iterator没有此功能�?br />4. 都可实现删除对象�Q�但是ListIterator可以实现对象的修改，set()�Ҏ��可以实现。Iierator仅能遍历�Q�不能修攏V�?br />
因�ؓListIterator的这些功能，可以实现对LinkedList�{�List数据�l�构的操作�?br />其实,数组对象也可以用�q�代器来实现�?br />org.apache.commons.collections.iterators.ArrayIterator��可以实现此功能�Q�我此前曄��提过��L��法。具体可以参考[link=http://www.javaresearch.org/article/showarticle.jsp?column=1&thread=41142
]
一般情况下�Q�我们��用Iterator��可以了�Q�如果你需要进行记录的前后反复��索的话，你就可以使用ListIterator来扩展你的功能，�Q�有点象JDBC中的滚动�l�果集）�?img src ="http://www.tkk7.com/os586/aggbug/71235.html" width = "1" height = "1" />

水煮三国 2006-09-22 09:02 发表评论

SWT:GridLayout 的��用需要注意的事项

水煮三国 — Tue, 12 Sep 2006 02:50:00 GMT

SWT当中的GridLayout是一个非常灵�zȝ��控�g,但是在��用�v来需要在控制上下一番功�?

大家都知�?JAVA在写�~�写�H�口�E�序的时�?物�g的添�?攄�� 操作��h��要比.net费劲的多,但是如果用好了相关org.eclipse.layout.*包当中的相关�c?也会写出十分漂亮的界面程�?

下面大家先看一个程�?

源码如下:

package com.layout;

import org.eclipse.swt.widgets.*;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.SWT;

public class CopyOfGridLayoutExc {

public static void main(String[] args) {

Display display = new Display();

Shell shell = new Shell(display);

shell.setText("Find (GridLayout)");

Label label = new Label(shell, SWT.NONE);

label.setText("Find what:");

Text text = new Text(shell, SWT.BORDER);

Button findButton = new Button(shell, SWT.PUSH);

findButton.setText("Find Next");

Group group = new Group(shell, SWT.NONE);

group.setLayout(new RowLayout());

Button upButton = new Button(group, SWT.RADIO);

upButton.setText("Up");

Button downButton = new Button(group, SWT.RADIO);

downButton.setText("Down");

downButton.setSelection(true);

group.setText("Direction");

Button cancelButton = new Button(shell, SWT.PUSH);

cancelButton.setText("Cancel");

/* Use a GridLayout to position the controls */

Monitor monitor = shell.getMonitor();

int width = monitor.getClientArea().width / 10;

GridLayout layout = new GridLayout(4, false);

layout.marginWidth = layout.marginHeight = 14;//layout leave's the window's space

shell.setLayout(layout);

GridData labelData =

new GridData(SWT.FILL, SWT.CENTER, false, false);

label.setLayoutData(labelData);

GridData textData =

new GridData(SWT.FILL,SWT.CENTER,true,false,2,1);

textData.widthHint = width;

text.setLayoutData(textData);

GridData findData =

new GridData(SWT.FILL, SWT.CENTER, false, false);

findButton.setLayoutData(findData);

GridData groupData =

new GridData(SWT.RIGHT,SWT.TOP,false,false,3,1);

group.setLayoutData(groupData);

GridData cancelData =

new GridData(SWT.FILL, SWT.TOP, false, false);

cancelButton.setLayoutData(cancelData);

shell.pack();

shell.open();

while (!shell.isDisposed()) {

if (!display.readAndDispatch()) display.sleep();

}

display.dispose();

}

}

�q�其中我们在使用的时候应该要注意以下几点:

1.要选择自己适合的Layout�c�d��.GridLayout适合于多�U�情�?它大部分情况是��用在较�ؓ复杂的界面编�E�当�?因�ؓ复杂的界面会有相当多的控�?

2.GridData的��用将是一个控制界面显�C�的主要�c?通过使用GridData我们可以很好的控制界�?

其中GridData的构造函数比较多,但是相关的��用我们都应该熟悉,特别是上面源�E�序当中使用的那个构造函�?在��用�v来更�Ҏ��控制GridLayout的布局.通过horizantalSpan,VerticalSpan来控制控件所占用的单元格,�q�样��׃��控制其它控制是否在一列当中显�C��是在几列当中昄��.前提是通过GridLayout.numColumns来设�|�列�?

3.如果不设�|�GridData那么相关的控仉��会按照相关的建立��序加入到GridLayout当中.GridData不能控制控�g的显�C�顺�?而相关顺序是对象的徏立顺序来控制�?�q�一点不要与GridData��h��?

希望写这��文章对大家学习SWT有用.

水煮三国 2006-09-12 10:50 发表评论

水煮三国 — Fri, 01 Sep 2006 02:31:00 GMT

1 Java排序��法
package com.cucu.test;

/**
* @author http://www.linewell.com cg@linewell.com
* @version 1.0
*/
public class Sort {

public void swap(int a[], int i, int j) {
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
}

public int partition(int a[], int low, int high) {
    int pivot, p_pos, i;
    p_pos = low;
    pivot = a[p_pos];
    for (i = low + 1; i <= high; i++) {
      if (a[i] > pivot) {
        p_pos++;
        swap(a, p_pos, i);
      }
    }
    swap(a, low, p_pos);
    return p_pos;
}

public void quicksort(int a[], int low, int high) {
    int pivot;
    if (low < high) {
      pivot = partition(a, low, high);
      quicksort(a, low, pivot - 1);
      quicksort(a, pivot + 1, high);
    }

}

public static void main(String args[]) {
    int vec[] = new int[] { 37, 47, 23, -5, 19, 56 };
    int temp;
    //选择排序�?Selection Sort)
    long begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 0; i < vec.length; i++) {
        for (int j = i; j < vec.length; j++) {
          if (vec[j] > vec[i]) {
            temp = vec[i];
            vec[i] = vec[j];
            vec[j] = temp;
          }
        }

      }
    }
    long end = System.currentTimeMillis();
    System.out.println("选择法用时�ؓ�Q? + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }
    // 冒��排序�?Bubble Sort)
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 0; i < vec.length; i++) {
        for (int j = i; j < vec.length - 1; j++) {
          if (vec[j + 1] > vec[j]) {
            temp = vec[j + 1];
            vec[j + 1] = vec[j];
            vec[j] = temp;
          }
        }

      }
    }
    end = System.currentTimeMillis();
    System.out.println("冒��法用时�ؓ�Q? + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }

    //插入排序�?Insertion Sort)
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      for (int i = 1; i < vec.length; i++) {
        int j = i;
        while (vec[j - 1] < vec[i]) {
          vec[j] = vec[j - 1];
          j--;
          if (j <= 0) {
            break;
          }
        }
        vec[j] = vec[i];
      }
    }
    end = System.currentTimeMillis();
    System.out.println("插入法用时�ؓ�Q? + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }

//快速排序法(Quick Sort)

    Sort s = new Sort();
    begin = System.currentTimeMillis();
    for (int k = 0; k < 1000000; k++) {
      s.quicksort(vec, 0, 5);
    }
    end = System.currentTimeMillis();
    System.out.println("快速法用时为：" + (end - begin));
    //打印排序好的�l�果
    for (int i = 0; i < vec.length; i++) {
      System.out.println(vec[i]);
    }
}

}
以下是运行结果：
选择法用时�ؓ�Q?34
56
47
37
23
19
-5
冒��法用时�ؓ�Q?72
56
47
37
23
19
-5
插入法用时�ؓ�Q?8
56
47
37
23
19
-5
快速法用时为：297
56
47
37
23
19
-5

水煮三国 2006-09-01 10:31 发表评论

Thinking�Q�Java中static、this、super、final用法

水煮三国 — Wed, 23 Aug 2006 02:15:00 GMT

Thinking�Q�Java中static、this、super、final用法
本篇旨在帮助准备学习Java以及刚接触Java的朋友认识、掌握和使用static、this、super、final�q�几个关键字的��用。Java博大�_�深�Q�我也是一位正在学习和使用Java的爱好者，文中隑օ�有不妥之处，�Ƣ迎指正�?br />一、static
请先看下面这�D늨�序：
public class Hello{
     public static void main(String[] args){//(1)
          System.out.println("Hello,world!");//(2)
        }
  }
看过�q�段�E�序�Q�对于大多数学过Java 的从来说�Q�都不陌生。即使没有学�q�Java�Q�而学�q�其它的高��语言�Q�例如C�Q�那你也应该能看懂这�D�代码的意思。它只是��单的输出“Hello,world”，一点别的用处都没有�Q�然而，它却展示了static关键字的主要用法。�?br />�?处，我们定义了一个静态的�Ҏ��名�ؓmain�Q�这��意味着告诉Java�~�译器，我这个方法不需要创��Z��个此�cȝ��对象卛_��使用。你�q�得你是怎么�q�行�q�个�E�序吗？一般，我们都是在命令行下，打入如下的命�?加下划线为手动输�?�Q?br />javac Hello.java
java Hello
Hello,world!
�q�就是你�q�行的过�E�，�W�一行用来编译Hello.java�q�个文�g�Q�执行完后，如果你查看当前，会发现多了一个Hello.class文�g�Q�那��是�W�一行��生的Java二进制字节码。第二行��是执行一个Java�E�序的最普遍做法。执行结果如你所料。在2中，你可能会惻I��Z��么要�q�样才能输出。好�Q�我们来分解一下这条语句。（如果没有安装Java文档�Q�请到Sun的官方网站浏览J2SE API�Q�首先，System是位于java.lang包中的一个核心类�Q�如果你查看它的定义�Q�你会发现有�q�样一行：public static final PrintStream out;接着在进一步，点击PrintStream�q�个��链接，在METHOD��面�Q�你会看到大量定义的�Ҏ��Q�查找println�Q�会有这样一行：
public void println(String x)。好了，现在你应该明白�ؓ什么我们要那样调用了，out是System的一个静态变量，所以可以直接��用，而out所属的�c�L��一个println�Ҏ��?br />静态方�?br />通常�Q�在一个类中定义一个方法�ؓstatic�Q�那��是��_��无需本类的对象即可调用此�Ҏ��。如下所�C�：
class Simple{
   static void go(){
        System.out.println("Go...");
    }
}
public class Cal{
  public static void main(String[] args){
     Simple.go();
  }
}
调用一个静态方法就是“类�?�Ҏ��名�?静态方法的使用很简单如上所�C�。一般来��_��静态方法常��ؓ应用�E�序中的其它�c�L��供一些实用工��h��用，在Java的类库中大量的静态方法正是出于此目的而定义的�?br />静态变�?br />静态变量与静态方法类伹{��所有此�c�d��例共享此静态变量，也就是说在类装蝲�Ӟ��只分配一块存储空��_��所有此�cȝ��对象都可以操控此块存储空��_��当然对于final则另当别��Z��。看下面�q�段代码�Q?br />class Value{
static int c=0;
static void inc(){
c++;
  }
}
class Count{
  public static void prt(String s){
    System.out.println(s);
  }
  public static void main(String[] args){
    Value v1,v2;
    v1=new Value();
    v2=new Value();
    prt("v1.c="+v1.c+"  v2.c="+v2.c);
    v1.inc();
    prt("v1.c="+v1.c+"  v2.c="+v2.c);
  }
}
�l�果如下�Q?br />v1.c=0  v2.c=0
v1.c=1  v2.c=1
由此可以证明它们�׃�n一块存储区。static变量有点�c�M��于C中的全局变量的概��c��值得探讨的是静态变量的初始化问题。我们修改上面的�E�序�Q?br />class Value{
  static int c=0;
  Value(){
    c=15;
  }
  Value(int i){
    c=i;
  }
  static void inc(){
    c++;
  }
}
class Count{
  public static void prt(String s){
    System.out.println(s);
  }
    Value v=new Value(10);
    static Value v1,v2;
    static{
      prt("v1.c="+v1.c+"  v2.c="+v2.c);
      v1=new Value(27);
      prt("v1.c="+v1.c+"  v2.c="+v2.c);
      v2=new Value(15);
      prt("v1.c="+v1.c+"  v2.c="+v2.c);
    }
  public static void main(String[] args){
    Count ct=new Count();
    prt("ct.c="+ct.v.c);
    prt("v1.c="+v1.c+"  v2.c="+v2.c);
    v1.inc();
    prt("v1.c="+v1.c+"  v2.c="+v2.c);
    prt("ct.c="+ct.v.c);
  }
}
�q�行�l�果如下�Q?br />v1.c=0  v2.c=0
v1.c=27  v2.c=27
v1.c=15  v2.c=15
ct.c=10
v1.c=10  v2.c=10
v1.c=11  v2.c=11
ct.c=11
�q�个�E�序展示了静态初始化的各�U�特性。如果你初次接触Java�Q�结果可能��o你吃惊。可能会对static后加大括��h��到困惑。首先要告诉你的是，static定义的变量会优先于�Q何其它非static变量�Q�不论其出现的顺序如何。正如在�E�序中所表现的，虽然v出现在v1和v2的前面，但是�l�果却是v1和v2的初始化在v的前面。在static{后面跟着一�D�代码，�q�是用来�q�行昑ּ�的静态变量初始化�Q�这�D�代码只会初始化一�ơ，且在�c�被�W�一�ơ装载时。如果你能读懂�ƈ理解�q�段代码�Q�会帮助你对static关键字的认识。在涉及到��承的时候，会先初始化父�cȝ��static变量�Q�然后是子类的，依次�c�L��。非静态变量不是本文的主题�Q�在此不做详�l�讨论，请参考Think in Java中的讲解�?br />静态类
通常一个普通类不允许声明�ؓ静态的�Q�只有一个内部类才可以。这时这个声明�ؓ静态的内部�c�d��以直接作��Z��个普通类来��用，而不需实例一个外部类。如下代码所�C�：
public class StaticCls{
  public static void main(String[] args){
    OuterCls.InnerCls oi=new OuterCls.InnerCls();
  }
}
class OuterCls{
  public static class InnerCls{
    InnerCls(){
      System.out.println("InnerCls");
    }
   }
}
输出�l�果会如你所料：
InnerCls
和普通类一栗��内部类的其它用法请参阅Think in Java中的相关章节�Q�此处不作详解�?br />二、this & super
    在上一��拙作中�Q�我们讨��Z��static的种�U�用法，通过用static来定义方法或成员�Q��ؓ我们�~�程提供了某�U�便利，从某�U�程度上可以说它�c�M��于C语言中的全局函数和全局变量。但是，�q�不是说有了�q�种便利�Q�你便可以随处��用，如果那样的话�Q�你侉K��要认真考虑一下自己是否在用面向对象的思想�~�程�Q�自��q��E�序是否是面向对象的。好了，现在开始讨论this&super�q�两个关键字的意义和用法�?br />在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西�Q�比如当前对象的某个�Ҏ��Q�或当前对象的某个成员，你便可以利用this来实现这个目的，当然�Q�this的另一个用途是调用当前对象的另一个构造函敎ͼ��q�些马上��p��讨论。如果你惛_��用父�cȝ��某种东西�Q�则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某�U�关�p�，所以我们在�q�一块儿来讨论，希望能帮助你区分和掌握它们两个�?br />在一般方法中
最普遍的情况就是，在你的方法中的某个�Ş参名与当前对象的某个成员有相同的名字�Q�这时�ؓ了不至于��h��Q�你侉K��要明��用this关键字来指明你要使用某个成员�Q��用方法是“this.成员名”，而不带this的那个便是�Ş参。另外，�q�可以用“this.�Ҏ��名”来引用当前对象的某个方法，但这时this��׃��是必��ȝ��了，你可以直接用�Ҏ��名来讉K��那个�Ҏ��Q�编译器会知道你要调用的是那一个。下面的代码演示了上面的用法�Q?br />public class DemoThis{
  private String name;
  private int age;
  DemoThis(String name,int age){
    setName(name); //你可以加上this来调用方法，像这��P��this.setName(name);但这�q�不是必��ȝ��
    setAge(age);
    this.print();
  }
  public void setName(String name){
    this.name=name;//此处必须指明你要引用成员变量
  }
  public void setAge(int age){
    this.age=age;
  }
  public void print(){
    System.out.println("Name="+name+" Age="+age);//在此行中�q�不需要用this�Q�因为没有会��D��h��的东�?br />  }
  public static void main(String[] args){
    DemoThis dt=new DemoThis("Kevin","22");
  }
}
�q�段代码很简单，不用解释你也应该能看明白。在构造函��C��你看到用this.print(),你完全可以用print()来代替它�Q�两者效果一栗��下面我们修改这个程序，来演�C�super的用法�?br />class Person{
  public int c;
  private String name;
  private int age;
  protected void setName(String name){
    this.name=name;
  }
  protected void setAge(int age){
    this.age=age;
  }
  protected void print(){
    System.out.println("Name="+name+" Age="+age);
  }
}
public class DemoSuper extends Person{
  public void print(){
    System.out.println("DemoSuper:");
    super.print();
  }
  public static void main(String[] args){
    DemoSuper ds=new DemoSuper();
    ds.setName("kevin");
    ds.setAge(22);
    ds.print();
  }
}
在DemoSuper中，重新定义的print�Ҏ��覆写了父�cȝ��print�Ҏ��Q�它首先做一些自��q��事情�Q�然后调用父�cȝ��那个被覆写了的方法。输出结果说明了�q�一点：
DemoSuper:
Name=kevin Age=22
�q�样的��用方法是比较常用的。另外如果父�cȝ��成员可以被子�c�访问，那你可以像��用this一样��用它�Q�用“super.父类中的成员名”的方式�Q�但常常你�ƈ不是�q�样来访问父�c�M��的成员名的�?br />在构造函��C��
构造函数是一�U�特�D�的�Ҏ��Q�在对象初始化的时候自动调用。在构造函��C��Q�this和super也有上面说的�U�种使用方式�Q��ƈ且它�q�有�Ҏ��的地方，��L��下面的例子：
class Person{
  public static void prt(String s){
    System.out.println(s);
  }
  Person(){
    prt("A Person.");
  }
  Person(String name){
    prt("A person name is:"+name);
  }
}
public class Chinese extends Person{
  Chinese(){
    super();  //调用父类构造函敎ͼ�1�Q?br />    prt("A chinese.");//(4)
  }
  Chinese(String name){
    super(name);//调用父类��h��相同形参的构造函敎ͼ�2�Q?br />    prt("his name is:"+name);
  }
  Chinese(String name,int age){
    this(name);//调用当前��h��相同形参的构造函敎ͼ�3�Q?br />    prt("his age is:"+age);
  }
  public static void main(String[] args){
    Chinese cn=new Chinese();
    cn=new Chinese("kevin");
    cn=new Chinese("kevin",22);
  }
}
在这�D늨�序中�Q�this和super不再是像以前那样用�?”连接一个方法或成员�Q�而是直接在其后跟上适当的参敎ͼ�因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同�Ş式的构造函敎ͼ��?�?处。this后加参数则调用的是当前具有相同参数的构造函敎ͼ��?处。当�Ӟ��在Chinese的各个重载构造函��C��Q�this和super在一般方法中的各�U�用法也仍可使用�Q�比�?处，你可以将它替换�ؓ“this.prt�?因�ؓ它��承了父类中的那个�Ҏ��Q�或者是“super.prt”（因�ؓ它是父类中的�Ҏ��且可被子�c�访问）�Q�它照样可以正确�q�行。但�q�样��g��有点画蛇添��的味道了�?br />最后，写了�q�么多，如果你能对“this通常指代当前对象�Q�super通常指代父类”这句话牢记在心�Q�那么本��便辑ֈ�了目的，其它的你自会在以后的�~�程实践当中慢慢体会、掌握。另外关于本��中提到的��承，请参阅相关Java教程�?br />三、final
final在Java中�ƈ不常用，然而它却�ؓ我们提供了诸如在C语言中定义常量的功能�Q�不仅如此，final�q�可以让你控制你的成员、方法或者是一个类是否可被覆写或��承等功能�Q�这些特点��final在Java中拥有了一个不可或�~�的��C��Q�也是学习Java时必��要知道和掌握的关键字之一�?br />final成员
当你在类中定义变量时�Q�在其前面加上final关键字，那便是说�Q�这个变量一旦被初始化便不可改变�Q�这里不可改变的意思对基本�c�d��来说是其��g��可变�Q�而对于对象变量来说其引用不可再变。其初始化可以在两个地方�Q�一是其定义处，也就是说在final变量定义时直接给其赋��|��二是在构造函��C��。这两个地方只能选其一�Q�要么在定义时给��|��要么在构造函��C��l��|��不能同时既在定义时给了��|��又在构造函��C��l�另外的倹{��下面这�D�代码演�C�Z��q�一点：
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
public class Bat{
    final PI=3.14;          //在定义时便给址�?br />    final int i;            //因�ؓ要在构造函��C��q�行初始化，所以此处便不可再给�?br />    final List list;        //此变量也与上面的一�?br />    Bat(){
        i=100;
        list=new LinkedList();
    }
    Bat(int ii,List l){
        i=ii;
        list=l;
    }
    public static void main(String[] args){
        Bat b=new Bat();
        b.list.add(new Bat());
        //b.i=25;
        //b.list=new ArrayList();
        System.out.println("I="+b.i+" List Type:"+b.list.getClass());
        b=new Bat(23,new ArrayList());
        b.list.add(new Bat());
        System.out.println("I="+b.i+" List Type:"+b.list.getClass());
    }
}
此程序很��单的演示了final的常规用法。在�q�里使用在构造函��C��q�行初始化的�Ҏ��Q�这使你有了一点灵�z�L��。如Bat的两个重载构造函数所�C�，�W�一个缺省构造函��C��Z��提供默认的��|��重蝲的那个构造函��C��Ҏ��你所提供的值或�c�d��为final变量初始化。然而有时你�q�不需要这�U�灵�z�L��，你只需要在定义时便�l�定其值�ƈ�怸�变化�Q�这时就不要再用�q�种�Ҏ��。在main�Ҏ��中有两行语句注释掉了�Q�如果你��L��注释�Q�程序便无法通过�~�译�Q�这便是��_��不论是i的值或是list的类型，一旦初始化�Q�确实无法再更改。然而b可以通过重新初始化来指定i的值或list的类型，输出�l�果中显�C�Z��q�一点：
I=100 List Type:class java.util.LinkedList
I=23 List Type:class java.util.ArrayList
�q�有一�U�用法是定义�Ҏ��中的参数为final�Q�对于基本类型的变量�Q�这样做�q�没有什么实际意义，因�ؓ基本�c�d��的变量在调用�Ҏ��时是传值的�Q�也��是说你可以在方法中更改�q�个参数变量而不会媄响到调用语句�Q�然而对于对象变量，却显得很实用�Q�因为对象变量在传递时是传递其引用�Q�这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量，当你在方法中不需要改变作为参数的对象变量�Ӟ��明确使用final�q�行声明�Q�会防止你无意的修改而媄响到调用�Ҏ��?br />另外�Ҏ��中的内部�c�d��用到�Ҏ��中的参变量时�Q�此参变也必��d��明�ؓfinal才可使用�Q�如下代码所�C�：
public class INClass{
   void innerClass(final String str){
        class IClass{
            IClass(){
                System.out.println(str);
            }
        }
        IClass ic=new IClass();
    }
  public static void main(String[] args){
      INClass inc=new INClass();
      inc.innerClass("Hello");
  }
}
final�Ҏ��
��方法声明�ؓfinal�Q�那��p��明你已经知道�q�个�Ҏ��提供的功能已�l�满��你要求�Q�不需要进行扩展，�q�且也不允许��M��从此�cȝ��承的�c�L��覆写�q�个�Ҏ��Q�但是��承仍然可以��承这个方法，也就是说可以直接使用。另外有一�U�被�U�Cؓinline的机�Ӟ��它会使你在调用final�Ҏ��Ӟ��直接��方法主体插入到调用处，而不是进行例行的�Ҏ��调用�Q�例如保存断点，压栈�{�，�q�样可能会��你的�E�序效率有所提高�Q�然而当你的�Ҏ��M��非常庞大�Ӟ��或你在多处调用此�Ҏ��Q�那么你的调用主体代码便会迅速膨胀�Q�可能反而会影响效率�Q�所以你要慎用final�q�行�Ҏ��定义�?br />final�c?br />当你��final用于�c��n上时�Q�你��需要仔�l�考虑�Q�因��Z��个final�c�L��无法被�Q何�h�l�承的，那也��意味着此类在一个��承树中是一个叶子类�Q��ƈ且此�cȝ��设计已被认�ؓ很完��而不需要进行修�Ҏ��扩展。对于final�c�M��的成员，你可以定义其为final�Q�也可以不是final。而对于方法，�׃��所属类为final的关�p�，自然也就成了final型的。你也可以明��的�l�final�c�M��的方法加上一个final�Q�但�q�显然没有意义�?br />下面的程序演�C�Z��final�Ҏ��和final�cȝ��用法�Q?br />final class final{
      final String str="final Data";
      public String str1="non final data";
      final public void print(){
           System.out.println("final method.");
      }
      public void what(){
             System.out.println(str+"\n"+str1);
     }
}
public class FinalDemo{//extends final无法�l�承
        public static void main(String[] args){
              final f=new final();
               f.what();
               f.print();
    }
}
从程序中可以看出�Q�final�c�M��普通类的��用几乎没有差别，只是它失��M��被��承的�Ҏ��。final�Ҏ��与非final�Ҏ��的区别也很难从程序行看出�Q�只是记住慎用�?br />final在设计模式中的应�?br />在设计模式中有一�U�模式叫做不变模式，在Java中通过final关键字可以很�Ҏ��的实现这个模式，在讲解final成员时用到的�E�序Bat.java��是一个不变模式的例子。如果你�Ҏ��感兴��，可以参考阎宏博士编写的《Java与模式》一书中的讲解�?br />到此为止�Q�this,static,supert和final的��用已�l�说完了�Q�如果你对这四个关键字已�l�能够大致说出它们的区别与用法，那便说明你基本已�l�掌握。然而，世界上的��M��东西都不是完��无�~�的�Q�Java提供�q�四个关键字�Q�给�E�序员的�~�程带来了很大的便利�Q�但�q�不是说要让你到处��用，一旦达到滥用的�E�序�Q�便适得其反�Q�所以在使用时请一定要认真考虑�?img src ="http://www.tkk7.com/os586/aggbug/65213.html" width = "1" height = "1" />

水煮三国 2006-08-23 10:15 发表评论

水煮三国 — Tue, 15 Aug 2006 02:41:00 GMT

其实我对建造者模式的理解�Q�倒是有些聚合合�ƈ的原则在里面�Q�这只是我个人的理解�Q?br />
但是对于建造者模式来��_��对于客户端来��_��相关的��品内部的元�g的徏立都是被隐藏的．我们通过相关的角色去完成产品对象及其元�g的徏立．

引用的一句话是这栯��的：一个导演者对象和具体建造者对象一个一个地建造出所有的零�g�Q�从而徏造出完整的��品对象．建造者模式将产品的结构和产品的零件徏造过�E�对客户端隐藏�v来，把对建造过�E�进行指挥的责�Q和具体徏造者零件的责�Q侵害开来．辑ֈ�责�Q划分和封装的目的�Q?br />

我觉得徏造者模式当中：相关角色的定义是最为重要的�Q�它们各司其职，而又互不�q�涉�Q?br />
抽象建造者角�Ԍ��它是一个抽象接口，�l�出了徏立相兛_��件的�Ҏ��及一个返回对象的�Ҏ��Q�这个接口必��ȝ��具体建造者角色来实现�Q?br />
具体建造者角�Ԍ��它有两个作用�Q�第一是实现抽象徏造者角色声明的�Ҏ��

�W�二��是提供产品对象的实例．

导演者角�Ԍ��它是一个中间�{换类�Q�它实现了构建相兛_��件的�Ҏ��Q�调用具体徏造者类�Q?br />
产品角色�Q�具体的产品�cȝ��实现�Q?br />

水煮三国 2006-08-15 10:41 发表评论

水煮三国 — Wed, 02 Aug 2006 08:09:00 GMT

J2EE相关站点(�Ƣ迎填加)
http://www.theserverside.com
权威的的J2EE站点�Q�有最新的消息发布和很多技术文章以及很好的论坛�Q�进行J2EE相关技术的全方位的讨论�Q�也有电子书可以下蝲�?br />
http://www.javaworld.com
很著名的国外的java技术站炏V��有一�D�|��间由于一些原因停止了更新�Q�不�q�不久前有开始了更新的工作�?br />
http://www-900.ibm.com/developerWorks/cn/java/index.shtml
IBM公司的developerWorks Java技术专区，有很多关于J2EE的技术文章，�q�且文章的质量很高�?br />
http://www.jdon.com
国内不错的J2EE技术站点，有很多技术文章和源代码。以前推��汉化的JIVE版本�Q�现在有了自��q��J2EE框架产品�?br />
http://www.huihoo.com
专注于中间�g技术的站点和论坛，国内开源��Y件做的相当不错的�l�织�Q�推��Z��自己的J2EE服务器��品JFox以及相关的OpenSource 产品�?br />
http://gceclub.sun.com.cn
SUN的中文技术社区，有SUN 的技术�h员的支持�l�护�Q�很多不错的文章�Q�在�U�讲堂栏目办的很有特艌Ӏ�推��Z��新版的技术论坛，但是人气一直不是很旺�?br />
http://www.cnjsp.org
以前做过JSP的论坛，现在定位于Java技术服务，提供一些J2EE的技术文章，�q�不错�?br />
http://www.chinajavaworld.net
应该是国内最著名和热门的java技术站点了�Q�有很j2ee的信息和技术文章和很好的论坛�?br />
http://www.csdn.net
�E�序员都知道的网�?)也把它列�q�来。有最新的java业界动态和技术文章可以查找�?br /> �q�两个网站都是台湄��的所以都是繁体中文，不过�q�不影响大家的阅读速度�?br />
http://www.javaworld.com.tw

http://www.caterpillar.onlyfun.net/phpBB2/index.php

Java学习�|�站
http://www-900.ibm.com/developerWorks/cn/java/index.shtml IBM的JAVA专题——永�q�的蓝色巨�h
http://www.huihoo.com   灰狐动力——Enterprise Open Source
http://www.jdon.com   J道——JAVA和J2EE解决之道
http://www.chinaunix.net   ChinaUnix——我们在努力打造一个Unix时代�Q?
http://www.theserverside.com   TheServerSide.COM——Your Enterprise Java Community
http://www.onjava.com   O'REILLY ON java.com
http://www.matrix.org.cn   Matrix与Java��p��
http://www.java-source.net   JavaSource
http://www.javaresearch.org   Java研究�l�织——汇聚技术精�?增进技术交��?
http://www.cn-java.com   中文Java技术网——�ؓJava爱好者服�?
http://www.javalobby.org   JavaLobby
http://www.javajia.com   Java�?
http://www.cnjavaclub.com   中国JAVA�׃��?
http://www.jspcn.net   JSP中文�|?
http://www.cnjsp.org   中国JSP技术网�?
http://www.xuejava.com   学Java——学习Java的精�?
http://tech.ccidnet.com   赛��_�|�技术天�?
http://www.uml.org.cn   UML软�g工程�l�织
http://dev2dev.bea.com.cn/index.jsp   BEAdev2dev在线
http://www.kissjava.com   爪哇��氓
http://java.about.com   来自About.com的Java新闻和技术文�?
http://www.jcp.org/en/home/index   Java Community Process
http://www.java-cn.com   Java中文站——每一天我们都在进�?
http://www.chedong.com/   车东
http://www.javayou.com/   Java自由�?
http://www.j2medev.com/   J2ME开发网

http://www.javadown.com.cn
http://www.java.net/

Java技术论坛�?
http://bbs.chinajavaworld.com      ChinaJavaWorld技术论�?
http://www.javaworld.com.tw/jute/index.html   JavaWorld技术论�?
http://forum.javaeye.com   Java视线论坛
http://www.jdon.com/jive/index.jsp   J道论�?
http://gceclub.sun.com.cn/NASApp/sme/jive/index.jsp   Sun技术社��?
http://www.cjsdn.com   中国Java开发网
http://spring.jactiongroup.net   SpringFramework中文论坛
http://www.cartexpert.com/forum/forum.jsp?column=24   Jive研究论坛
http://www.javafan.net/jive/index.jsp   JavaFan论坛

Java优秀Blog
javazhai.mblogger.cn
http://blog.donews.com/redtroy/
http://blog.csdn.net/casularm   Casularm Blog
http://hedong.3322.org   竹笋炒肉
http://blog.csdn.net/baijsp   Java and OpenSource Software
http://leosky.java.mblogger.cn   leo的Blog
http://java2guru.java.mblogger.cn   J2EE Blog
http://blog.csdn.net/chenyun2000   Open Java Project
http://gigix.blogdriver.com/gigix/index.html   透明思�?
http://blog.tomxp.com/Home.html   东�L的Blog
http://blog.csdn.net/liaoxingya276   liaoxingya的Blog
http://blog.csdn.net/arielxp   !Java
http://www.nncn.com/blog/weblog.php   HuiFei's Blog
http://www.donews.net/yahoo163/   BlogJava

Java热门QQ��?
6927954   Java爱好者 �?5747018   Java开源框架研�I?
2184090   Java最后通道   5464040   Java技术交��?
6090680   Java讨论�l� �?6868040   Java讨论�?
2848217   Java技术交�� ?5287881   Java�C�֛�
3057466   Java世界   3657130   Java夜未�?
4874250   Java开发者 �?6522650   Java联盟
4972763   Java爱好者 �?6880123   Java技术交��?
2473372   Java学习班 �?6347116   Java学院
3049837   Java人生路 �?1407900   Java爱好�?
2371661   Java最爱 �?7096701   Java思想与技�?
4421567   Java菜鸟交流室 �?3493424   Java学习�?
1822386   Java学习��组   3905714   Java乐园
4085683   Java疯狂�~�程   5718771   Java�C�֌�
4578000   Jsp技术群   4384534   Jsp学习�l?
4617990   Jsp学习班 �?1845656   Jsp爱好�?
2493314   Jsp交流中心   3241217   Jsp专题学习
6788666   Jsp爱好者 �?3417234   Jsp交流
7378475   开发联盟Jsp学习   2347397   Java和Jsp技术讨�?
1020937   Jsp   1693379   Jsp
200016    J2ME   4453572   J2ME
6074752   J2ME   4835602   J2ME
1772284   J2ME   155348    开发联�?WAP J2ME

源代码下�?
��Z��j2ee�q�_��的大型电子商务网站源代码下蝲 :

本源代码可以帮助大家了解大型物品买卖和交换网站如淘宝�Q�易宝乐�{�网站的开发和创徏�?br />下蝲地址: http://www.ebaole.com/sourcedown.html
�q�且开辟了一个社��Z��门�ؓ大家提供源代码的交流和讨�?

Online Resources for Java Programmers

The Web offers many resources to help you use the Java platform. This section lists some that we use ourselves, or that we've heard good things about.

Caveat: A Web site that's good one year might stagnate the next, and it can be difficult to tell unless you know the site well. Please tell us if any of these Web sites is obsolete, or if you have a URL for an excellent resource not mentioned here.

We list three kinds of resources:

General Programming Resources

Web sites that provide information useful to most developers.

Specialized Programming Resources

Sources of more specialized programming information. Examples include assorted tutorials, The Swing Connection, and a Web site for Macintosh programmers.

Other Resources

Other stuff, such as the latest industry news.

Don't forget that our Tutorial has many examples, and that you can search all the java.sun.com tutorials . Another source of resources is the Help section of java.sun.com.

General Programming Resources

The Java Developer Connection^SM
http://developer.java.sun.com
Essential. Here are some of the things you can do at the JDC:
research bugs
vote for which bugs should be fixed first
view tutorials and book samples
download early access software
chat with developers and API architects
Code Conventions
http://java.sun.com/docs/codeconv/
Conventions that developers within Sun try to follow when writing programs in the Java programming language.
About.com Focus on Java
http://java.about.com
Has articles and links to many resources.
JavaWorld Magazine
http://www.javaworld.net
Has articles about current programming topics.
Java Boutique
http://javaboutique.internet.com
Has applets (some including source code), tutorials, book reviews, and more.
Java Developer's Journal
http://www.sys-con.com/java/
An online subset of a print magazine. Includes source code and selected articles.

Specialized Programming Resources

The J2EE^TM Tutorial
http://java.sun.com/j2ee/tutorial/index.html
A beginner's guide to developing enterprise applications on the Java 2 Platform, Enterprise Edition SDK.
Java 3D^TM API Tutorial
http://java.sun.com/products/java-media/3D/collateral/
Has descriptions and examples of the most commonly used features in the Java 3D API.
XML Technologies
http://java.sun.com/xml/tutorial_intro.html
Introduces XML and tells you how to use the Java XML APIs.
The JNDI Tutorial
http://java.sun.com/products/jndi/tutorial/
Tells you how to use the Java^TM Naming and Directory Interface (JNDI) for associating names and attributes with objects.
JDC Tutorials
http://developer.java.sun.com/developer/onlineTraining/
Many tutorials, covering a wealth of topics. Subjects include JavaBeans, Enterprise JavaBeans, JDBC, and Java 2D.
The Swing Connection
http://java.sun.com/products/jfc/tsc/
The Swing engineering team's Web site. Has articles written both by Swing creators and by external programmers who use Swing.
The Swing/JFC FAQ
http://www.drye.com/java/faq.html
Unofficial answers to frequently asked questions about Swing.
Apple's Developer Site
http://developer.apple.com/java/
For programmers who use Macs.

Other Resources

How To Write Unmaintainable Code
http://mindprod.com/unmain.html
Long, funny essay on how (not) to write code that no one else can read.
Slashdot
http://slashdot.org/search.pl?topic=108
News and discussions about the Java platform.

水煮三国 2006-08-02 16:09 发表评论

水煮三国 — Wed, 02 Aug 2006 07:41:00 GMT

Java接口当中有一个类型�ؓ帔R��接口�Q�我在网上看到有些�h不提倡��用这�U�方式。具体的原因也没怎么�Ԍ��但是在这里我�q�是想与大家讨论一下这个接口方式的使用�?br />
希望有对此接口��用方式有深刻了解的网友能够多提意见：

今天朋友发来邮�g谈�v�q�种接口方式�Q�说她写的程序当中的最后一句有错，�?我帮着看看�Q�下面是�q�段�E�序的源�?br />
interface Math
{
  double PI=3.1415926;
}
class Arithmetic implements Math
{
  double roudeArea(double radius)
     {
         return PI*radius*radius;
     }
}
class Student
{
   public static void main(String[] args)
     {
       Arithmetic a=new Arithmetic();
       System.out.println(a.roudeArea(3));
       System.out.println(Math.PI);
       System.out.println(Arithmetic.PI);
       System.out.println(a.PI);
      }
}

我在eclipse里面看了�Q�是一个警告原因就在于她用a.PI来取得常量值的方式的警告�?br />
其实原因很简单，��是一个静态字�D�需要在一个静态方法中使用的警告�?br />
看了�q�段代码后，我发现其实她使用帔R��接口的作用已�l�在实现了接口Maths的类中体现。就是我们可以在实现帔R��接口的类中直接��用常量而不必加上前面的对象�Q�当然��用Math.PI也是对的�Q�不�q��ؓ了方便我们可以在�q�个�c�d��中直接��用PI��M��替它�?br />
同样我们也可以��用类Arithmetic当中的PI�Q�我们可以直接引用arithmetic.PI,但是我们不能够��用a.PI

�c�d��中的帔R��定义对其它类来说是可见可用的�Q�他的��用可以以 �c�d��.帔R��?卛_��

而接口当中：对其它类来说是不可见的，除非我们需要去实现�q�个接口�Q�只有实现它我们才可以直接��?帔R��?的方�?br />
帔R��接口当中定义的常量，在实现这个接口的�c�d��中可以直接拿来��用。它里面没有相关属性和其它�Ҏ��。还有一点就是：帔R��在��用�v来更为简�z��?br />

水煮三国 2006-08-02 15:41 发表评论

JAVA 当中接口的��用�ȝ��

水煮三国 — Wed, 02 Aug 2006 07:22:00 GMT

转自Cnblogs.com

法则2�Q�针�Ҏ��口编�E�，而非�Q�接口的�Q�实�?/span>

[ Program To An Interface, Not An Implementation ]

接口

n 接口是一个对象在对其它的对象�q�行调用时所知道的方法集合�?/span>

n 一个对象可以有多个接口�Q�实际上�Q�接口是对象所有方法的一个子集）

n �c�d��是对象的一个特定的接口�?/span>

n 不同的对象可以具有相同的�c�d��Q�而且一个对象可以具有多个不同的�c�d��?/span>

n 一个对象仅能通过其接口才会被其它对象所了解�?/span>

n 某种意义上，接口是以一�U�非常局限的方式�Q�将“是一�U?/span>�?/span>”表达�ؓ“一�U�支持该接口�?/span>�?/span>”�?/span>

n 接口是实现插件化�Q?/span>pluggability�Q�的关键

实现�l�承和接口��?/span>

n 实现�l�承�Q?i>�cȝ��?/i>�Q�：一个对象的实现是根据另一个对象的实现来定义的�?/span>

n 接口�l�承�Q?i>子类型化�Q�：描述了一个对象可在什么时候被用来替代另一个对象�?/span>

n C++的��承机制既指类�l�承�Q�又指接口��ѝ�?/span>

n C++通过�l�承�U�虚�c�L��实现接口�l�承�?/span>

n Java�Ҏ��口��承具有单独的语言构造方式－Java接口�?/span>

n Java接口构造方式更加易于表辑֒�实现那些专注于对象接口的设计�?/span>

接口的好�?/span>

n 优点�Q?/span>

F Client不必知道其��用对象的具体所属类�?/span>

F 一个对象可以很�Ҏ��地被�Q�实��C��相同接口的）的另一个对象所替换�?/span>

F 对象间的�q�接不必��绑定（hardwire�Q�到一个具体类的对象上�Q�因此增加了灉|��性�?/span>

F 松散藕合�Q?/span>loosens coupling�Q��?/span>

F 增加了重用的可能性�?/span>

F 提高了（对象�Q�组合的机率�Q�因��包含对象可以是�Q何实��C��一个指定接口的�c�R�?/span>

n �~�点�Q?/span>

F 设计的复杂性略有增�?/span>

�Q�译者注�Q�接口表�C��?/span>�?/span>�?/span>�?/span>”（LikeA�Q�的关系�Q��承表�C��?/span>�?/span>�?/span>�?/span>”（IsA�Q�的关系�Q�组合表�C��?/span>�?/span>�?/span>�?/span>”（HasA�Q�的关系。）

接口实例

该方法是指其它的一些类可以�q�行交通工��L��N��Q�而不必关心其实际上是�Q�汽车，轮船�Q�潜艇或是其它�Q何实��C��IManeuverabre的对象）�?/span>

水煮三国 2006-08-02 15:22 发表评论

水煮三国 — Tue, 01 Aug 2006 01:06:00 GMT

final�Q?br />final可以让你控制你的成员、方法或者是一个类是否可被覆写或��承等功能�Q�这些特点��final在Java中拥有了一个不可或�~�的��C��Q�也是学习Java时必��要知道和掌握的关键字之一�?br />final成员
当你在类中定义变量时�Q�在其前面加上final关键字，那便是说�Q�这个变量一旦被初始化便不可改变�Q�这里不可改变的意思对基本�c�d��来说是其��g��可变�Q�而对于对象变量来说其引用不可再变。其初始化可以在两个地方�Q�一是其定义处，二是在构造函��C��Q�两者只能选其一�?br />下面�E�序很简单的演示了final的常规用法：
public class Test{
    final int t = 1; // 在定义时�l��?br />    // 或者（两者只能选其一�Q?br />    final int t;
    public Test(){
        t = 3; // 构造时�l��?br />}
}

�q�有一�U�用法是定义�Ҏ��中的参数为final�Q�对于基本类型的变量�Q�这样做�q�没有什么实际意义，因�ؓ基本�c�d��的变量在调用�Ҏ��时是传值的�Q�也��是说你可以在方法中更改�q�个参数变量而不会媄响到调用语句�Q�然而对于对象变量，却显得很实用�Q�因为对象变量在传递时是传递其引用�Q�这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量，当你在方法中不需要改变作为参数的对象变量�Ӟ��明确使用final�q�行声明�Q�会防止你无意的修改而媄响到调用�Ҏ��?br />另外�Ҏ��中的内部�c�d��用到�Ҏ��中的参变量时�Q�此参变也必��d��明�ؓfinal才可使用�Q�如下代码所�C�：
public class Test{
   void print(final String str){
        class InnerTest{
            InnerTest (){
                System.out.println(str);
            }
        }
        InnerTest it=new InnerTest ();
    }
  public static void main(String[] args){
      Test test=new Test();
      test.print("Hello word!!!");
  }
}
final�Ҏ��
��方法声明�ؓfinal那有两个原因�Q�第一��是说明你已�l�知道这个方法提供的功能已经满��你要求，不需要进行扩展，�q�且也不允许��M��从此�cȝ��承的�c�L��覆写�q�个�Ҏ��Q�但是��承仍然可以��承这个方法，也就是说可以直接使用。第二就是允许编译器��所有对此方法的调用转化为inline�Q�行内）调用的机�Ӟ��它会使你在调用final�Ҏ��Ӟ��直接��方法主体插入到调用处，而不是进行例行的�Ҏ��调用�Q�例如保存断点，压栈�{�，�q�样可能会��你的�E�序效率有所提高�Q�然而当你的�Ҏ��M��非常庞大�Ӟ��或你在多处调用此�Ҏ��Q�那么你的调用主体代码便会迅速膨胀�Q�可能反而会影响效率�Q�所以你要慎用final�q�行�Ҏ��定义�?br />final�c?br />当你��final用于�c��n上时�Q�你��需要仔�l�考虑�Q�因��Z��个final�c�L��无法被�Q何�h�l�承的，那也��意味着此类在一个��承树中是一个叶子类�Q��ƈ且此�cȝ��设计已被认�ؓ很完��而不需要进行修�Ҏ��扩展。对于final�c�M��的成员，你可以定义其为final�Q�也可以不是final。而对于方法，�׃��所属类为final的关�p�，自然也就成了final型的。你也可以明��的�l�final�c�M��的方法加上一个final�Q�但�q�显然没有意义�?br />
finally:
finally 关键字是对 Java 异常处理模型的最佌��充。 finally �l�构使代码��M��执行�Q�而不��有无异常发生。��用 finally 可以�l�护对象的内部状态，�q�可以清理非内存资源。如果没有 finally�Q�您的代码就会很费解。例如，下面的代码说明，在不使用 finally 的情况下您如何编写代码来释放非内存资源：

public void writeFile(String filePath, String fileName, String args)
            throws IOException

    {

        FileWriter fw = new FileWriter(filePath + fileName);
        try {

            fw.write(args);
        } catch (IOException e) {
            //1
            fw.close();
            throw e;
        }
//2
        fw.close();
    }
�q�段代码创徏了一个FileWriter object�Q��ƈ调用 write �Ҏ��。在退��Ҏ��之前�Q�您必须关闭FileWriter object�Q�以避免资源漏洞。�ؓ了完成这一��d��Q�我们在 //2 处调用 close�Q�它是该�Ҏ��的最后一条语句。但是，如果 try 块中发生一个异�怼�怎么样呢�Q�在�q�种情况下，//2 处的 close 调用永远不会发生。因此，您必��L��莯��个异常，�q�在重新发出�q�个异常之前在�?/1 处插入对 close 的另一个调用。这样就可以��保在退��Ҏ��之前关闭FileWriter object。这��L��写代码既�ȝ��又易于出错，但在没有 finally 的情况下�q�是必不可少的。有了 finally�Q�前面的代码��可以重写�ؓ以下的�Ş式：

public void writeFile(String filePath, String fileName, String args)
            throws IOException

    {

        FileWriter fw = new FileWriter(filePath + fileName);
        try {

            fw.write(args);
        } catch (IOException e) {
            throw e;
        } finally {

            fw.close();
        }
    }
finally 块确保 close �Ҏ��总被执行�Q�而不�� try 块内是否发出异常。因此，可以��保在退��Ҏ��之前��M��调用 close �Ҏ��。这��h��可以确信FileWriter object被关闭�ƈ且您没有泄漏资源�?br />
finalize�Q��?br />
　　�Ҏ��Java语言规范�Q�JVM保证调用finalize函数之前�Q�这个对象是不可辄��Q�但是JVM不保证这个函��C��定会被调用。另外，规范�q�保证finalize函数最多运行一�ơ�?br />
　　通常�Q�finalize用于一些不�Ҏ��控制、�ƈ且非帔R��要资源的释放�Q�例如一些I/O的操作，数据的连接。这些资源的释放�Ҏ��个应用程序是非常关键的。在�q�种情况下，�E�序员应该以通过�E�序本��n��理(包括释放)�q�些资源��Z��Q�以finalize函数释放资源方式��Q��Ş成一�U�双保险的管理机�Ӟ��而不应该仅仅依靠finalize来释放资源�?img src ="http://www.tkk7.com/os586/aggbug/61124.html" width = "1" height = "1" />

水煮三国 2006-08-01 09:06 发表评论

水煮三国 — Tue, 01 Aug 2006 00:58:00 GMT

转自JR-研究

1.final value:
�? �c�Thread中的　�Q��?br />public static final int MAX_PRIORITY = 10;
// MAX_PRIORITY的��g��能再修改,之所以称为final value,是因为此处�ؓprimitive type

2.final reference:
�? public final String str = "This is a string";
// 指的是Object reference 为final,str不能再改而指向其他的对象,但其指向的对象�ƈ不一定不能改�?

�?
1>我们�怼�看见函数参数或局部变量常被声明�ؓfinal,�Ҏ��变量是primitive�q�是reference区别考虑.
2>.在局部内部类(local inner class)和匿名内部类(anonymous inner class)中不但可以访问外�cȝ��成员(包括成员变量和成员函�?,�q�可以访问外�cȝ��final 变量.

3.final class:
�?public final class URL extends Object implements Serializable
//指URL�c�M��能被�l�承,cannot be subclassed.

4.final method:
�? �c�Thread中的 :　
public final void setPriority(int newPriority)
//指此�Ҏ��不能被子�c�override,final class 中的所有方法都自动为final

水煮三国 2006-08-01 08:58 发表评论

JAVA中内部类的��用�ȝ��

水煮三国 — Tue, 01 Aug 2006 00:53:00 GMT

内部�cȝ��使用�Q?/p>

内部�cȝ��使用的优�~�点�Q?/p>

优点�Q�减��了在类文�g�~�译后的产生的字节码文�g的大��?br /> �~�点�Q��ɽE�序�l�构不清�?/p>

使用内部�cȝ��注意事项�Q?/p>

内部�cȝ��使用一般都与所在的外部�c�L��一定的兌��Q�它是在一个类的内部嵌套定义的�c�，它可以是其它�cȝ��成员�Q�也可以在一个语句块的内部定义，�q�可以在表达式内部匿名定�?匿名内部�c?�?/p>

内部�c�L��如下的特性：

.一般用在定义它的类或语句块之内�Q�在外部引用它时必须�l�出完整的名�U�ͼ�名字不能与包含它的数癑֐�相同

. 可以使用包含它的�cȝ��表态和实例成员变量�Q�也可以使用它所在方法的局部变�?/p>

.可以定义为abstract

.若被声明为static,��变成了��层�c�，不能再��用局部变�?/p>

.若想在inner class 中声明�Q何static成员�Q�则该inner class必须声明为static.

.匿名�c�L��一�U�特�D�的内部�c�，它是在一个表辑ּ�的内部包含一个完整的�cȝ��定义。匿名内部类不需要�Q何的修饰词�?/p>

.内部�c�d��以��用�Q何听修饰�W�，但是如果声明为static�c�，则等同于一个标准类�?/p>

.如果非表态内部类�Q�就拥有对外部类的所有成员的完全讉K��权限�Q�包括实例字�D�和�Ҏ��。�ؓ实现�q�一行�ؓ�Q�非表态内部类存着对外部类的实例的一个隐匿的引用�?/p>

.所以对一个非表态内部类�q�行实例化需要采用不同语法的new 语句�Q�这�U�开工的new 语句要求外部�cȝ��一个实例，使内部类能在那个实例的上下文中创建�?/p>

.非表态内部类��h��一些限制。尤其是�Q�它们不能声明表态初始化列表和表态成员，除非是在帔R��字段中。此外方法内部声明的内部�c�M��能访问方法的局部变量和参数�Q�除非它们被初始化成final.

.表态内部类当中可以有表态数据，表态方法或者是又一个表态内部类。而非表态内部类当中不能有静态数据。这是它们的区别�?/p>

.局部内部类�Q�Java内部�c�M��可以是局部的�Q�它可以定义在一个方法甚至一个代码块之内�?/p>

有一炚w��要注意的是，匿名内部�cȝ��于没有名字，所以它没有构造函敎ͼ�但是如果�q�个匿名内部�cȝ��承了一个只含有带参数构造函数的父类�Q�创建它的时候必��d��上这些参敎ͼ��q�在实现的过�E�中使用super关键字调用相应的内容�Q�。如果你惌��初始化它的成员变量，有下面几�U�方法：

　　如果是在一个方法的匿名内部�c�，可以利用�q�个�Ҏ��传进你想要的参数�Q�不�q�记住，�q�些参数必须被声明�ؓfinal�?

　　��匿名内部类攚w��成有名字的局部内部类�Q�这样它��可以拥有构造函��C��?

　　在这个匿名内部类中��用初始化代码块�?

　　��Z��么需要内部类�Q?

　　java内部�c�L��什么好处？��Z��么需要内部类�Q?/p>

　　首先举一个简单的例子�Q�如果你惛_��C��个接口，但是�q�个接口中的一个方法和你构想的�q�个�c�M��的一个方法的名称�Q�参数相同，你应该怎么办？�q�时候，你可以徏一个内部类实现�q�个接口。由于内部类对外部类的所有内定w��是可讉K��的，所以这样做可以完成所有你直接实现�q�个接口的功能�?/p>

　　不过你可能要质疑�Q�更改一下方法的不就行了吗？

　　的确�Q�以此作��计内部类的理由，实在没有说服力�?/p>

　　真正的原因是�q�样的，java中的内部�c�d��接口加在一��P��可以的解军_��被C++�E�序员抱怨java中存在的一个问题——没有多�l�承。实际上�Q�C++的多�l�承设计��h��很复杂，而java通过内部�c�d��上接口，可以很好的实现多�l�承的效果�?br />

下面是��用内部类的几个小例子�Q?br />
JAVA的内部类的构造方法是不会自动调用�Q�必��d��外部�c�d��中的某个�Ҏ��当中或构造函数当中显�C��用才能够正确使用�?/p>

   Class Outer{

        public outer(){
System.out.println("....");
       }

Class Inner{

public Innter(){

System.out.println("inner");
}
}

public static void Main(String[] args){

Outer a = new Outer();
}
}

�q�种使用�Ҏ��不会关系到内部类的输出。因为它�q�没有显�C��用内部类�?br />所以我们应该进行这��L��修改�Q?/p>

在Outer构造函��C��加入 Innter b = new Innter();
��可以直接调用它的输出或�Ҏ��体了�?/p>

不过我们�l�常使用的还是匿名内部类�Q?/p>

class Outer{

Outer(){

(new Inner(){
  public void print(){
   System.out.println("Inner");
   }
  }
).print();
System.out.println("Outer");
       }
}

下面是JAVA的一个源码��用了匿名内部�c�：
/**
* "Tokenizes" the entire stream as a single token.
*/
public class KeywordAnalyzer extends Analyzer {
public TokenStream tokenStream(String fieldName,
final Reader reader) {
return new TokenStream() {
private boolean done;
private final char[] buffer = new char[1024];
public Token next() throws IOException {
if (!done) {
done = true;
StringBuffer buffer = new StringBuffer();
int length = 0;
while (true) {
length = reader.read(this.buffer);
if (length == -1) break;
buffer.append(this.buffer, 0, length);
}
String text = buffer.toString();
return new Token(text, 0, text.length());
}
return null;
}
};
}
}

水煮三国 2006-08-01 08:53 发表评论

水煮三国 — Mon, 31 Jul 2006 08:35:00 GMT

在没有好好地研习面向对象设计的设计模式之前，我对Java接口和Java抽象�cȝ��认识�q�是很模�p�，很不可理解�?/p>

刚学Java语言�Ӟ��很隄��解�ؓ什么要有接口这个概念，虽说是可以实现所谓的多��承，可一个只有方法名�Q�没有方法体的东西，我实现它又有什么用呢？我从它那什么也得不刎ͼ�除了一些方法名�Q�我直接在具体类里加入这些方法不��p��了吗�Q?/p>

��Z��么一定要有抽象类�q�个概念�Q��ؓ什么就不能把这个父�c�d��成一个具体的�c�，子类再��承它不就可以了吗�Q�何必弄一个抽象类出来�Q�还要弄一些没有方法体的抽象方法，弄得又象接口又象�cȝ��Q�让人捉�怸�定�?/p>

当我开始学习java设计模式�Q�真正走�q�面向对象设计的大门之后�Q�我才发玎ͼ�自己寚w��向对象设计的理解原来是那么的片面�Q�那么的肤浅�Q�根本就没有真正理解面向对象思想的精髓，在某一�U�程度上�q�受着面向�q�程的媄响，以�ؓ弄出了一个个�c�，��q��是面向对象了�Q�而其实还是被�q�程所�׃��着�?/p>

我还是说说我现在寚w��向对象思想的理解吧�Q�不一定正��全面，但我惛_��该还��是比以前略有进步吧�?/p>

面向对象思想�Q�我觉得最关键的就是抽象�?/strong>

一个��Y件设计的好坏�Q�我惛_��大程度上取决于它的整体架构，而这个整体架构其实就是你�Ҏ��个宏观商业业务的抽象框架�Q�当代表业务逻辑的高层抽象层�l�构合理�Ӟ��你底层的具体实现需要考虑的就仅仅是一些算法和一些具体的业务实现了。当你需要再开发另一个相�q�的��目�Ӟ��你以前的抽象层说不定�q�可以再�ơ利用呢�Q�面对对象的设计�Q�复用的重点其实应该是抽象层的复用，而不是具体某一个代码块的复用，是不是一下子感觉自己对复用理解的高度又上升了一层？^_^

说到了抽象，我就不能不提到曾让我头痛的Java接口和Java抽象�c�M��Q�这也是本文我想说的重点�?/p>
既然面向对象设计的重点在于抽象，那Java接口和Java抽象�c�d��有它存在的必然性了�?/p>
Java接口和Java抽象�c�M��表的��是抽象�c�d��Q�就是我们需要提出的抽象层的具体表现。OOP面向对象的编�E�，如果要提高程序的复用率，增加�E�序的可�l�护性，可扩展性，��必��L��面向接口的编�E�，面向抽象的编�E�，正确��C��用接口、抽象类�q�些太有用的抽象�c�d��做�ؓ你结构层�ơ上的顶层�?/p>
Java接口和Java抽象�c�L��太多�怼�的地方，又有太多特别的地方，�I�竟在什么地方，才是它们的最佳位�|�呢�Q�把它们比较一下，你就可以发现了�?/p>
1、Java接口和Java抽象�c�L��大的一个区别，��在于Java抽象�c�d��以提供某些方法的部分实现�Q�而Java接口不可以，�q�大概就是Java抽象�c�d��一的优点吧�Q�但�q�个优点非常有用�?br />如果向一个抽象类里加入一个新的具体方法时�Q�那么它所有的子类都一下子都得��C��q�个新方法，而Java接口做不到这一点，如果向一个Java接口里加入一个新�Ҏ��Q�所有实现这个接口的�c�d��无法成功通过�~�译了，因�ؓ你必��让每一个类都再实现�q�个�Ҏ��才行�Q�这昄��是Java接口的缺炏V�?/p>
2、一个抽象类的实现只能由�q�个抽象�cȝ��子类�l�出�Q�也��是��_��q�个实现处在抽象�c�L��定义出的�l�承的等�U�结构中�Q�而由于Java语言的单�l�承性，所以抽象类作�ؓ�c�d��定义工具的效能大打折扣�?br />在这一点上�Q�Java接口的优势就出来了，��M��一个实��C��一个Java接口所规定的方法的�c�都可以��h��q�个接口的类型，而一个类可以实现��L��多个Java接口�Q�从而这个类��有了多�U�类型�?/p>
3、从�W?点不隄��出，Java接口是定义�؜合类型的理想工具�Q��؜合类表明一个类不仅仅具有某个主�c�d��的行为，而且��h��其他的次要行为�?/p>
4、结�?�?点中抽象�c�d��Java接口的各自优势，��L��典的设计模式��出来了�Q�声明类型的工作仍然由Java接口承担�Q�但是同时给��Z��个Java抽象�c�，且实��C��q�个接口�Q�而其他同属于�q�个抽象�c�d��的具体类可以选择实现�q�个Java接口�Q�也可以选择�l�承�q�个抽象�c�，也就是说在层�ơ结构中�Q�Java接口在最上面�Q�然后紧跟着抽象�c�，哈，�q�下两个的最大优炚w��能发挥到极至了。这个模式就是“缺省适配模式”�?br />在Java语言API中用了这�U�模式，而且全都遵��@一定的命名规范�Q�Abstract �Q�接口名�?/p>
Java接口和Java抽象�cȝ��存在��是��Z��用于具体�cȝ��实现和��承的�Q�如果你准备写一个具体类�ȝ��承另一个具体类的话�Q�那你的设计��有很大问题了。Java抽象�c�d��是�ؓ了��承而存在的�Q�它的抽象方法就是�ؓ了强制子�c�d��d��实现的�?/p>
使用Java接口和抽象Java�c�进行变量的�c�d��声明、参数是�c�d��声明、方法的�q�还�c�d��说明�Q�以及数据类型的转换�{�。而不要用具体Java�c�进行变量的�c�d��声明、参数是�c�d��声明、方法的�q�还�c�d��说明�Q�以及数据类型的转换�{��?/font>

我想�Q�如果你�~�的代码里面�q�一个接口和抽象�c�都没有的话�Q�也许我可以说你�Ҏ��没有用到��M��设计模式�Q��Q何一个设计模式都是和抽象分不开的，而抽象与Java接口和抽象Java�c?/font>又是分不开的�?/p>
理解抽象�Q�理解Java接口和抽象Java�c�，我想��应该是真正开始用面向对象的思想��d��析问题，解决问题了吧

水煮三国 2006-07-31 16:35 发表评论

转：使用Java中的final变量需要注意的地方

水煮三国 — Fri, 28 Jul 2006 01:36:00 GMT

对与java中的final变量�Q�java�~�译器是�q�行了优化的。每个��用了final�c�d��变量的地斚w��不会通过�q�接而进行访问。比如说Test�c�M��使用了Data�c�M��一个final的int数字fNumber=77�Q�这时候，java�~�译器会��?7�q�个常数�~�译到Test�cȝ��指��o码或者常量池中。这��P��每次Test�cȝ��到fNumber的时候，不会通过引用�q�接到Data�c�M��q�行��d��Q�而是直接使用自己保存在类文�g中的副本�?

对与java中的final变量�Q�java�~�译器是�q�行了优化的。每个��用了final�c�d��变量的地斚w��不会通过�q�接而进行访问。比如说Test�c�M��使用了Data�c�M��一个final的int数字fNumber=77�Q�这时候，java�~�译器会��?7�q�个常数�~�译到Test�cȝ��指��o码或者常量池中。这��P��每次Test�cȝ��到fNumber的时候，不会通过引用�q�接到Data�c�M��q�行��d��Q�而是直接使用自己保存在类文�g中的副本�?br />用程序说话：
Test.java:

public class Test{
public static void main(String[] args){
System.out.println(Data.fNumber);
}
}

Data.java:

public class Data{
public static final int fNumber=77;
}

执行命��o和结果：

Microsoft Windows XP [版本 5.1.2600]
(C) 版权所�?1985-2001 Microsoft Corp.

C:\Documents and Settings\zangmeng>cd ..

C:\Documents and Settings>cd ..

C:\>javac Test.java

C:\>java Test
77

C:\>

�q�时候，我们更改Data.java的内容：
public class Data{
public static final int fNumber=777;
}

然后执行如下命��o�Q?/font>

C:\>javac Data.java

C:\>java Test
77

C:\>

�q�里我们看到�Q�虽然Data.java中的fNumber已经更改�?77�Q�而且已经重新�~�译了，但是因�ؓ�~�译器把fNumber的副本保存Test�c�M��Q�所以在重新�~�译Test�cȝ��前，Test�c�M��直把fNumber认�ؓ�?7而不�?77。下面我们变异Test.java�Q�再执行�Q�看看结果�?/font>

C:\>javac Test.java

C:\>java Test
777

C:\>
�q�时候，我们看到�Q�重新编译的Test�c�d��新的777数值封装到了自��q��中�?/font>

整个�q�程如下�Q?br />Microsoft Windows XP [版本 5.1.2600]
(C) 版权所�?1985-2001 Microsoft Corp.

C:\Documents and Settings\zangmeng>cd ..

C:\Documents and Settings>cd ..

C:\>javac Test.java

C:\>java Test
77
//在这里改变了Data.java的内�?br />C:\>javac Data.java

C:\>java Test
77

C:\>javac Test.java

C:\>java Test
777

C:\>

水煮三国 2006-07-28 09:36 发表评论

深入理解abstract class和interface

水煮三国 — Fri, 28 Jul 2006 01:11:00 GMT
abstract class和interface是Java语言中对于抽象类定义�q�行支持的两�U�机�Ӟ��正是�׃��q�两�U�机制的存在�Q�才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的�怼�性，甚至可以�怺�替换�Q�因此很多开发者在�q�行抽象�c�d��义时对于abstract class和interface的选择昑־�比较随意。其实，两者之间还是有很大的区别的�Q�对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意囄��理解是否正确、合理。本文将对它们之间的区别�q�行一番剖析，试图�l�开发者提供一个在二者之间进行选择的依据�?

理解抽象�c?

abstract class和interface在Java语言中都是用来进行抽象类�Q�本文中的抽象类�q��从abstract class��译而来�Q�它表示的是一个抽象体�Q�而abstract class为Java语言中用于定义抽象类的一�U�方法，误��者注意区分）定义的，那么什么是抽象�c�，使用抽象�c�能为我们带来什么好处呢�Q?

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

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

从语法定义层面看abstract class和interface

在语法层面，Java语言对于abstract class和interface�l�出了不同的定义方式�Q�下面以定义一个名为Demo的抽象类��Z��来说明这�U�不同�?

使用abstract class的方式定义Demo抽象�cȝ��方式如下�Q?

abstract class Demo �?
abstract void method1();
abstract void method2();
�?
�?

使用interface的方式定义Demo抽象�cȝ��方式如下�Q?

interface Demo {
void method1();
void method2();
�?
}

在abstract class方式中，Demo可以有自��q��数据成员�Q�也可以有非abstarct的成员方法，而在interface方式的实��C��Q�Demo只能够有静态的不能被修改的数据成员�Q�也��是必须是static final的，不过在interface中一般不定义数据成员�Q�，所有的成员�Ҏ��都是abstract的。从某种意义上说�Q�interface是一�U�特�D��Ş式的abstract class�?

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

首先�Q�abstract class在Java语言中表�C�的是一�U��承关�p�，一个类只能使用一�ơ��承关�p�R��但是，一个类却可以实现多个interface。也许，�q�是Java语言的设计者在考虑Java对于多重�l�承的支持方面的一�U�折中考虑吧�?

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

在抽象类中不能定义默认行��存在另一个比较严重的问题�Q�那��是可能会造成�l�护上的�ȝ��。因为如果后来想修改�cȝ��界面�Q�一般通过abstract class或者interface来表�C�）以适应新的情况�Q�比如，��d��新的�Ҏ��或者给已用的方法中��d��新的参数�Q�时�Q�就会非常的�ȝ��Q�可能要��p��很多的时��_��对于�z��c�d��多的情况�Q�尤为如此）。但是如果界面是通过abstract class来实现的�Q�那么可能就只需要修改定义在abstract class中的默认行�ؓ��可以了�?

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

从设计理念层面看abstract class和interface

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

前面已经提到�q�，abstarct class在Java语言中体��C��一�U��承关�p�，要想使得�l�承关系合理�Q�父�c�d��z��c�M��间必��d��?is a"关系�Q�即父类和派生类在概忉|��质上应该是相同的�Q�参考文献�?〕中有关�?is a"关系的大��幅深入的论�q�ͼ�有兴��的读者可以参考）。对于interface 来说则不�Ӟ��q�不要求interface的实现者和interface定义在概忉|��质上是一致的�Q�仅仅是实现了interface定义的契�U�而已。�ؓ了��便于理解�Q�下面将通过一个简单的实例�q�行说明�?

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

使用abstract class方式定义Door�Q?

abstract class Door {
abstract void open();
abstract void close()�Q?
}

使用interface方式定义Door�Q?

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

其他具体的Door�c�d��可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看��h��好像使用abstract class和interface没有大的区别�?

如果现在要求Door�q�要��h��报警的功能。我们该如何设计针对该例子的�cȝ��构呢�Q�在本例中，主要是�ؓ了展�C�abstract class和interface反映在设计理念上的区别，其他斚w��无关的问题都做了��化或者忽略）�Q�下面将�|�列出可能的解决�Ҏ��Q��ƈ从设计理念层面对�q�些不同的方案进行分析�?

解决�Ҏ��一�Q?

��单的在Door的定义中增加一个alarm�Ҏ��Q�如下：

abstract class Door {
abstract void open();
abstract void close()�Q?
abstract void alarm();
}

或�?

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

那么��h��报警功能的AlarmDoor的定义方式如下：

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

或�?

class AlarmDoor implements Door �?
void open() { �?}
void close() { �?}
void alarm() { �?}
�?

�q�种�Ҏ��q�反了面向对象设计中的一个核心原则ISP�Q�Interface Segregation Priciple�Q�，在Door的定义中把Door概念本��n固有的行为方法和另外一个概�?报警�?的行为方法�؜在了一赗��这样引��L��一个问题是那些仅仅依赖于Door�q�个概念的模块会因�ؓ"报警�?�q�个概念的改变（比如�Q�修改alarm�Ҏ��的参敎ͼ�而改变，反之依然�?

解决�Ҏ��二：

既然open、close和alarm属于两个不同的概念，�Ҏ��ISP原则应该把它们分别定义在代表�q�两个概�늚�抽象�c�M��。定义方式有�Q�这两个概念都��用abstract class方式定义�Q�两个概念都使用interface方式定义�Q�一个概念��用abstract class方式定义�Q�另一个概念��用interface方式定义�?

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

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

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

abstract class Door {
abstract void open();
abstract void close()�Q?
}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
void open() { �?}
void close() { �?}
void alarm() { �?}
}

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

�l�论

abstract class和interface是Java语言中的两种定义抽象�cȝ��方式�Q�它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概忉|��质的理解、对于设计意囄��反映是否正确、合理，因�ؓ它们表现了概念间的不同的关系�Q�虽焉��能够实现需求的功能�Q�。这其实也是语言的一�U�的惯用法�?/font>

水煮三国 2006-07-28 09:11 发表评论

水煮三国 — Fri, 03 Mar 2006 01:53:00 GMT
在写JAVA�E�序的时候，特别是jsp/servlet之类的东西，�l�常会有�q�样一�U�情况：当然你辛辛苦苦地打下了千百行字母的时候，写完最后一个大括号�Q�当你运行这个程序进行调试时�Q�忽然出现NullPointerException的字��P��你是不是很懊丧呢。在以前我肯定会随手拿�v桌上的杯子砸了�?BR>�l�过了一�q�多的打字母�l�历�Q�我渐渐的�ȝ��Z��一些经验，关于NullPointerException�q�个恶棍�?BR>NullPointerException�q�个异常出现在处理对象时对象不存在但又没有捕捉到�q�行处理的时候，但是在JAVA里面它又是被大多断片的类所抛出�Q�所以它�l�常会不�l�意的出现在你的面前。在api里的原文说明是这��L��Q�Thrown when an application attempts to use null in a case where an object is required. These include:

* Calling the instance method of a null object.
* Accessing or modifying the field of a null object.
* Taking the length of null as if it were an array.
* Accessing or modifying the slots of null as if it were an array.
* Throwing null as if it were a Throwable value.

Applications should throw instances of this class to indicate other illegal uses of the null object.
据我自己的统计，在我的代码中�Q�出现频率最多的�c�L��String.class�Q�因此我们就以String��Z��来看一下怎么避免在��用这个类的时候遇到NullPointerException�?BR>从JAVA的源代码来看�Q�String�q�个�c�M��共在两个地方��抛��Z��NullPointerException�q�个异常�Q�一个是String的一个构造方法，一个是toLowerCase�q�个�Ҏ��Q�所以在用到�q�两个方法的时候最好捕捉一下异常�?BR>�q�有�l�常遇到的是equals�q�个�Ҏ��Q�equals出现NullPointerException异常是因为对象不存在造成的。如果是变量和常量的比较�Q�比如str.equals("this is a string."),如果str == null。那么就会出现NullPointerException�Q�怎么解决呢，��是把常量和变量的位�|�互换，"this is a string.".equals(str),�q�样��׃��会再见到NullPointerException了�?BR>在jsp中经�怼�有一些form来提交表单给服务器，但是有时候表单项�q�没有填�Q�那么在jsp�E�序对传上来的数据进行处理时�Q�就会有异常出现。这时就要在使用�q�些数据前进行一�ơ判断，如：request.getParameter("str")�Q�如果没有�Q何处理就直接使用的话��有可能出错�Q�但是如果这�?BR>
String tmp = "";
if(request.getParameter("str") != null)
tmp = request.getParameter("str");

然后再对tmp�q�行操作��没有问题了。当�Ӟ��几乎所有的NullPointerException问题差不多都可以用这个方法解冟�?BR>�q�有在��用JDBC的时候，ResultSet�q�个对象使用的时候也会经常有NullPointerException异常�Q�一般来说ResultSet出现�q�个问题主要是sql不对的原因�?img src ="http://www.tkk7.com/os586/aggbug/33370.html" width = "1" height = "1" />

水煮三国 2006-03-03 09:53 发表评论

全面理解Java中的String数据�c�d��

水煮三国 — Fri, 03 Mar 2006 01:33:00 GMT
　　1. 首先String不属�?�U�基本数据类型，String是一个对象�?

　　因�ؓ对象的默认值是null�Q�所以String的默认��g��是null�Q�但它又是一�U�特�D�的对象�Q�有其它对象没有的一些特性�?

　　2. new String()和new String(“�?都是��x��一个新的空字符�Ԍ��是空串不是null�Q?

　　3. String str=”kvill”；
String str=new String (“kvill�?;的区别：

　　在这里，我们不谈堆，也不谈栈�Q�只先简单引入常量池�q�个��单的概念�?

　　帔R��?constant pool)指的是在�~�译期被��定�Q��ƈ被保存在已编译的.class文�g中的一些数据。它包括了关于类、方法、接口等中的帔R��Q�也包括字符串常量�?

　　看例1�Q?

String s0=”kvill�?
String s1=”kvill�?
String s2=”kv�?+ “ill�?
System.out.println( s0==s1 );
System.out.println( s0==s2 );

　　�l�果为：

true
true

　　首先�Q�我们要知道Java会确保一个字�W�串帔R��只有一个拷贝�?

　　因�ؓ例子中的s0和s1中的”kvill”都是字�W�串帔R��Q�它们在�~�译期就被确定了�Q�所以s0==s1为true�Q�而”kv”和”ill”也都是字符串常量，当一个字�W�串由多个字�W�串帔R��q�接而成�Ӟ��它自��p��定也是字�W�串帔R��Q�所以s2也同样在�~�译期就被解析�ؓ一个字�W�串帔R��Q�所以s2也是帔R��池中”kvill”的一个引用�?

　　所以我们得出s0==s1==s2;

　　用new String() 创徏的字�W�串不是帔R��Q�不能在�~�译期就��定�Q�所以new String() 创徏的字�W�串不放入常量池中，它们有自��q��地址�I�间�?

　　看例2�Q?

String s0=”kvill�?
String s1=new String(”kvill�?;
String s2=”kv�?+ new String(“ill�?;
System.out.println( s0==s1 );
System.out.println( s0==s2 );
System.out.println( s1==s2 );

　　�l�果为：

false
false
false

　　�?中s0�q�是帔R��池中”kvill”的应用�Q�s1因�ؓ无法在编译期��定�Q�所以是�q�行时创建的新对象”kvill”的引用�Q�s2因�ؓ有后半部分new String(“ill�?所以也无法在编译期��定�Q�所以也是一个新创徏对象”kvill”的应用;明白了这些也��q��道�ؓ何得出此�l�果了�?

　　4. String.intern()�Q?

　　再补充介�l�一点：存在�?class文�g中的帔R��池，在运行期被JVM装蝲�Q��ƈ且可以扩充。String的intern()�Ҏ��是扩充帔R��池的一个方法；当一个String实例str调用intern()�Ҏ��Ӟ��Java查找帔R��池中是否有相同Unicode的字�W�串帔R��Q�如果有�Q�则�q�回其的引用�Q�如果没有，则在帔R��池中增加一个Unicode�{�于str的字�W�串�q�返回它的引用；看例3��清楚了

　　�?�Q?

String s0= “kvill�?
String s1=new String(”kvill�?;
String s2=new String(“kvill�?;
System.out.println( s0==s1 );
System.out.println( �?*********�?);
s1.intern();
s2=s2.intern(); //把常量池中“kvill”的引用赋给s2
System.out.println( s0==s1);
System.out.println( s0==s1.intern() );
System.out.println( s0==s2 );

　　�l�果为：

false
**********
false //虽然执行了s1.intern(),但它的返回值没有赋�l�s1
true //说明s1.intern()�q�回的是帔R��池中”kvill”的引用
true

　　最后我再破除一个错误的理解�Q?

　　有�h��_��“��用String.intern()�Ҏ��则可以将一个String�cȝ��保存��C��个全局String表中�Q�如果具有相同值的Unicode字符串已�l�在�q�个表中�Q�那么该�Ҏ��q�回表中已有字符串的地址�Q�如果在表中没有相同值的字符�Ԍ��则将自己的地址注册到表中“如果我把他说的�q�个全局的String表理解�ؓ帔R��池的话，他的最后一句话�Q�“如果在表中没有相同值的字符�Ԍ��则将自己的地址注册到表中”是错的�Q?

　　看例4�Q?

String s1=new String("kvill");
String s2=s1.intern();
System.out.println( s1==s1.intern() );
System.out.println( s1+" "+s2 );
System.out.println( s2==s1.intern() );

　　�l�果�Q?

false
kvill kvill
true

　　在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的�Q�当我们调用s1.intern()后就在常量池中新��d��了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了�?

　　s1==s1.intern()为false说明原来的“kvill”仍然存在；

　　s2现在为常量池中“kvill”的地址�Q�所以有s2==s1.intern()为true�?

　　5. 关于equals()�?=:

　　�q�个对于String��单来说就是比较两字符串的Unicode序列是否相当�Q�如果相�{�返回true;�?=是比较两字符串的地址是否相同�Q�也��是是否是同一个字�W�串的引用�?

　　6. 关于String是不可变�?BR>
　　�q�一说又要说很多�Q�大家只要知道String的实例一旦生成就不会再改变了�Q�比如说�Q�String str=”kv�?”ill�?�?�?”ans�?
��是�?个字�W�串帔R��Q�首先”kv”和”ill”生成了”kvill”存在内存中�Q�然后”kvill”又和�?�?生成 ”kvill “存在内存中�Q�最后又和生成了”kvill ans�?�q�把�q�个字符串的地址赋给了str,��是因�ؓString的“不可变”��生了很多临时变量�Q�这也就是�ؓ什么徏议用StringBuffer的原因了�Q�因为StringBuffer是可改变�?

水煮三国 2006-03-03 09:33 发表评论

�l�典的Object转�ؓString的几�U��Ş式[摘]

水煮三国 — Fri, 03 Mar 2006 01:18:00 GMT
在java��目的实际开发和应用中，常常需要用到将对象转�ؓString�q�一基本功能。本文将对常用的转换�Ҏ��q�行一个�ȝ��。常用的�Ҏ��有Object#toString()�Q�（String�Q�要转换的对象，String.valueOf(Object)�{�。下面对�q�些�Ҏ��一一�q�行分析�?BR>
�Ҏ��1�Q�采�?Object#toString()�Ҏ��
��L��下面的例子：

　　Object object = getObject();

System.out.println(object.toString());

在这�U��用方法中�Q�因为java.lang.Object�c�里已有public�Ҏ��.toString()�Q�所以对��M��严格意义上的java对象都可以调用此�Ҏ��。但在��用时要注意，必须保证object不是null��|��否则��抛出NullPointerException异常。采用这�U�方法时�Q�通常�z��c�M��覆盖Object里的toString�Q�）�Ҏ��?BR>
�Ҏ��2�Q�采用类型�{换（String�Q�object�Ҏ��
�q�是标准的类型�{换，��object转成String�c�d��的倹{��用这�U�方法时�Q�需要注意的是类型必��能转成String�c�d��。因此最好用instanceof做个�c�d��查，以判断是否可以�{换。否则容易抛出CalssCastException异常。此外，需特别��心的是因定义�ؓObject �c�d��的对象在转成String时语法检查�ƈ不会报错�Q�这��可能导致潜在的错误存在。这时要格外��心。如�Q?BR>
Object obj = new Integer(100);

String　strVal = (String)obj;

在运行时��会出错�Q�因为将Integer�c�d��强制转换为String�c�d��Q�无法通过。但是，

Integer obj = new Integer(100);

String　strVal = (String)obj;

如是格式代码�Q�将会报语法错误�?BR>
此外�Q�因null值可以强制�{换�ؓ��M��java�cȝ��型，(String)null也是合法的�?BR>
�Ҏ��3�Q�采用String.valueOf(Object)
String.valueOf(Object)的基��是Object#toString()。但它与Object#toString()又有所不同。在前面�Ҏ��1的分析中提到�Q��用后者时需保证不�ؓnull。但采用�W�三�U�方法时�Q�将不用担心object是否为null��D��一问题。�ؓ了便于说明问题，我们来分析一下相关的源代码。Jdk里String# valueOf(Object)源码如下�Q?BR>
　　/**

　　 * Returns the string representation of the Object argument.

　　 *

　　 * @param　 obj　 an Object.

　　 * @return　if the argument is null, then a string equal to

　　 *　　　　　"null"; otherwise, the value of

　　 *　　　　　obj.toString() is returned.

　　 * @see　　 java.lang.Object#toString()

　　 */

　　public static String valueOf(Object obj) {

　　　 return (obj == null) ? "null" : obj.toString();

}

从上面的源码可以很清晰的看出null��g��用担心的理由。但是，�q�也恰恰�l�了我们隐患。我们应当注意到�Q�当object为null�Ӟ��String.valueOf�Q�object�Q�的值是字符东y��null”，而不是null�Q�！�Q�在使用�q�程中切记要注意。试想一下，如果我们�?if(String.valueOf�Q�object�Q?=null){System.out.println(“传入的值是null�Q��?;}�q�样的语句将可能会发生什么问题。再想一下，向控制台输出�Ӟ��在视觉上如下语句在执行的�l�果上有什么不同：

System.out.println(String.valueOf(null));

System.out.println(null);

我们看到的输出将是一模一��L��东西�Q�null�Q�但它们意义相同吗？

水煮三国 2006-03-03 09:18 发表评论

亚洲精品在线免费观看视频,亚洲 综合 国产 欧洲 丝袜,亚洲视频国产视频

Java 堆与栈的使用

NoClassDefDoundErr与ClassNotFoundException区别

澄清Java语言接口与��承的本质

关键字new和newInstance�Ҏ��区别

SWT:GridLayout 的��用需要注意的事项

Thinking�Q�Java中static、this、super、final用法

Online Resources for Java Programmers

General Programming Resources

Specialized Programming Resources

Other Resources

JAVA 当中 接口的��用�ȝ��

法则2�Q�针�Ҏ��口编�E�，而非�Q�接口的�Q�实�?/span>

接口

实现�l�承和接口���?/span>

接口的好�?/span>

接口实例

JAVA中内部类的��用�ȝ��

转：使用Java中的final变量需要注意的地方

深入理解abstract class和interface

全面理解Java中的String数据�c�d��

�l�典的Object转�ؓString的几�U��Ş式[摘]

亚洲精品在线免费观看视频,亚洲综合国产欧洲丝袜,亚洲视频国产视频

JAVA 当中接口的��用�ȝ��

实现�l�承和接口��?/span>