亚洲国产高清在线,亚洲美女在线国产,亚洲经典千人经典日产

�Ҏ��的String

和风�l�雨 — Tue, 29 Apr 2008 07:10:00 GMT

String的特�D�之�?/strong>

String是Java�~�程中很常见的一个类,�q�个�cȝ��实例是不可变�?immutable ).��Z��提高效率,JVM内部对其操作�q�行了一些特�D�处�?本文��旨在于帮助大家辨析�q�些�Ҏ��的地�?
在进入正文之�?你需要澄清这些概�?
1) 堆与�?br /> 2) 相同与相�{?==与equals
3) =的真实意�?

栈与�?/strong>

1. �?stack)与堆(heap)都是Java用来在内存中存放数据的地斏V��与C++不同�Q�Java自动��理栈和堆，�E�序员不能直接地讄��栈或堆。每个函数都有自��q��?而一个程序只有一个堆.
2. 栈的优势是，存取速度比堆要快�Q�仅�ơ于直接位于CPU中的寄存器。但�~�点是，存在栈中的数据大��与生存期必��L��定的，�~�Z��灉|��性。另外，栈数据可以共享，详见�W?炏V��堆的优势是可以动态地分配内存大小�Q�生存期也不必事先告诉编译器�Q�Java的垃圾收集器会自动收走这些不再��用的数据。但�~�点是，�׃��要在�q�行时动态分配内存，存取速度较慢�?3. Java中的数据�c�d��有两�U��?　　一�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�出于追求速度的原因，��存在于栈中�?　　另外�Q�栈有一个很重要的特�D�性，��是存在栈中的数据可以共享。假设我们同时定�?　　int a = 3; 　　int b = 3�Q?　　�~�译器先处理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的倹{�?　　另一�U�是包装�c�L��据，如Integer, String, Double�{�将相应的基本数据类型包装�v来的�c�R��这些类数据全部存在于堆中，Java用new()语句来显�C�地告诉�~�译器，在运行时才根据需要动态创建，因此比较灉|��Q�但�~�点是要占用更多的时间�?

相同与相�{?==与equals

在Java�?相同指的是两个变量指向的地址相同,地址相同的变量自然值相�?而相�{�是指两个变量值相�{?地址可以不同.
相同的比较��?=,而相�{�的比较使用equals.
对于字符串变量的值比较来�?我们一定要使用equals而不�?=.

=的真实意�?/strong>

=卌��值操�?�q�里没有问题,关键是这个值有时是真正的�?有的是地址,具体来说会根据等号右边的部分而变�?
如果是基本类�?八种),则赋��g��递的是确定的�?��x��双��变量的��g��递给左边的变�?
如果是类�c�d��,则赋��g��递的是变量的地址,��x��{�号左边的变量地址指向�{�号双��的变量地址.

指出下列代码的输�?/strong>

String andy="andy";
String bill="andy";

if(andy==bill){
System.out.println("andy和bill地址相同");
}
else{
System.out.println("andy和bill地址不同");
}

String str=“andy”的机制分�?/strong>

上页代码的输出是andy和bill地址相同.
当通过String str=“andy”;的方式定义一个字�W�串�?JVM先在栈中��L��是否有��gؓ“andy”的字�W�串,如果有则��str指向栈中原有字符串的地址;如果没有则创��Z��?再将str的地址指向�? String andy=“andy”�q�句代码走的是第二步,而String bill=“andy”走的是第一�?因此andy和bill指向了同一地址,故而andy==bill,andy和bill地址相等,所以输出是andy和bill地址相同.
�q�样做能节省�I�间—少创徏一个字�W�串;也能节省旉��—定向��L��创徏要省�?

指出下列代码的输�?/p>
String andy="andy";
String bill="andy";
bill="bill";

if(andy==bill){
System.out.println("andy和bill地址相同");
}
else{
System.out.println("andy和bill地址不同");
}

输出及解�?/strong>

上页代码的输出是:andy和bill地址不同
当执行bill=“bill”一句时,外界看来好像是给bill变换了一个新值bill,但JVM的内部操作是把栈变量bill的地址重新指向了栈中一块��gؓbill的新地址,�q�是因�ؓ字符串的值是不可变的,要换�?赋值操�?只有��变量地址重新转向. �q�样andy和bill的地址在执行bill=“bill”一句后��׃��一样了,因此输出是andy和bill地址不同.

指出下列代码的输�?/strong>

String andy=new String("andy");
String bill=new String("andy");

// 地址比较
if(andy==bill){
System.out.println("andy和bill地址相同");
}
else{
System.out.println("andy和bill地址不同");
}

// 值比�?br /> if(andy.equals(bill)){
System.out.println("andy和bill值相�{?);
}
else{
System.out.println("andy和bill��g��{?);
}

输出及机制分�?/strong>

andy和bill地址不同
andy和bill值相�{?br /> 我们知道new操作新徏出来的变量一定处于堆�?字符串也是一�?
只要是用new()来新建对象的�Q�都会在堆中创徏�Q�而且其字�W�串是单独存值的,��x��个字�W�串都有自己的�?自然地址��׃��会相�?因此输出了andy和bill地址不同.
equals操作比较的是��D��不是地址,地址不同的变量值可能相�?因此输出了andy和bill值相�{?

指出下列代码的输�?/strong>

String andy=new String("andy");
String bill=new String(andy);

// 地址比较
if(andy==bill){
System.out.println("andy和bill地址相同");
}
else{
System.out.println("andy和bill地址不同");
}

// 值比�?br /> if(andy.equals(bill)){
System.out.println("andy和bill值相�{?);
}
else{
System.out.println("andy和bill��g��{?);
}

输出

andy和bill地址不同
andy和bill值相�{?/p>
道理仍和�W�八��늛��?只要是用new()来新建对象的�Q�都会在堆中创徏�Q�而且其字�W�串是单独存值的,��x��个字�W�串都有自己的�?自然地址��׃��会相�?

指出下列代码的输�?/strong>

String andy="andy";
String bill=new String(“Bill");
bill=andy;

// 地址比较
if(andy==bill){
System.out.println("andy和bill地址相同");
}
else{
System.out.println("andy和bill地址不同");
}

// 值比�?br /> if(andy.equals(bill)){
System.out.println("andy和bill值相�{?);
}
else{
System.out.println("andy和bill��g��{?);
}

输出及解�?/strong>

andy和bill地址相同
andy和bill值相�{?br /> String bill=new String(“Bill”)一句在栈中创徏变量bill,指向堆中创徏�?#8221;Bill”,�q�时andy和bill地址和值都不相�?而执行bill=andy;一句后,栈中变量bill的地址��指向了andy,�q�时bill和andy的地址和值都相同�?而堆中的”Bill”则没有指向它的指�?此后�q�块内存��等待被垃圾攉��.

指出下列代码的输�?/p>
String andy="andy";
String bill=new String("bill");
andy=bill;

// 地址比较
if(andy==bill){
System.out.println("andy和bill地址相同");
}
else{
System.out.println("andy和bill地址不同");
}

// 值比�?br /> if(andy.equals(bill)){
System.out.println("andy和bill值相�{?);
}
else{
System.out.println("andy和bill��g��{?);
}

输出

andy和bill地址相同
andy和bill值相�{?/p>
道理同第十二��?/p>
�l�论

使用诸如String str = “abc”�Q�的语句在栈中创建字�W�串时时�Q�str指向的字�W�串不一定会被创建！唯一可以肯定的是�Q�引用str本��n被创��Z��。至于这个引用到底是否指向了一个新的对象，必须�Ҏ��上下文来考虑�Q�如果栈中已有这个字�W�串则str指向�?否则创徏一个再指向新创建出来的字符�? 清醒地认识到�q�一点对排除�E�序中难以发现的bug是很有帮助的�?br /> 使用String str = “abc”�Q�的方式�Q�可以在一定程度上提高�E�序的运行速度�Q�因为JVM会自动根据栈中数据的实际情况来决定是否有必要创徏新对象。而对于String str = new String(“abc”)�Q�的代码�Q�则一概在堆中创徏新对象，而不��其字符串值是否相�{�，是否有必要创建新对象�Q�从而加重了�E�序的负担�?br /> 如果使用new()来新建字�W�串的，都会在堆中创建字�W�串�Q�而且其字�W�串是单独存值的,��x��个字�W�串都有自己的�?且其地址�l�不会相�?br /> 当比较包装类里面的数值是否相�{�时�Q�用equals()�Ҏ��Q�当��试两个包装�cȝ��引用是否指向同一个对象时�Q�用==�?br /> �׃��String�cȝ��immutable性质�Q�当String变量需要经常变换其值如SQL语句拼接,HTML文本输出�Ӟ��应该考虑使用StringBuffer�c�，以提高程序效率�?

和风�l�雨 2008-04-29 15:10 发表评论

集合�l�D��

和风�l�雨 — Tue, 04 Mar 2008 00:33:00 GMT

1.Collection接口

Java集合�c�M��最基础的接口是Collection�Q�它定义了两个基本方法：
Public interface Collection{
    boolean add(E element);
    Iterator iterator();
}
add是向Collection中添加一个元素，当添加的内容��实对Collection发生了有效变更的话add�Ҏ��q�回真，否则�q�回假，比如你向一个Set��d��重复的元素时�Q�Set内容不会变化�Q�add�Ҏ��会返回假�?br /> iterator�Ҏ��q�回实现了Iterator接口的对象，你可以借此对Collection中的内容�q�行挨个遍历�?/p>
2.Iterator接口

Iterator有三个方法：
Public interface Iterator{
   E next();
   boolean hasNext();
   void remove();
}
通过重复调用next�Ҏ��Q�你可以挨个遍历Collection中的元素。然而，当遍历到Collection末端�Ӟ��此方法会抛出一个NoSuchElementException异常�Q�因此在遍历时你��需要hasNext�Ҏ��和next�Ҏ��配合使用�?hasNext�Ҏ��在当前遍历位�|�后仍有元素时会�q�回真。配合例子如下：
Collection c=….;
Iterator iterator=c.iterator();
While(iterator.hasNext()){
       String str=iterator.next();
      …….
}
remove�Ҏ��能删除上一�ơ调用next时指向的元素,注意不能�q�箋两次调用remove�Ҏ��,否则会抛出IllegalStateException.

3.Collection接口的其它方�?/strong>

int size():�q�回当前存储的元素个�?br /> boolean isEmpty():当集合中没有元素时返回真
boolean contains(Object obj):当集合中有元素和obj值相�{�时�q�回�?
boolean containsAll(Collection other):当集合包含另一集合的全部元素时�q�回�?
bBoolean addAll (Collection other):把其它集合中的元素添加到集合中来,当此集合��实发生变化时返回真.
boolean remove(Object obj):删除一个和obj值相�{�的元素,当吻合的元素被删除时�q�回�?
boolean removeAll(Collection other) :从本集合中删除和另一集合中相�{�的元素,当本集合��实发生变化时返回真.(差集)
void clear():清除集合中的所有元�?br /> boolean retainAll(Collection other) :从本集合中删除和另一集合中不相等的元�?当本集合��实发生变化时返回真.(交集)
Object[] toArray()
�q�回由集合中元素�l�成的数�l?/p>
4.实现了Collection接口的具体类

ArrayList:带下标的队列,增加和收�~�时都是动态的.
LinkedList:有序队列,在�Q意位�|�插入和删除都是高效�?
HashSet:不存在重复的非排序集�?
TreeSet:自动排序的不存在重复的集�?
LinkedHashSet:保持了插入时��序的哈希表
PriorityQueue:优先�U�队�?能有效的删除最��元�?

5.没有重复元素存在的集合HashSet

HashSet通过哈希码来查找一个元�?�q�比链表的整体查找要�q�速得�?但是由此带来的缺��h��它不能保持插入时的顺�?
�׃��HashSet靠hash码来识别元素,因此它不能包含重复元�?当集合中已经存在值相�{�的元素�?再次��d��同样的元素HashSet不会发生变化.

Set hashSet=new HashSet();
hashSet.add("Andy");
hashSet.add("Andy");
hashSet.add("Bill");
hashSet.add("Cindy");
hashSet.add("Bill");
hashSet.add("Cindy");

Iterator iter=hashSet.iterator();

while(iter.hasNext()){
        System.out.println(iter.next());
}
输出:
Cindy
Andy
Bill

6.自动排序的集�?TreeSet

TreeSet和HashSet�c�M��但它值得一提的一�Ҏ��无论你以何顺序插入元�?元素都能保持正确的排序位�|?�q�时因�ؓTreeSet是以�U�黑树的形式存储数据,在插入时��p��扑ֈ�正确的位�|?注意插入TreeSet的元素都要实现Comparable接口.
�?
SortedSet treeSet=new TreeSet();
treeSet.add("Andy");
treeSet.add("Andy");
treeSet.add("Bill");
treeSet.add("Cindy");
treeSet.add("Bill");
treeSet.add("Cindy");

Iterator iter=treeSet.iterator();

while(iter.hasNext()){
       System.out.println(iter.next());
}

输出:
Andy
Bill
Cindy

7.优先�U�队列PriorityQueue

PriorityQueue使用一�U�名为堆的二叉树高效的存储数�?它检索数据是按排序的��序而插入则随意,当你调用remove�Ҏ��?你总能得到最��的元素.但PriorityQueue�q�不按序排列它的元素,当你遍历时它是不会排序的,�q�也没有必要. 在制作一个按优先�U�执行日�E�安排或事务安排时你应该首先惛_��PriorityQueue�?br /> �?
PriorityQueue pq=new PriorityQueue();
pq.add("Cindy");
pq.add("Felix");
pq.add("Andy");
pq.add("Bill");

Iterator iter=pq.iterator();

while(iter.hasNext()){
      System.out.println(iter.next());
}

while(!pq.isEmpty()){
      System.out.println(pq.remove());
}

8.保持插入��序的哈希表LinkedHashMap

�?.4起Java集合�c�M��多了一个LinkedHashMap,它在HashMap的基��上增加了一个双向链�?由此LinkedHashMap既能以哈希表的�Ş式存储数�?又能保持查询时的��序.
Map members=new LinkedHashMap();

members.put("001", "Andy");
members.put("002", "Bill");
members.put("003", "Cindy");
members.put("004", "Dell");

Iterator iter=members.keySet().iterator();

while(iter.hasNext()){
      System.out.println(iter.next());
}

Iterator iter2=members.values().iterator();

while(iter2.hasNext()){
      System.out.println(iter2.next());
}

9.自动按键�q�行排序的哈希表TreeMap

Map members=new TreeMap();

members.put("001", "Andy");
members.put("006", "Bill");
members.put("003", "Cindy");
members.put("002", "Dell");
members.put("004", "Felex");

for(Map.Entry entry:members.entrySet()){
      System.out.println("Key="+entry.getKey()+"                      Value="+entry.getValue());
}

10.1 集合工具�c�Collections的方法unmodifiable

此方法构��Z��个不可更改的集合视图�Q�当使用其修�Ҏ��法时会抛��Z��个UnsupportedOperationException
static Collection unmodifiableCollection(Collection c)
static List unmodifiableList (List c)
static Set unmodifiableSet (Set c)
static SortedSet unmodifiableSortedSet (SortedSet c)
static Map unmodifiableMap (Map c)
static SortedMap unmodifiableSortedMap (SortedMap c)

10.2 集合工具�c�Collections的方法synchronized

此方法会�q�回一个线�E�安全的集合视图
static Collection synchronizedCollection(Collection c)
static List synchronizedList (List c)
static Set synchronizedSet (Set c)
static SortedSet synchronizedSortedSet (SortedSet c)
static Map synchronizedMap (Map c)
static SortedMap synchronizedSortedMap (SortedMap c)

集合�c�静态类�?/p>

和风�l�雨 2008-03-04 08:33 发表评论

泛型�c?Generic Class)

和风�l�雨 — Mon, 03 Mar 2008 14:55:00 GMT

C++模版(Template)�c�d��Java中的体现-泛型�c?/strong>

泛型�c�L��C++模版(Template)�c�L��想在java新版�?1.5)中的应用体现.当对�c�d��相同的对象操作时泛型是很有用�?但其中对象的具体�c�d��直到对类实例化时才能知道.�q�种方式非常适合于包含关联项目的集合或设计查扄��c?

泛型�cȝ��使用�C�Z��一

/**
* 泛型�cȝ��例一,成员变量为链�?T可以指代��L��cȝ��?
* @author sitinspring
*
* @date 2007-12-28
*/
public class Service{
// 元素为T的链�?br /> private List elements;

/**
   * 构造函�?�q�里无须指定�c�d��
   *
   */
public Service(){
    elements=new ArrayList();
}

/**
   * 向链表中��d��c�d��为T的元�?br />    * @param element
   */
public void add(T element){
    elements.add(element);
}
/**
   * 打印链表中元�?br />    *
   */
public void printElements(){
    for(T t:elements){
      System.out.println(t);
    }
}

/**
   * 使用�C�Z��
   * @param args
   */
public static void main(String[] args){
    // 创徏Service�cȝ��C�Z��memberService
    Service memberService=new Service();

    // 向memberService中添加元�?br />     memberService.add(new Member("Andy",25));
    memberService.add(new Member("Bill",24));
    memberService.add(new Member("Cindy",55));
    memberService.add(new Member("Felex",35));

    // 打印memberService中诸元素
    memberService.printElements();
}
}

泛型�cȝ��使用�C�Z��?/strong>

/**
* 泛型�cȝ��例二,成员变量为哈希表,k,v可以指代��L��cȝ��?
* @author sitinspring
*
* @date 2007-12-28
*/
public class ServiceHt{
private Map elements;

/**
   * 向elements中添加元�?br />    * @param k
   * @param v
   */
public void add(K k,V v){
    // 如果elements为空则创建元�?br />     if(elements==null){
      elements=new Hashtable();
    }

    // 向elements中添加键值对
    elements.put(k, v);
}
/**
   * 打印哈希表中的元�?br />    *
   */
public void printElements(){
    Iterator it=elements.keySet().iterator();

    while(it.hasNext()){
      K k=(K)it.next();
      V v=elements.get(k);

      System.out.println("�?"+k+" �?"+v);
    }
}

/**
   * 使用�C�Z��
   * @param args
   */
public static void main(String[] args){
    // 创徏Service�cȝ��C�Z��memberService
    ServiceHt memberService=new ServiceHt();

    // 向memberService中添加元�?br />     memberService.add("Andy",new Member("Andy",25));
    memberService.add("Bill",new Member("Bill",24));
    memberService.add("Cindy",new Member("Cindy",55));
    memberService.add("Felex",new Member("Felex",35));

    // 打印memberService中诸元素
    memberService.printElements();
}
}

和风�l�雨 2008-03-03 22:55 发表评论

字符串比�? ==与equals辨析

和风�l�雨 — Mon, 03 Mar 2008 14:38:00 GMT

字符串比�?/strong>

字符串比较是java�E�序帔R��到的问题,新手常用==�q�行两个字符串比�?实际上这时进行的地址比较,不一定会�q�回正确�l�果.在java�?正确的进行字�W�串比较的函数String�cȝ��equals()函数,�q�才是真正的值比�?

==的真正意�?/strong>

Java�?==用来比较两个引用是否指向同一个内存对�?对于String的实�?�q�行时JVM会尽可能的确保�Q何两个具有相同字�W�串信息的String实例指向同一个内部对�?此过�E�称�?#8221;�ȝ��”(interning),但它不助于每个String实例的比�?一个原因是垃圾攉��器删除了�ȝ��?另一个原因是String所在的位置可能被别的String实例所取代.�q�样的话,==��不会返回预想的�l�果.
下页的示例说明了�q�个问题:

==和equals比较的示�?br />

String str1,str2,str3;

str1="Andy";

str2=str1;

if(str1==str2){
System.out.println("str1,str2地址相等");
}
if(str1.equals(str2)){
System.out.println("str1,str2值相�{?/span>");
}

str2=“Andy”;
if(str1==str2){
System.out.println("str1,str2通常地址相等");
}
if(str1.equals(str2)){
System.out.println("str1,str2��g��定相�{?/span>");
}

str3=new String("Andy");
if(str1==str3){
System.out.println("str1,str3地址相等");
}
else{
System.out.println("str1,str3地址不相�{?/span>");
}

if(str1.equals(str3)){
System.out.println("str1,str3��g��定相�{?/span>");
}

�l�论

从上面的例子可以看出,==比较的是地址,在驻留机制的作用�?也许�q�回正确的结�?但�ƈ不可�?�q�种不确定性会隐藏在阴暗的角落�?在你以�ؓ万事大吉时给你致命一�?
而equal始终�q�行值比�?它一定会�q�回正确的结�?无论在什么情况下.

我们应该��C��:��Z��保证�E�序的正��?�q�行字符串比较时一定要使用equals,而一定不能��?=.

和风�l�雨 2008-03-03 22:38 发表评论

异常机制�l�D��

和风�l�雨 — Mon, 03 Mar 2008 14:34:00 GMT

在运行过�E�中,应用�E�序可能遭遇各种严重�E�度不同的问�?异常提供了一�U�在不弄��q��序的情况下检查错误的巧妙方式.它也提供了一�U�直接报告错误的机制,而不必检查标志或者具有此作用的域.异常把方法能够报告的错误作�ؓ�Ҏ��U�定的一个显式部�?
异常能够被程序员看到,��q��译器��?�q�且由重载方法的子类保留.
如果遇到意外的错误将抛出异常,然后异常被方法调用栈上的子句捕获.如果异常未被捕获,��导致执行线�E�的�l�止.

异常的体�pȝ��?/strong>

毫无疑问,在java中异常是对象,它必定��承Throwable及其子类.Throwable中含有一个用于描�q�异常的字符�?Exception是Throwable的一个最常用子类,另一个子�c�L��Error.而RuntimeException�l�承自Exception.

异常的种�c?/strong>

非检查型异常(Unchecked Exception):
非检查型异常反映了程序中的逻辑错误,不能从运行中合理恢复.
标准的运行时异常和错误构成非��查型异常,它们�l�承自RuntimeException和Error.
非检查型异常不用昄��q�行捕获.

��查型异常(Checked Exception):
�q�种异常描述了这�U�情�?虽然是异常的,但被认�ؓ是可以合理发生的,如果�q�种异常真的发生�?必须调用某种�Ҏ��处理.
Java异常大多是检查型异常,�l�承自Exception�c?你自己定义的异常必须是��承Exception的检查型异常.
��查型异常必须�q�行昄��捕获.

自定义异�?/strong>

�l�承Exception卛_��定义自己的异�?以下是一�U�常见写�?br /> public class DBXmlFileReadException extends Exception{
public DBXmlFileReadException(String   msg){
    super(msg);
}
}

抛出异常

在Java语句�?可以用throw语句抛出异常,如throw new NoSuchElementException();
抛出的对象必��L��Throwable�cȝ��子类�?

抛出异常的策�?
1) 如果抛出后不可能得到处理,可以抛出Error.
2) 如果你想让其它类自由选择是否处理�q�个异常,��可以抛出RuntimeException.
3) 如果你要求类的用户必��d��理这个异�?则可以抛出Exception.

异常抛出后的控制权�{�U?/strong>

一旦发生异�?异常发生点后的动作将不会发生.此后��要发生的操作不是在catch块和finally�?

当异常抛出时,��D��异常发生的语句和表达式就被称为突然完�?语句的突然完成将��D��调用��N��渐展开,直到该异常被捕获.

如果该异常没有捕�?执行�U�程��中�?

Try,catch和finally

异常由包含在try块中的语句捕�?
    try{
      正常执行语句
    }
    catch(XException e){
      异常执行语句一
    }
    catch(XXException e){
      异常执行语句�?br />     }
    catch(XXXException e){
      异常执行语句�?br />     }
    finally{
      中止语句
    }

Try中的语句体要么顺利完�?要么执行到抛出异�?
如果抛出异常,��p��扑և�对应于异常类或其父类的catch子句,如果未能扑ֈ�合适的catch子句,异常��׃��try语句中扩散出�?�q�入到外层可能对它进行处理的try语句.
Catch子句可以有多�?只要�q�些子句捕获的异常类型不�?
如果在try中有finally子句,其代码在try把所有其它处理完成之后执�?
无论是正常完成或是出现异�?甚至是通过return或者break�q�样的控制语句结�?finally子句��L��被执�?
Catch子句和finally子句在try语句之后臛_��有一�?不要求全部出�?

More…

在catch语句中捕获通用的异常Exception通常不是最佳策�?因�ؓ它会��所有异常进行等同处�?
不能把基�c�d��常的catch语句攑ֈ�子类异常的catch语句之前,�~�译器会在运行之前就��查出�q�样的错�?
Try…catch�Ҏ��个catch语句都从头到��检�?如果扑ֈ�处理同类异常的catch子句,此catch块中的语句将得以执行,而不再处理同层次的其它catch�?
如果catch或finally抛出另一个异�?�E�序��不会再��L��查try的catch子句.
Try...catch语句可以嵌套,内层抛出的异常可被外层处�?

Throws子句

函数能抛出的��查型异常用throws声明,它后面可以是带用逗号隔开的一�p�d��异常�c�d��.仅仅那些在方法中不被捕获的异常必��d��?

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();

        // Read in size
        int size = s.readInt();

        // Initialize header
        header = new Entry(null, null, null);
        header.next = header.previous = header;

        // Read in all elements in the proper order.
        for (int i=0; i              addBefore((E)s.readObject(), header);
        }
}

More…

Throws子句的约定是严格强制性的,只能抛出throws子句中声明的异常�c�d��,抛出其它�c�d��的异常是非法�?不管是直接利用throw,�q�是调用别的�Ҏ��间接的抛�?
RuntimeException和Error是仅有的不必由throws子句列出的异�?
调用函数的函数要么处理对声明的异常进行处�?要么也声明同��L��异常,��收到的异常抛向上层.

�Ҏ��查型异常通常�q�行的几�U�处�?/strong>

1) 用e.printStackTrace()输出异常信息.
2) ��异常记录到日志中以备查,如logger.error(e.getMessage()).
3) 试图�q�行异常恢复.
4) 告知�l�护者和用户发生的情�?

和风�l�雨 2008-03-03 22:34 发表评论

和风�l�雨 — Mon, 03 Mar 2008 14:30:00 GMT

嵌套�c�d��匿名�c?/strong>

内部�cȝ��出现
当进行Java开发时,有时需要实��C��个仅包含1-2个方法的接口.在AWT和Swing开发中�l�常出现�q�种情况,例如当一个display�l��g需要一个事件回调方法如一个按钮的ActionListener�? 如果使用普通的�c�L��实现此操�?最�l�会得到很多仅在单个位置上��用的��型�c?
内部�cȝ��于处理这�U�情�?java允许定义内部�c?而且可在Gui外��用内部类.

内部�cȝ��定义和实�?/strong>

内部�c�L��指在另一个类内部定义的一个类.可以��内部类定义��Z��个类的成�?
public class Linker{
public class LinkedNode{
    private LinkedNode prev;
    private LinkedNode next;
    private String content;

    public LinkedNode(String content){
      this.content=content;
    }
}

public Linker(){
    LinkedNode first=new LinkedNode("First");
    LinkedNode second=new LinkedNode("Second");

    first.next=second;
    second.prev=first;
}
}

定义在一个类�Ҏ��中的内部�c?/strong>

public class Hapiness{
interface Smiler{
    public void smile();
}

public static void main(String[] args){
    class Happy implements Smiler{
      public void smile(){
        System.out.println(":-}");
      }
    }

    Happy happy=new Happy();
    happy.smile();
}
}

匿名�c?/strong>

对很多情况而言,定义在方法内部的�c�d��意义不大,它可以保持�ؓ匿名�?�E�序员关心的只是它的实例�?
�?
Runnable runner=new Runnable(){
     public void run(){
          // Run statememnt
     }
}

理解匿名�c?/strong>

匿名�c�dƈ不难理解,它只是把�cȝ��定义�q�程和实例的创徏�q�程混合而已,上页的语句实际上相当于如下语�?
// 定义�c?br /> Public class Runner implements Runnable{
     public void run(){
         // do sth
      }
}

// 创徏实例
Runner runner=new Runner();

使用匿名�cȝ��{�选解耦过�E?/p>
需�?从公司的职员列表�?扑և��h��且�q�龄大于22的成�?

传统写法:

   List allmembers=company.getMembers();// 取得所有成�?br />     List results=new ArrayList();// �l�果列表

    for(Iterator it=allmembers.iterator();it.hasNext();){
     Member member=(Member)it.next();

     if(member.getAge()>22 && member.isMale()){ // �{��?�q�里是把查询条�g和遴选过�E�融合在一�?条�g一变立卛_��得加个分�?
      results.add(member);
     }
   }

传统�Ҏ��的缺�?/strong>

�q�种写法没有�?但是不是面向对象的写�?它有以下�~�陷:
1.查询条�g和筛选过�E�没有分��?
2.�q�样写的后果使Company变成了一个失血模型而不是领域模�?
3.换查询条件的�?上面除了"�{��?一句有变化外其它都是模板代�?重复性很�?

使用匿名�c�d��现的OO化查�?/p>
真正�W�合OO的查询应该是�q�样:

   MemberFilter filter1=new MemberFilter(){
    public boolean accept(Member member) {
         return member.isMale() && member.getAge()>22;
    }
   };

   List ls=company.listMembers(filter1);

�q�段代码成功的把查询条�g作�ؓ一个接口分��M��出去,接口代码如下:

public interface MemberFilter{
public boolean accept(Member member);
}

查询函数的变�?/strong>

而类Company增加了这样一个函�?

public List searchMembers(MemberFilter memberFilter){
   List retval=new ArrayList();

    for(Iterator it=members.iterator();it.hasNext();){
     Member member=(Member)it.next();

     if(memberFilter.accept(member)){
      retval.add(member);
    }
   }

   return retval;
}
�q�就把模板代码归�l�到了类内部,外面不会重复书写�?Company也同时拥有了数据和行�?而不是原来的数据容器�?

匿名�cȝ��例子�?/strong>

用匿名类处理分类汇�ȝ��Ҏ�� 分类汇��L��l�计中常�?举例来说如统计学生成�l?及格不及格的归类,分优良中差等�U�归�cȝ��,每个单项代码很好�?但是如果分类汇�ȝ��目多了,能一�U�汇��d��一个函数吗? 比如说有些科�?0分才��及�?有些�U�目50分就��?有些老师喜欢分优良中差四�{?有些老师却喜�Ƣ分ABCD;不一而��,如果每个都写一个函数无疑是个编写和�l�护恶梦. 如果我们用匿名类把分�c�L��ȝ��规则和分�c�L��ȝ��q�程分别抽象出来,代码��清晰灵�z�d��?以下代码讲述了这个过�E?

基本�c�Student

public class Student{
    private String name;
    private int score;

    public Student(String name,int score){
        this.name=name;
        this.score=score;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
}

用于分类汇�ȝ��c?/strong>

它强制子�c�d��现getKey和getvalue两个�Ҏ��:
public abstract class ClassifyRule {
    public Student student;

    public ClassifyRule(){
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    abstract public String getKey();
    abstract public int getValue();
}

对Student�q�行�l�计处理的StudentService�c?/strong>

注意getSum�Ҏ��,它保留了�{�选过�E?�{�选规则则不在其中:
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

public class StudentService {
    private List students;

    public StudentService() {
        students = new ArrayList();
    }

    public void add(Student student) {
        students.add(student);
    }

    public Hashtable getSum(ClassifyRule rule) {
        Hashtable ht = new Hashtable();

        for (Student student : students) {
            rule.setStudent(student);
            String key = rule.getKey();
            int value = rule.getValue();

            if (ht.containsKey(key)) {
                Integer oldValue = ht.remove(key);
                oldValue += value;
                ht.put(key, oldValue);
            } else {
                ht.put(key, value);
            }
        }

        return ht;
    }
}

��试代码,注意其中�{�选规则的创徏

public class Test {
    public static void main(String[] args) {
        // 初始�?br />         StudentService service = new StudentService();
        service.add(new Student("Andy", 90));
        service.add(new Student("Bill", 95));
        service.add(new Student("Cindy", 70));
        service.add(new Student("Dural", 85));
        service.add(new Student("Edin", 60));
        service.add(new Student("Felix", 55));
        service.add(new Student("Green", 15));

        // 60分及格筛�?br />         ClassifyRule rule60 = new ClassifyRule() {
            public String getKey() {
                return student.getScore() >= 60 ? "及格" : "不及�?;
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("60分及格筛�?);
        printHt(service.getSum(rule60));

        // 50分及格筛�?br />         ClassifyRule rule50 = new ClassifyRule() {
            public String getKey() {
                return student.getScore() >= 50 ? "及格" : "不及�?;
            }

            public int getValue() {
                return 1;
            }
        };
        System.out.println("\n50分及格筛�?);
        printHt(service.getSum(rule50));

        // �?优良中差"�{��
        ClassifyRule ruleCn = new ClassifyRule() {
            public String getKey() {
                String retval = "";

                int score = student.getScore();
                if (score >= 90) {
                    retval = "�?;
                } else if (score >= 80) {
                    retval = "�?;
                } else if (score >= 60) {
                    retval = "�?;
                } else if (score > 0) {
                    retval = "�?;
                }

                return retval;
            }

            public int getValue() {
                return 1;
            }
        };

��试代码

System.out.println("\n分优良中差等�U�筛�?);
        printHt(service.getSum(ruleCn));

        // �?ABCD"�{��
        ClassifyRule ruleWest = new ClassifyRule() {
            public String getKey() {
                String retval = "";

                int score = student.getScore();
                if (score >= 90) {
                    retval = "A";
                } else if (score >= 80) {
                    retval = "B";
                } else if (score >= 60) {
                    retval = "C";
                } else if (score > 0) {
                    retval = "D";
                }

                return retval;
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("\n分ABCD�{��{��?);
        printHt(service.getSum(ruleWest));
    }

    private static void printHt(Hashtable ht) {
        for (Iterator it = ht.keySet().iterator(); it.hasNext();) {
            String key = (String) it.next();
            Integer value = (Integer) ht.get(key);
            System.out.println("Key=" + key + " Value=" + value);
        }
    }
}

��试�l�果如下:

60分及格筛�?br /> Key=及格 Value=5
Key=不及�?Value=2

50分及格筛�?br /> Key=及格 Value=6
Key=不及�?Value=1

分优良中差等�U�筛�?br /> Key=�?Value=2
Key=�?Value=1
Key=�?Value=2
Key=�?Value=2

分ABCD�{��{��?br /> Key=A Value=2
Key=D Value=2
Key=C Value=2
Key=B Value=1

后记

内部�c�M��叫嵌套类,一般不提倡书�?但它在java核心�c�M��都存�?如接口Map中的Entry,我们应该了解�q�能解读�q�种�Ҏ��.

匿名�cȝ��对而言有用得多,在解耦合和事件回调注册中很常�?大家应该对它的运用融会诏�?

和风�l�雨 2008-03-03 22:30 发表评论

Socket基础

和风�l�雨 — Tue, 26 Feb 2008 05:53:00 GMT

本文内容

Socket概述
Socket的重要API
一个Socket通信的例�?/p>
Socket是什么？

Socket通常也称�?#8220;套接�?#8221;�Q�用于描�q�IP地址和端口，是一个通信铄��句柄。应用程序通常通过“套接�?#8221;向网�l�发��求或者应�{�网�l�请求�?
在java中，Socket和ServerSocket�c�d��位于java.net包中。ServerSocket用于服务器端�Q�Socket是徏立网�l�连接时使用的。在�q�接成功�Ӟ��应用�E�序两端都会产生一个Socket实例�Q�操作这个实例，完成所需的会话�?br /> 对于一个网�l�连接来��_��套接字是�q�等的，�q�没有差别，不因为在服务器端或在客户端而��生不同��别�?

Socket的直观描�q?/strong>

Socket的英文原义是“�?#8221;�?#8220;插��”。在�q�里作�ؓ�q�程通信机制�Q�取后一�U�意义。socket非常�c�M��于电话插座。以一个国家��电话�|��ؓ例。电话的通话双方相当于相互通信�?个进�E�，区号是它的网�l�地址�Q�区内一个单位的交换机相当于一��C��机，��L��分配�l�每个用��L��局内号码相当于socket受��Q何用户在通话之前�Q�首先要占有一部电话机�Q�相当于甌��一个socket�Q�同时要知道�Ҏ��的号码，相当于对�Ҏ��一个固定的socket。然后向�Ҏ��拨号呼叫�Q�相当于发出�q�接��h��(假如�Ҏ��不在同一区内�Q�还要拨�Ҏ��区号�Q�相当于�l�出�|�络地址)。对方假如在场�ƈ�I�闲(相当于通信的另一��L��开��Z��可以接受�q�接��h��)�Q�拿��L��话话�{�，双方��可以正式通话�Q�相当于�q�接成功。双斚w��话的过�E�，是一方向电话机发��Z��号和�Ҏ��从电话机接收信号的过�E�，相当于向socket发送数据和从socket接收数据。通话�l�束后，一�Ҏ��L��话机相当于关闭socket�Q�撤消连接�?br /> 在电话系�l�中�Q�一般用户只能感受到本地电话机和�Ҏ��电话��L��的存在，建立通话的过�E�，话音传输的过�E�以及整个电话系�l�的技术细节对他都是透明的，�q�也与socket机制非常�怼�。socket利用�|�间�|�通信设施实现�q�程通信�Q�但它对通信设施的细节毫不关心，只要通信设施能提供��够的通信能力�Q�它��满��了�?br /> ��x��Q�我们对socket�q�行了直观的描述。抽象出来，socket实质上提供了�q�程通信的端炏V��进�E�通信之前�Q�双斚w��先必��d��自创��Z��个端点，否则是没有办法徏立联�p�dƈ�怺�通信的。正如打电话之前�Q�双方必��d��自拥有一台电话机一栗��?/p>
socket 是面向客�?服务器模型而设计的

socket 是面向客�?服务器模型而设计的�Q�针对客户和服务器程序提供不同的socket �pȝ��调用。客户随机申请一个socket (相当于一个想打电话的人可以在��M��一台入�|�电话上拨号呼叫)�Q�系�l��ؓ之分配一个socket��P��服务器拥有全局公认�?socket �Q��Q何客户都可以向它发出�q�接��h��和信息请�?相当于一个被呼叫的电话拥有一个呼叫方知道的电话号�?�?br /> socket利用客户/服务器模式��y妙地解决了进�E�之间徏立通信�q�接的问题。服务器socket为全局所公认非常重要。读者不妨考虑一下，两个完全随机的用戯��E�之间如何徏立通信�Q�假如通信双方没有��M��一方的socket 固定�Q�就好比打电话的双方彼此不知道对方的电话��L��Q�要通话是不可能的�?/p>
Socket的应�?/strong>

Socket 接口是访�?Internet 使用得最�q�泛的方法�?如果你有一台刚配好TCP/IP协议的主机，其IP地址�?02.120.127.201�Q?此时在另一��C��机或同一��C��Z��执行ftp 202.120.127.201�Q�显然无法徏立连接。因"202.120.127.201" �q�台��L��没有�q�行FTP服务软�g。同��P�� 在另一台或同一��C��Z��q�行��览软�g 如Netscape�Q�输�?http://202.120.127.201"�Q�也无法建立�q�接。现在，如果在这��C��Z��q�行一个FTP服务软�g�Q�该软�g��打开一个Socket�Q?�q�将其绑定到21端口�Q�，再在�q�台��L��上运行一个Web 服务软�g�Q�该软�g��打开另一个Socket�Q��ƈ��其�l�定�?0端口�Q�。这��P��在另一��C��机或同一��C��Z��执行ftp 202.120.127.201�Q�FTP客户软�g��通过21端口来呼叫主��Z��由FTP 服务软�g提供的Socket�Q�与其徏立连接�ƈ对话。而在netscape中输�?http://202.120.127.201"�Ӟ��通过80端口来呼叫主��Z��由Web服务软�g提供的Socket�Q�与其徏立连接�ƈ对话�?在Internet上有很多�q�样的主机，�q�些��L��一般运行了多个服务软�g�Q�同时提供几�U�服务。每�U�服务都打开一个Socket�Q��ƈ�l�定��C��个端口上�Q�不同的端口对应于不同的服务。Socket正如其英文原意那��P��象一个多孔插座。一��C��机犹如布满各�U�插座的戉K��Q�每个插座有一个编��P��有的插��提供220伏交��电�Q?有的提供110伏交��电�Q�有的则提供有线电视节目�?客户软�g��插头插��C��同编��L��插��Q�就可以得到不同的服务�?

重要的Socket API

accept�Ҏ��用于产生“��d��”�Q�直到接受到一个连接，�q�且�q�回一个客��L��的Socket对象实例�?#8220;��d��”是一个术语，它�ɽE�序�q�行暂时“停留”在这个地方，直到一个会话��生，然后�E�序�l�箋�Q�通常“��d��”是由循环产生的�?br /> getInputStream�Ҏ��获得�|�络�q�接输入�Q�同时返回一个IutputStream对象实例�?
getOutputStream�Ҏ��q�接的另一端将得到输入�Q�同时返回一个OutputStream对象实例�?注意�Q�其中getInputStream和getOutputStream�Ҏ��均会产生一个IOException�Q�它必须被捕��P��因�ؓ它们�q�回的流对象�Q�通常都会被另一个流对象使用�?

一个Server-Client模型的程序的开发原�?/strong>

服务器，使用ServerSocket监听指定的端口，端口可以随意指定�Q�由�?024以下的端口通常属于保留端口�Q�在一些操作系�l�中不可以随意��用，所以徏议��用大�?024的端口）�Q�等待客戯��接请求，客户�q�接后，会话产生�Q�在完成会话后，关闭�q�接�?br /> 客户端，使用Socket对网�l�上某一个服务器的某一个端口发��接请求，一旦连接成功，打开会话�Q�会话完成后�Q�关闭Socket。客��L��不需要指定打开的端口，通常临时的、动态的分配一�?024以上的端口�?

服务器端代码

public class ResponseThread implements Runnable {
private static Logger logger = Logger.getLogger(ResponseThread.class);

// 用于与客��L��通信的Socket
private Socket incomingSocket;

/**
   * 构造函�?用以��incomingSocket传入
   * @param incomingSocket
   */
public ResponseThread(Socket incomingSocket) {
    this.incomingSocket = incomingSocket;
}

public void run() {
    try {
      try {
        // 输入��?br />         InputStream inStream = incomingSocket.getInputStream();

        // 输出��?br />         OutputStream outStream = incomingSocket.getOutputStream();

        // 文本扫描�?br />         Scanner in = new Scanner(inStream);

        // 输出��打印器
        PrintWriter out = new PrintWriter(outStream,true);

        while (in.hasNextLine()) {
          String line = in.nextLine();
          logger.info("从客��L��获得文字:"+line);

          String responseLine=line+" 门朝大�v 三河合水万年��?;
          out.println(responseLine);
          logger.info("向客��L��送出文字:"+responseLine);
        }
      } finally {
        incomingSocket.close();
      }
    } catch (IOException ex) {
      ex.printStackTrace();
    }
}
public static void main(String[] args) {
    try {
      // 建立一个对2009端口�q�行监听的ServerSocket�q�开始监�?br />       ServerSocket socket=new ServerSocket(2009);
      logger.info("开始监�?);

      while(true){
        // 产生��d��,直到客户端连接过来才会往下执�?br />         logger.info("��d��?�{�待来自客户端的�q�接��h��");
        Socket incomingSocket=socket.accept();

        // 执行到这里客��L��已经�q�接�q�来�?incomingSocket��是创徏出来和远�E�客��L��Socket�q�行通信的Socket
        logger.info("获得来自"+incomingSocket.getInetAddress()+"的请�?");

        // 开辟一个线�E?�q�把incomingSocket传进�?在这个线�E�中服务器和客户机开始通信
        ResponseThread responseThread=new ResponseThread(incomingSocket);

        // 启动�U�程
        Thread thread=new Thread(responseThread);
        thread.start();
      }

    } catch (IOException ex) {
      ex.printStackTrace();
    }
}
}

客户端代�?/strong>

/**
* Socket客户端类
* @author sitinspring
*
* @date 2008-2-26
*/
public class SocketClient{
private static Logger logger = Logger.getLogger(ResponseThread.class);

public static void main(String[] args){
    try {
      // 建立一个Socket,试图�q�接��C��?27.0.0.1的主机的2009端口,如果服务器已�l�在监听则会接收到这个请�?accept�Ҏ��产生一个和�q�边通信的Socket
      Socket socket=new Socket("127.0.0.1",2009);
      logger.info("客户端向服务器发赯��?");

      try {
        // 输入��?br />         InputStream inStream = socket.getInputStream();

        // 输出��?br />         OutputStream outStream = socket.getOutputStream();

        /**
         * 向服务器发送文�?br />          */
        // 输出��打印器
        PrintWriter out = new PrintWriter(outStream);
        out.println("地震高岗一�z�溪山千古秀");
        out.flush();

        /**
         * 接收服务器发送过来的文字
         */
        // 文本扫描�?br />         Scanner in = new Scanner(inStream);
        while (in.hasNextLine()) {
          String line = in.nextLine();
          logger.info("客户端获得响应文�?"+ line);
        }
      } finally {
        // 关闭Socket
        socket.close();
      }
    } catch (IOException ex) {
      ex.printStackTrace();
    }
}
}

和风�l�雨 2008-02-26 13:53 发表评论

使用java.text.SimpleDateFormat�c�进行文本日期和Date日期的�{�?

和风�l�雨 — Fri, 22 Feb 2008 00:50:00 GMT

Date�c�d��部既不存储年月日也不存储时分�U�，而是存储一个从1970�q?�?�?�?�?�U�开始的毫秒敎ͼ�而真正有用的�q�月日时分秒毫秒都是从这个毫�U�数转化而来�Q�这是它不容易被使用的地方，��其是显�C�和存储的场合。但Date�cȝ��优势在于方便计算和比较�?br /> 另一点，日常生活中我们习惯用�q�月日时分秒�q�样的文本日期来表示旉��Q�它方便昄��和存储，也容易理解，但不�Ҏ��计算和比较�?br /> �l�g��所�q�ͼ�我们在程序中�q�行日期旉��处理时经帔R��要在在文本日期和Date�c�M��间进行�{换，为此我们需要借助java.text.SimpleDateFormat�c�L��q�行处理�Q�下文列举了它的几个常用�C�Z��?/p>
1.��Date转化为常见的日期旉��字符�?br /> �q�里我们需要用到java.text.SimpleDateFormat�cȝ��format�Ҏ��Q�其中可以指定年月日时分�U�的模式字符串格式�?br /> Date date = new Date();
Format formatter = new SimpleDateFormat("yyyy�q�MM月dd日HH时mm分ss�U?);
System.out.println("转化的时间等�?"+formatter.format(date));
其中
yyyy表示四位数的�q�䆾
MM表示两位数的月䆾
dd表示两位数的日期
HH表示两位数的��时
mm表示两位数的分钟
ss表示两位数的�U�钟

2.��文本日期�{化�ؓDate以方便比�?/em>
文本日期的优势在于便于记忆，�Ҏ��处理�Q�但�~�点是不方便比较�Q�这时我们需要借助SimpleDateFormat的parse�Ҏ��得到Date对象再进行比较，实例如下�Q?br /> String strDate1="2004�q?�?�?;
String strDate2="2004�q?0�?�?;

SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy�q�MM月dd�?);
java.util.Date date1 = myFormatter.parse(strDate1);

java.util.Date date2 = myFormatter.parse(strDate2);

// Date比较能得出正��结�?br /> if(date2.compareTo(date1)>0){
      System.out.println(strDate2+">"+strDate1);
}

// 字符串比较得不出正确�l�果
if(strDate2.compareTo(strDate1)>0){
      System.out.println(strDate2+">"+strDate1);
}

3.��文本日期�{化�ؓDate以方便计��?/em>
文本日期的另一个大问题是不方便计算�Q�比如计��?008�q?�?日的100天后是那一天就不容易，此时我们�q�是需要把文本日期转化为Date�q�行计算�Q�再把结果�{化�ؓ文本日期�Q?br /> SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy�q�MM月dd�?);
java.util.Date date = myFormatter.parse("2008�q?�?�?);
date.setDate(date.getDate()+100);

Format formatter = new SimpleDateFormat("yyyy�q�MM月dd�?);

// 得到2008�q?4�?8�?br /> System.out.println("100天后�?+formatter.format(date));

和风�l�雨 2008-02-22 08:50 发表评论

反射Reflection�l�D��

和风�l�雨 — Thu, 21 Feb 2008 13:05:00 GMT

和风�l�雨 2008-02-21 21:05 发表评论

异常机制概述

和风�l�雨 — Thu, 21 Feb 2008 12:09:00 GMT

异常机制�l�D��

在运行过�E�中,应用�E�序可能遭遇各种严重�E�度不同的问�?异常提供了一�U�在不弄��q��序的情况下检查错误的巧妙方式.它也提供了一�U�直接报告错误的机制,而不必检查标志或者具有此作用的域.异常把方法能够报告的错误作�ؓ�Ҏ��U�定的一个显式部�?
异常能够被程序员看到,��q��译器��?�q�且由重载方法的子类保留.
如果遇到意外的错误将抛出异常,然后异常被方法调用栈上的子句捕获.如果异常未被捕获,��导致执行线�E�的�l�止.

异常的体�pȝ��?/strong>

毫无疑问,在java中异常是对象,它必定��承Throwable及其子类.Throwable中含有一个用于描�q�异常的字符�?Exception是Throwable的一个最常用子类,另一个子�c�L��Error.而RuntimeException�l�承自Exception.

异常的种�c?/strong>

非检查型异常(Unchecked Exception):
非检查型异常反映了程序中的逻辑错误,不能从运行中合理恢复.
标准的运行时异常和错误构成非��查型异常,它们�l�承自RuntimeException和Error.
非检查型异常不用昄��q�行捕获.

��查型异常(Checked Exception):
�q�种异常描述了这�U�情�?虽然是异常的,但被认�ؓ是可以合理发生的,如果�q�种异常真的发生�?必须调用某种�Ҏ��处理.
Java异常大多是检查型异常,�l�承自Exception�c?你自己定义的异常必须是��承Exception的检查型异常.
��查型异常必须�q�行昄��捕获.

自定义异�?/strong>

�l�承Exception卛_��定义自己的异�?以下是一�U�常见写�?br /> public class DBXmlFileReadException extends Exception{
public DBXmlFileReadException(String   msg){
    super(msg);
}
}

抛出异常

在Java语句�?可以用throw语句抛出异常,如throw new NoSuchElementException();
抛出的对象必��L��Throwable�cȝ��子类�?

抛出异常的策�?
1) 如果抛出后不可能得到处理,可以抛出Error.
2) 如果你想让其它类自由选择是否处理�q�个异常,��可以抛出RuntimeException.
3) 如果你要求类的用户必��d��理这个异�?则可以抛出Exception.

异常抛出后的控制权�{�U?/strong>

一旦发生异�?异常发生点后的动作将不会发生.此后��要发生的操作不是在catch块和finally�?

当异常抛出时,��D��异常发生的语句和表达式就被称为突然完�?语句的突然完成将��D��调用��N��渐展开,直到该异常被捕获.

如果该异常没有捕�?执行�U�程��中�?

Try,catch和finally

异常由包含在try块中的语句捕�?
    try{
      正常执行语句
    }
    catch(XException e){
      异常执行语句一
    }
    catch(XXException e){
      异常执行语句�?br />     }
    catch(XXXException e){
      异常执行语句�?br />     }
    finally{
      中止语句
    }

Try中的语句体要么顺利完�?要么执行到抛出异�?
如果抛出异常,��p��扑և�对应于异常类或其父类的catch子句,如果未能扑ֈ�合适的catch子句,异常��׃��try语句中扩散出�?�q�入到外层可能对它进行处理的try语句.
Catch子句可以有多�?只要�q�些子句捕获的异常类型不�?
如果在try中有finally子句,其代码在try把所有其它处理完成之后执�?
无论是正常完成或是出现异�?甚至是通过return或者break�q�样的控制语句结�?finally子句��L��被执�?
Catch子句和finally子句在try语句之后臛_��有一�?不要求全部出�?

More…

在catch语句中捕获通用的异常Exception通常不是最佳策�?因�ؓ它会��所有异常进行等同处�?
不能把基�c�d��常的catch语句攑ֈ�子类异常的catch语句之前,�~�译器会在运行之前就��查出�q�样的错�?
Try…catch�Ҏ��个catch语句都从头到��检�?如果扑ֈ�处理同类异常的catch子句,此catch块中的语句将得以执行,而不再处理同层次的其它catch�?
如果catch或finally抛出另一个异�?�E�序��不会再��L��查try的catch子句.
Try...catch语句可以嵌套,内层抛出的异常可被外层处�?

Throws子句

函数能抛出的��查型异常用throws声明,它后面可以是带用逗号隔开的一�p�d��异常�c�d��.仅仅那些在方法中不被捕获的异常必��d��?

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();

        // Read in size
        int size = s.readInt();

        // Initialize header
        header = new Entry(null, null, null);
        header.next = header.previous = header;

        // Read in all elements in the proper order.
        for (int i=0; i              addBefore((E)s.readObject(), header);
        }
}

More…

Throws子句的约定是严格强制性的,只能抛出throws子句中声明的异常�c�d��,抛出其它�c�d��的异常是非法�?不管是直接利用throw,�q�是调用别的�Ҏ��间接的抛�?
RuntimeException和Error是仅有的不必由throws子句列出的异�?
调用函数的函数要么处理对声明的异常进行处�?要么也声明同��L��异常,��收到的异常抛向上层.

�Ҏ��查型异常通常�q�行的几�U�处�?br /> 1) 用e.printStackTrace()输出异常信息.
2) ��异常记录到日志中以备查,如logger.error(e.getMessage()).
3) 试图�q�行异常恢复.
4) 告知�l�护者和用户发生的情�?

和风�l�雨 2008-02-21 20:09 发表评论

和风�l�雨 — Thu, 21 Feb 2008 12:03:00 GMT

内部�cȝ��出现

当进行Java开发时,有时需要实��C��个仅包含1-2个方法的接口.在AWT和Swing开发中�l�常出现�q�种情况,例如当一个display�l��g需要一个事件回调方法如一个按钮的ActionListener�? 如果使用普通的�c�L��实现此操�?最�l�会得到很多仅在单个位置上��用的��型�c?
内部�cȝ��于处理这�U�情�?java允许定义内部�c?而且可在Gui外��用内部类.

内部�cȝ��定义和实�?/strong>

内部�c�L��指在另一个类内部定义的一个类.可以��内部类定义��Z��个类的成�?
public class Linker{
public class LinkedNode{
    private LinkedNode prev;
    private LinkedNode next;
    private String content;

    public LinkedNode(String content){
      this.content=content;
    }
}

public Linker(){
    LinkedNode first=new LinkedNode("First");
    LinkedNode second=new LinkedNode("Second");

    first.next=second;
    second.prev=first;
}
}

定义在一个类�Ҏ��中的内部�c?/p>
public class Hapiness{
interface Smiler{
    public void smile();
}

public static void main(String[] args){
    class Happy implements Smiler{
      public void smile(){
        System.out.println(":-}");
      }
    }

    Happy happy=new Happy();
    happy.smile();
}
}

匿名�c?/strong>

对很多情况而言,定义在方法内部的�c�d��意义不大,它可以保持�ؓ匿名�?�E�序员关心的只是它的实例�?
�?
Runnable runner=new Runnable(){
     public void run(){
          // Run statememnt
     }
}

理解匿名�c?/strong>

匿名�c�dƈ不难理解,它只是把�cȝ��定义�q�程和实例的创徏�q�程混合而已,上页的语句实际上相当于如下语�?
// 定义�c?br /> Public class Runner implements Runnable{
     public void run(){
         // do sth
      }
}

// 创徏实例
Runner runner=new Runner();

使用匿名�cȝ��{�选解耦过�E?/strong>

需�?从公司的职员列表�?扑և��h��且�q�龄大于22的成�?

传统写法:

   List allmembers=company.getMembers();// 取得所有成�?br />     List results=new ArrayList();// �l�果列表

    for(Iterator it=allmembers.iterator();it.hasNext();){
     Member member=(Member)it.next();

     if(member.getAge()>22 && member.isMale()){ // �{��?�q�里是把查询条�g和遴选过�E�融合在一�?条�g一变立卛_��得加个分�?
      results.add(member);
     }
   }
传统�Ҏ��的缺�?/strong>

�q�种写法没有�?但是不是面向对象的写�?它有以下�~�陷:
1.查询条�g和筛选过�E�没有分��?
2.�q�样写的后果使Company变成了一个失血模型而不是领域模�?
3.换查询条件的�?上面除了"�{��?一句有变化外其它都是模板代�?重复性很�?

使用匿名�c�d��现的OO化查�?/strong>

真正�W�合OO的查询应该是�q�样:

   MemberFilter filter1=new MemberFilter(){
    public boolean accept(Member member) {
         return member.isMale() && member.getAge()>22;
    }
   };

   List ls=company.listMembers(filter1);

�q�段代码成功的把查询条�g作�ؓ一个接口分��M��出去,接口代码如下:

public interface MemberFilter{
public boolean accept(Member member);
}

查询函数的变�?/p>
而类Company增加了这样一个函�?

public List searchMembers(MemberFilter memberFilter){
   List retval=new ArrayList();

    for(Iterator it=members.iterator();it.hasNext();){
     Member member=(Member)it.next();

     if(memberFilter.accept(member)){
      retval.add(member);
    }
   }

   return retval;
}
�q�就把模板代码归�l�到了类内部,外面不会重复书写�?Company也同时拥有了数据和行�?而不是原来的数据容器�?

匿名�cȝ��例子�?/strong>

用匿名类处理分类汇�ȝ��Ҏ�� 分类汇��L��l�计中常�?举例来说如统计学生成�l?及格不及格的归类,分优良中差等�U�归�cȝ��,每个单项代码很好�?但是如果分类汇�ȝ��目多了,能一�U�汇��d��一个函数吗? 比如说有些科�?0分才��及�?有些�U�目50分就��?有些老师喜欢分优良中差四�{?有些老师却喜�Ƣ分ABCD;不一而��,如果每个都写一个函数无疑是个编写和�l�护恶梦. 如果我们用匿名类把分�c�L��ȝ��规则和分�c�L��ȝ��q�程分别抽象出来,代码��清晰灵�z�d��?以下代码讲述了这个过�E?

基本�c�Student

public class Student{
    private String name;
    private int score;

    public Student(String name,int score){
        this.name=name;
        this.score=score;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
}

用于分类汇�ȝ��c?/p>
它强制子�c�d��现getKey和getvalue两个�Ҏ��:
public abstract class ClassifyRule {
    public Student student;

    public ClassifyRule(){
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    abstract public String getKey();
    abstract public int getValue();
}

对Student�q�行�l�计处理的StudentService�c?/p>
注意getSum�Ҏ��,它保留了�{�选过�E?�{�选规则则不在其中:
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

public class StudentService {
    private List students;

    public StudentService() {
        students = new ArrayList();
    }

    public void add(Student student) {
        students.add(student);
    }

    public Hashtable getSum(ClassifyRule rule) {
        Hashtable ht = new Hashtable();

        for (Student student : students) {
            rule.setStudent(student);
            String key = rule.getKey();
            int value = rule.getValue();

            if (ht.containsKey(key)) {
                Integer oldValue = ht.remove(key);
                oldValue += value;
                ht.put(key, oldValue);
            } else {
                ht.put(key, value);
            }
        }

        return ht;
    }
}

��试代码,注意其中�{�选规则的创徏

public class Test {
    public static void main(String[] args) {
        // 初始�?br />         StudentService service = new StudentService();
        service.add(new Student("Andy", 90));
        service.add(new Student("Bill", 95));
        service.add(new Student("Cindy", 70));
        service.add(new Student("Dural", 85));
        service.add(new Student("Edin", 60));
        service.add(new Student("Felix", 55));
        service.add(new Student("Green", 15));

        // 60分及格筛�?br />         ClassifyRule rule60 = new ClassifyRule() {
            public String getKey() {
                return student.getScore() >= 60 ? "及格" : "不及�?;
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("60分及格筛�?);
        printHt(service.getSum(rule60));

        // 50分及格筛�?br />         ClassifyRule rule50 = new ClassifyRule() {
            public String getKey() {
                return student.getScore() >= 50 ? "及格" : "不及�?;
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("\n50分及格筛�?);
        printHt(service.getSum(rule50));

        // �?优良中差"�{��
        ClassifyRule ruleCn = new ClassifyRule() {
            public String getKey() {
                String retval = "";

                int score = student.getScore();
                if (score >= 90) {
                    retval = "�?;
                } else if (score >= 80) {
                    retval = "�?;
                } else if (score >= 60) {
                    retval = "�?;
                } else if (score > 0) {
                    retval = "�?;
                }

                return retval;
            }

            public int getValue() {
                return 1;
            }
        };

��试代码

System.out.println("\n分优良中差等�U�筛�?);
        printHt(service.getSum(ruleCn));

        // �?ABCD"�{��
        ClassifyRule ruleWest = new ClassifyRule() {
            public String getKey() {
                String retval = "";

                int score = student.getScore();
                if (score >= 90) {
                    retval = "A";
                } else if (score >= 80) {
                    retval = "B";
                } else if (score >= 60) {
                    retval = "C";
                } else if (score > 0) {
                    retval = "D";
                }

                return retval;
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("\n分ABCD�{��{��?);
        printHt(service.getSum(ruleWest));
    }

    private static void printHt(Hashtable ht) {
        for (Iterator it = ht.keySet().iterator(); it.hasNext();) {
            String key = (String) it.next();
            Integer value = (Integer) ht.get(key);
            System.out.println("Key=" + key + " Value=" + value);
        }
    }
}

��试�l�果如下:

60分及格筛�?br /> Key=及格 Value=5
Key=不及�?Value=2

50分及格筛�?br /> Key=及格 Value=6
Key=不及�?Value=1

分优良中差等�U�筛�?br /> Key=�?Value=2
Key=�?Value=1
Key=�?Value=2
Key=�?Value=2

分ABCD�{��{��?br /> Key=A Value=2
Key=D Value=2
Key=C Value=2
Key=B Value=1

��结

内部�c�M��叫嵌套类,一般不提倡书�?但它在java核心�c�M��都存�?如接口Map中的Entry,我们应该了解�q�能解读�q�种�Ҏ��.

匿名�cȝ��对而言有用得多,在解耦合和事件回调注册中很常�?大家应该对它的运用融会诏�?

和风�l�雨 2008-02-21 20:03 发表评论

常用开发术语表

和风�l�雨 — Thu, 21 Feb 2008 11:57:00 GMT

Abstract class:抽象�c?br /> Abstract method:抽象�Ҏ��
Annotation:注释
Anonymous class:匿名�c?br /> API(Application Programming Interface):应用�~�程接口,由方法和语言构成的库.
ArrayList:实现了List接口的动态数�l?br /> Assertion:断言
Atrribute map:属性映��?br /> Autoboxing:自动装箱,表示一个内�|�类型如int和它的包装类如Integer之间的自动�{�?/p>
Boolean function:布尔函数
Bytecode:字节�?/p>
Casting:�c�d��强制转换
Channel:频道
ClassCastException:当一个对象引用强制�{换程一个不兼容的类型时出现的异�?
Collection:一个表�C�对象组或集合的接口
CSV(Comma-separated values):一�U�用于存储表格数据的文�g形式
Complier:�~�译�?br /> Compose:合成
Composite function:复合函数,通过多个函数创徏的一个函�?/p>
Decimal:十进�?br /> Deep:深度
DOM(Document Object Model):文��对象模型,一�U�采用树形表�C�来处理XML数据的API.
Database:数据�?/p>
Edge:�?br /> Element:元素,XML文档中的一个节�?
Encapsulation:��装
End tag:�l�束标签
Enum:枚�D
Escaping:转义

Function:函数
Fuzzy search:模糊搜烦

Generic:泛型
Graph:�?br /> GUI:用户囑�Ş界面
Grid computing:�|�格计算
Group:�l?/p>
HashMap:一个将键值映��到值的查找对象
Heap memory:堆内�?br /> HTML(Hyper Text Markup Language):��文本标记语�a�
HTTP(HyperText Tranfer Protocol):��文本传输协�?/p>
Inheritance:�l�承
Inner class:内部�c?br /> Iterator:允许�q�代��C�Q何Collection�cȝ��一个接�?/p>
JDBC(Java Database Connectivity):java数据库连�?一�U�属于Java核心库的用于操作关系数据库的API.
JDK(Java Development Kit):java开发工具包
JRE(Java Runtime Environment):java�q�行时环�?br /> JSP(Java Server Page):java服务��?br /> JVM(Java Virtual machine):Java虚拟�?br /> JavaDoc:属于JDK的一�U�文��生成工�?br /> JavaScript:�q�行于客��L��,用于HTML处理的一�U�轻量��教本语言,语法部分�c�M��于Java.

Layout:布局
Lexical analysis:词法分析
Linked List:链表

Matcher:一个用于正则表辑ּ�模式匚w��的Java�c?br /> Metadata:元数�?br /> Millisecond:微妙

Namespace:命名�I�间
Neural network:��经�|�络
Node:节点

Object-oriented programmming:面向对象�~�程
Object pool:可以从中获得对象的一个实例池
Origin:原点
Override:子类覆写父类的方�?/p>
Parser:分析�?br /> Patch:补丁
Pattern:模式
Polymorphism:多态�?br /> Port:端口
Predicate:谓词
Prefix:前缀
Procedural language:�q�程式语�a�,如C
Property:属�?/p>
Real time:实时
Recursive:递归
Reference:引用
Reflection:反射
Regular expression:正则表达�?br /> Relative:相对
Resource:资源
Runnable:多线�E�编�E��用的一个接�?

Syntax:语法
Screen scraping:屏幕抓取
Split:分割
State:状�?br /> Static:静�?br /> Sequence:序列
Swing:构徏在AWT上更高��的图形用��L��?br /> Synchronized:同步,用于�U�程安全协作的技�?/p>
Tag:标签
Thread:�q�程
Tiger : Sun�l�Java1.5的代�?br /> Token:标记
Translation:�q�移
Triple:三元�l?br /> Type:�c�d��

Unicode:�l�一字符界面
Unit testing:单元��试

Visitor pattern:讉K��者模�?/p>
WAR(Web Application Archive):Web应用�E�序归��
Web Service:Web服务
Weight:�?br /> Well-formed:格式良好�?br /> Whitespace:�I�白�W?/p>
XML(Extensible Markup Language):一�U�描�q�分�U�数据结构的文本标记语言

和风�l�雨 2008-02-21 19:57 发表评论

链表讲解

和风�l�雨 — Thu, 21 Feb 2008 11:26:00 GMT

集合框架的��承体�p?/strong>

Java2中包含了6个集合接�?�q�些接口的通用目的实现�c?以及一个集合实用类Collections,共同�l�成了集合框架的核心.
6个集合接口如�?
Collection及其以下的List,Set,以及Set下的SortedSet
Map及其以下的SortedMap

链表的通用实现

ArrayList:�U�程不安全的动态数�l�类,扚w��查询速度�?单个查找速度�?
Vector:�U�程安全的动态数�l�类,效率比ArrayList低下.
LinkedList:动态链表类,适于在队列首��N��J�增删成员的场合.

链表的创�?/strong>

List ls=new ArrayList();// 1.5版本及以�?/p>
List ls=new ArrayList();// 1.5版本以下

之所以将ls�c�d��指定为List而不是ArrayList是因�?如果情况变化, ArrayList需要修�Ҏ��Vector或LinkedList时无��M��改其它代�?仅修改实例类型即�?

向List中添加元�?/p>
��d��单个元素
ls.add(new Member("Andy",21));

从别的链表中��d��多个元素
List ls2=new ArrayList();
ls2.add(new Member("Felex",21));
ls2.add(new Member("Gates",23));
ls.addAll(ls2);

注意:
1.5及其以上版本�?��d��的元素必��d��定义时一�?如ls的类型是List,那么向其中添加的元素必须是Member或其子类.
1.5以下版本�?�Ҏ��加的元素不作��?只要是Object卛_��,如果是基本类型则需装箱成类�c�d��.如ls.add(new Integer(8));

删除链表中元�?/strong>

ls.remove(member); // 直接删除对象,member=new Member("Edin",28)
ls.remove(2);           // 删除�W�三个元�?br /> ls.clear();                // ��已有数据全部清�?/p>
寚w��表进行遍�?/strong>

1) 1.5中独有的遍历�Ҏ��,代码最�?使用最方便
for(Member member:ls){
     // member��是依次取出的每个元�?br /> }

2) 常规�Ҏ��,多用于需要取得下标的场合,各版本均适用
for(int i=0;i     Member member=ls.get(i);// member��是依次取出的每个元�? 1.5及其以上版本适用, ls.size()为链表长�?br />     Member member=(Member)ls.get(i);// 1.5以下版本适用
}

3) 使用Iterator寚w��表进行遍历的�Ҏ��,各版本均适用
for(Iterator it=ls.iterator();it.hasNext();){
    Member member=(Member)it.next();
}

链表的其它常用的�Ҏ��

ls.contains(Object o);// �q�回链表中是否包含某元素
ls.indexOf(Object o);// �q�回对象o是链表中的第几号元素
isEmpty();// �q�回链表中是否有元素

寚w��表进行排�?br /> 1�Q�让List中元素必��d��l�实现Comparable接口:
public class Member implements Comparable {
private String name;

private int age;

public Member(String name, int age) {
    this.name = name;
    this.age = age;
}

public int compareTo(Object obj) {
    Member another = (Member) obj;
    return this.name.compareTo(another.name);// 按名�U�排�?如果是this.age-another.age则按�q�龄排序
}

public String toString(){
    return "Member name="+name+" age="+age;
}
}

2�Q�排序过�E?br /> List ls=new ArrayList();

ls.add(new Member("Felex",21));
ls.add(new Member("Gates",23));
ls.add(new Member("Andy",21));
ls.add(new Member("Bill",23));
ls.add(new Member("Cindy",24));
ls.add(new Member("Dell",27));

Collections.sort(ls);

for(Member member:ls){
      System.out.println(member);
}

输出:
Member name=Andy age=21
Member name=Bill age=23
Member name=Cindy age=24
Member name=Dell age=27
Member name=Felex age=21
Member name=Gates age=23

// 如果需要逆序可以使用Collections.reverse(ls);

链表与数�l�之间的转换

1) List转换成数�l?br /> List ls=new ArrayList();

ls.add("Felex");
ls.add("Gates");
ls.add("Andy");
ls.add("Bill");
ls.add("Cindy");
ls.add("Dell");

Object[] arr=ls.toArray();
for(Object obj:arr){
      System.out.println((Object)obj);
}

输出�?
Felex
Gates
Andy
Bill
Cindy
Dell

2) 数组转换成List
String[] arr={"Andy","Bill","Cindy","Dell"};
List ls=Arrays.asList(arr);
for(String str:ls){
     System.out.println(str);
}

输出:
Andy
Bill
Cindy
Dell

和风�l�雨 2008-02-21 19:26 发表评论

Hashtable基本用法概述

和风�l�雨 — Thu, 21 Feb 2008 11:20:00 GMT

Hashtable-哈希表类

以哈希表的�Ş式存储数�?数据的�Ş式是键值对.
特点:
查找速度�?遍历相对�?br /> 键��g��能有�I�指针和重复数据

创徏
Hashtable ht=new Hashtable();

��d�?/strong>

ht.put(1,"Andy");
ht.put(2,"Bill");
ht.put(3,"Cindy");
ht.put(4,"Dell");
ht.put(5,"Felex");
ht.put(6,"Edinburg");
ht.put(7,"Green");

取�?/strong>

String str=ht.get(1);
System.out.println(str);// Andy

寚w��q�行遍历

Iterator it = ht.keySet().iterator();

while (it.hasNext()) {
    Integer key = (Integer)it.next();
    System.out.println(key);
}

对��D��行遍�?/strong>

Iterator it = ht.values().iterator();

while (it.hasNext()) {
    String value =(String) it.next();
    System.out.println(value);
}

取Hashtable记录�?/strong>

Hashtable ht=new Hashtable();

ht.put(1,"Andy");
ht.put(2,"Bill");
ht.put(3,"Cindy");
ht.put(4,"Dell");
ht.put(5,"Felex");
ht.put(6,"Edinburg");
ht.put(7,"Green");

int i=ht.size();// 7

删除元素

Hashtable ht=new Hashtable();

ht.put(1,"Andy");
ht.put(2,"Bill");
ht.put(3,"Cindy");
ht.put(4,"Dell");
ht.put(5,"Felex");
ht.put(6,"Edinburg");
ht.put(7,"Green");

ht.remove(1);
ht.remove(2);
ht.remove(3);
ht.remove(4);

System.out.println(ht.size());// 3

Iterator it = ht.values().iterator();

while (it.hasNext()) {
        // Get value
    String value =(String) it.next();
    System.out.println(value);
}

输出:
3
Green
Edinburg
Felex

和风�l�雨 2008-02-21 19:20 发表评论

接口与抽象类概述

和风�l�雨 — Thu, 21 Feb 2008 11:09:00 GMT

�c?抽象�c�M��接口

�c?抽象�c�M��接口都是Java中实现��承和多态的手段.
�c�d��调的是��?br /> 接口��的是规范
抽象�c�d��而有�?/p>
什么是接口

接口是一�U�特�D�的�c?它只有方法定义而没有实�?实现的�Q务完全交�l�子�c�d��?
接口以interface标志.
�l�承接口用implements关键字实�?
接口可以�l�承接口.
接口可以有成�?但成员全是public static final�c�d��?
接口没有构造函�?
接口�l�Java提供了多�l�承机制

接口例子—Knockable

public interface Knockable{
        public static final String Sound="Bang!";
        public void knock();
}

接口例子-实现接口

public class Hammer implements Knockable{
    public void knock(){
           System.out.println(Sound);
    }
}

接口例子-实现多个接口

public interface Knockable{
    public static final String Sound="Bang!";
    public void knock();
}

public interface Clampable {
    public void clamp();
}

public class Pliers implements Knockable,Clampable{
   public void clamp(){
         // do sth
   }

   public void knock(){
        System.out.println(Sound);
   }
}

接口�l�承接口例子

public interface Knockable{
      public static final String Sound="Bang!";
      public void knock();
}

public interface Hitable extends Knockable{
      public void hit();
}

public class Stick implements Hitable{
      public void knock(){
          // do sth
      }

      public void hit(){
          // do sth
      }
}

什么叫抽象�c?/strong>

�c�M��h��抽象�Ҏ��的类为抽象类.抽象�Ҏ��以abstract在函数前修饰,只有定义没有实现,�q�一点和接口一�?
抽象�c�d��c�d��前需加上abstract修饰�W�以标识.
抽象�c�M��能生成实�?
抽象�cȝ��l�承性和�c�M��?

抽象�cȝ��实现

public abstract class Gun{
protected String cannon;
protected List bullets;

public abstract void shoot();

public void addBullet(Bullet bullet){
    if(bullets==null){
      bullets=new LinkedList();
    }

    bullets.add(bullet);
}
}

�l�承抽象�c?/strong>

public class Rifle extends Gun{
public void shoot(){
    // Shoot Sth
}

public void reload(){
    if(bullets!=null){
      bullets.clear();
    }

    addBullet(new Bullet());
    addBullet(new Bullet());
    addBullet(new Bullet());
    addBullet(new Bullet());
    addBullet(new Bullet());
    addBullet(new Bullet());
}
}

�l�承抽象�c�dƈ实现接口

public abstract class Gun{
protected String cannon;
protected List bullets;

public abstract void shoot();

public void addBullet(Bullet bullet){
    if(bullets==null){
      bullets=new LinkedList();
    }

    bullets.add(bullet);
}
}

public interface Thornable{
public void thorn();
}

public class SpringFieldRifle extends Gun implements Thornable{
public void thorn(){
    // thorn sth
}

public void shoot(){
    // shoot sth
}
}

抽象�cȝ��承抽象类实现接口的例�?/strong>

public abstract class Gun{
protected String cannon;
protected List bullets;

public abstract void shoot();

public void addBullet(Bullet bullet){
    if(bullets==null){
      bullets=new LinkedList();
    }

    bullets.add(bullet);
}
}

public interface Handable{
public void hold();
}

public abstract class HandGun extends Gun implements Handable{

}

public class BlackStar extends HandGun{
public void hold(){
    // Hold the gun
}

public void shoot(){
    // Shoot Sth
}
}

抽象�c?接口,�cȝ��区别

�l�承好比家学渊源,所�?忠厚传家�?诗书�l�世�?,安��M��潜移默化的媄响下一�?下一代也会在不经意中学习前辈的特�?但因为年��分辨能力不高加上世易时�U�L��些优点已�l�不再是有点甚至会变成缺�?下一代会把前辈的优缺点不分良莠的�l�承下来.�q�也是日后出现问题的�Ҏ��.

接口好比拜师学艺,"入了�q�个�?��得说这行话",比如相声界说学逗唱四门是必��要学的,但是"师傅领进�?修行在个�?,学得怎么栯��全看自己,指望不费力的�l�承什么是不可能的,具体功夫�q�得个�h来过. 因�ؓ是自己来,具体实现成什么样自由度也很大,比如四门功课中的"�?,原指唱太�q�x��?但因为爱听的��?现在相声演员已经不要求这个了,改�ؓ唱歌唱戏的唱,其实严格界定的话�?�?的一�U?�q�也无所谓对�?郭�d刚坚持唱太��^歌词也行,�W�林唱流行歌曲也不错,��M��实现了就可以,实现得怎么样则留给实践来检�?一个类可以同时实现多个接口,��和��Z�h拜几个师傅是没有问题�?郭�d刚就同时实现了大鼓和相声两个接口.

抽象�c�d��介于�l�承和接口之�?既可不费力的从上一代��?也可强制实现某接�?有如某大师收自己的孩子�ؓ�?当然相声界不让这么干,其它曲艺行业�q�是可以�?比如京剧界的梅兰芛_��其子梅葆�?既有�a�传��n�?也有强制实现,�l�合了��承和接口的特�?

抽象�c?接口,�cȝ��详细区别

接口抽象�c?/td> �c?/td>

可以�l�承�?/td> 接口抽象�c?�c?/td> 抽象�c?�c?/td>

可以实现�?/td> �?/td> 一个或多个接口一个或多个接口

有否成员只有static final成员均可均可

是否有构造函�?/td> �?/td> �?/td> �?/td>

可否实例�?/td> 不可不可 �?/td>

意图规范行�ؓ �l�承成员+规范行�ؓ �l�承成员

抽象�c?接口和类在��承体�p�M��的位�|?/strong>

抽象�c?接口一般来说都是从一般类�ȝ��归纳出来的抽象共性的东西,�c�d��是实际具体的东西.
一般来�?应该把合理抽象出的抽象类,接口攑֜��cȝ��承体�pȝ��上层,子类依靠�c�L��实现.

和风�l�雨 2008-02-21 19:09 发表评论

	接口	抽象�c?/td>	�c?/td>
可以�l�承�?/td>	接口	抽象�c?�c?/td>	抽象�c?�c?/td>
可以实现�?/td>	�?/td>	一个或多个接口	一个或多个接口
有否成员	只有static final成员	均可	均可
是否有构造函�?/td>	�?/td>	�?/td>	�?/td>
可否实例�?/td>	不可	不可	�?/td>
意图	规范行�ؓ	�l�承成员+规范行�ؓ	�l�承成员