考考你的java 基础，求出三段代码的输出值


代码1：

public static void main(String[] args) {
	ArrayList<Short> s = new ArrayList<Short>();
  
		for(short i=0;i<100;i++){
			s.add(i);
			s.remove(i-1);
		}
		System.out.println(s.size());
}

代码2：

                 /**
	 * @param args
	 */
	public static void main(String[] args) {
		Set<Short> s = new HashSet<Short>();
		
		for(short i=0;i<100;i++){
			s.add(i);
			s.remove(i-1);
		}
		System.out.println(s.size());
	}

 
代码3：

public static void main(String[] args) {
	ArrayList<Short> s = new ArrayList<Short>();
		
		for(short i=0;i<100;i++){
			s.add(i);
			s.remove((Object)(i-1));
		}
	System.out.println(s.size());
}

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛

aacPlus 简介

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

可能有的概念您还不是太了解，譬如什么叫“历史集合”，Hashtable、HashMap、TreeMap三者之间有什么区别和联系，怎样实现对一个特定集合的快速遍历、元素查找或者排序，没关系，我们在下面将逐一进行研究。

细节考虑：目标与效率

有了JCF的层次还不够，重要的是对集合所容纳的对象的具体操作，以前我们学数据结构的时候可能老师总会让你计算一个算法的时间复杂度，可能你会对这个O(f(n))很不耐烦，但事实上算法效率是一个重要的因素。

1. 侧重点：遍历 vs. 查找
对集合的有两个主要的应用：我需要知道集合有哪些元素；根据条件找到一个特定的元素。在算法上通常称为“遍历”和“查找”。不要以为我们生活中不常用哦！譬如CCTV的“幸运52”里面，李咏让参赛者报出一款PDA的准确价位，他会怎么做？“2000”“高了”“1000”“低了”“1500”“低了”……直到答对为止。可能有很多人都会选择这个策略，无论他是不是计算机专业出身的，也不知道他是不是了解“数据结构”和“折半查找”，更不用说他是不是知道还有比在无初始代价下O(log n)的时间复杂度更快的算法了，但我们经常会自然而然地用这样的方法，这和一个人的行业无关，除非这个人的rp超强，呵呵……
又讲了一堆题外话了，遍历和修改似乎是一对矛盾，一个可以高效率插入删除元素的数据结构通常遍历的性能并不是最优。于是JCF在这里根据用户的目标实现了两种定制的数据结构：哈希表（包括HashSet和HashMap）和平衡二叉树（包括TreeSet和TreeMap）。由于可排序性是一种独特的要求，所以引入了SortedSet和SortedMap，它们分别是AbstractSet和AbstractMap的子接口，而TreeSet和TreeMap又分别是他们的一种实现。熟悉数据结构的人可能比较了解，哈希表在进行插入、删除、查找这样的操作是很快的，其时间复杂度是常数级O(1)；平衡二叉树虽然插入、删除操作比较麻烦（需要O(log n)的代价），但进行遍历和排序却很快。选择完全在于用户的侧重点，但由于类型转换的方便性，通常我们用哈希表构造一个集合以后，再把它转换成相应的树集进行遍历，以获得较好的效果。

Set set1 = new HashSet();
set1.add(elem1);// 通过插入元素构造集合
set1.add(elem2);
set1.add(elem3);
Set set2 = new TreeSet(set);
Iterator all = set2.iterator();
while (all.hasNext())
{// 遍历集合
all.next();
...
}

2. 历史实现 vs. 新实现
历史实现（Legacy Implementations）是JCF的一个术语，准确的意义不是很清楚，但大致可以认为在Java 2（JDK 1.2）出现以前的老版本中JCF的一个雏形框架。在Java 2以后，JCF才开始完善健壮起来，新实现中出现了一些新的类用于替代老版本中的成员，但由于种种原因，老版本中很多类都代表了传统数据结构的精髓部分，以及一些安全原因，所以仍然被我们使用着。

Enumeration vs. Iterator
Enumeration是一个传统的集合遍历工具，在新的JCF中使用的是Iterator，Iterator同样具有遍历功能，还包含一个remove()方法来删除当前得到的元素。

Dictionary vs. Map
Dictionary是一个现在已经被标记为deprecated的类，实现了老版本中的映射功能，现在已经完全被Map取代。它们的区别是：Dictionary不key和value不能为null，但Map却允许空的关键字和值，这一点直接影响到它们的后代：Hashtable和HashMap。

Vector vs. ArrayList
Vector和ArrayList是数组在JCF中的体现，还记得前面讲过的数组的缺点么？Vector和ArrayList就是一种可以动态增长的数组。Vector是历史实现，它和ArrayList的主要区别在于，Vector是同步集合（或者说是线程安全的），但ArrayList并不是同步的，由于同步需要花一定的代价，所以ArrayList看起来要比Vector的存取访问效率更高。关于同步我们下面还将要谈到。

Hashtable vs. HashMap
Hashtable是Dictionary的子类，属于历史实现，而HashMap是Map的子类，是新实现。它们的区别除了上面所说的key和value是否可以为空之外，也有同步的差别，Hashtable是同步的，但HashMap不是。不过不要因为Hashtable是“老前辈”而瞧不起它哦，它的一个著名的子类Properties我们可是经常会用到的。

3. 同步 vs. 不同步
从上面的描述中我们似乎可以得出这么一个印象：历史实现好像都是同步的，但新实现中却没有。需要同步操作的理由是，可能存在多个线程对同一个集合进行操作的情况：譬如一个线程正在对某集合进行遍历，但与此同时，另一个线程又在对该集合进行插入或删除，那么第一个线程的遍历结果将是不可预测的，对于同步集合，它将会抛出一个ConcurrentModificationException异常，JCF把这种机制成为“fail-fast”。我们对比一下Vector和ArrayList的源代码就可以发现Vector的很多方法都是有synchronized关键字修饰的，但ArrayList没有。

4. 容易遗忘的工具：Collections和Arrays
在图1中右下角落里有两个类叫做Collections（注意，不是Collection！）和Arrays，这是JCF里面功能强大的工具，但初学者往往会忽视。按JCF文档的说法，这两个类提供了封装器实现（Wrapper Implementations）、数据结构算法和数组相关的应用。
想必大家不会忘记上面谈到的“折半查找”、“排序”等经典算法吧，Collections类提供了丰富的静态方法帮助我们轻松完成这些在数据结构课上烦人的工作：

binarySearch：折半查找。
sort：排序，这里是一种类似于快速排序的方法，效率仍然是O(n * log n)，但却是一种稳定的排序方法。
reverse：将线性表进行逆序操作，这个可是从前数据结构的经典考题哦！
rotate：以某个元素为轴心将线性表“旋转”??哇，这个功能太酷了！
swap：交换一个线性表中两个元素的位置。
……

Collections还有一个重要功能就是“封装器”（Wrapper），它提供了一些方法可以把一个集合转换成一个特殊的集合：

unmodifiableXXX：转换成只读集合，这里XXX代表六种基本集合接口：Collection、List、Map、Set、SortedMap和SortedSet。如果你对只读集合进行插入删除操作，将会抛出UnsupportedOperationException异常。
synchronizedXXX：转换成同步集合。
singleton：创建一个仅有一个元素的集合，这里singleton生成的是单元素Set，singletonList和singletonMap分别生成单元素的List和Map。
空集：由Collections的静态属性EMPTY_SET、EMPTY_LIST和EMPTY_MAP表示。

此外，我们知道把集合转换成对象数组可以用Collection的toArray()方法，我们也可以方便地把一个对象数组转换成一个线性表（可不要告诉我你是一个一个地add哦）：Arrays.asList()。

5. 泛型
目前我们了解的JCF的一个重要特征是：所有加入到集合当中的对象都将在表面上失去它们自己的特性，而看上去仅仅只是一个Object对象而已，除非你把它强制类型转换成它们原来的对象。这一点很自然，集合嘛，对象的容器，它容纳的是各种各样的对象，而不仅仅是某种特定类型的对象。J2SE 5.0出现以后，JCF开始引入泛型的特性，譬如我们经常碰到这样的应用，就是把集合转换成特定的数组，虽然Collection有toArray()的方法，但可惜的是，这个数组的所有元素都是Object类型的，我们通常的做法是用一个for循环把数组的每个元素都进行强制类型转换，虽然可行，但看上去很笨拙，如果有了泛型，我们就可以预先指定要得到的类型，然后一次toArray就可以得到我们期望的数组，里面的元素全部都是指定类型了。惭愧的是，我对5.0还不是太了解，具体可以参考J2SE 5.0的JCF文档。

小结

我这里走马观花一样把JCF的一些主要概念罗嗦了一下，Java的老手们可能比较厌烦，新手们可能更觉得像回顾了一下高中的数学课和大学的数据结构，呵呵。这只是一个小小的例子，可见基础知识对现实当中的应用还是蛮有指导意义的。大师们看数学，觉得那是很唯美很艺术的一样东西，西方一直都把数学区别于其它自然科学，而认为它更靠近于哲学，像我等这样整天还在为找工作烦得要死的俗人还是没法入道啊，sigh……

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

最近在搞JAVA和python， 可是eclipse 老是出现这样那样的问题，今天没什么事，从网上把eclipse 3.3 ，myeclipse6.0和一些插件重新搞了一个最新的开发工具。集成完成一看500多M。不过我电脑上跑的还是满好的。把一些插件共享一些：

下载最新的eclipse 3.3：eclipse-jee-europa-fall2-win32.zip

下载最新的myeclipse 6.0：MyEclipse_6.0.1GA_E3.3.1_Installer.exe

在网上搜了一下注册码，下面把 6.0GA / M1 和 5.5GA 版本的“注册信息”“注册码”“破解”给大家：

Subscriber:
Subscriber Code: jLR8ZC-655355-5450765457039125
或者
Subscriber:
Subscriber Code: jLR7ZL-655355-5450755330522962
适用于早期的 5.5 M2 版本的：

Subscriber:
Subscriber Code: jLR8ZC-956-55-5467865833584547
适用于早期的 5.1.1 GA 和 5.5 M1 版本的：

Subscriber:
Subscriber Code: jLR8ZC-444-55-4467865481680090
注册成功后会发现：

Subscriber:
Product ID: E3MP (MyEclipse Professional Subscription)
License version: x.x
Full Maintenance Included
Subscription expiration date (YYYYMMDD): 20090520
Number of licenses: 800

安装步骤大家应该很清楚了，这里主要说一下集成了哪些插件:

1.  Subversion是下一代版本(或源码)控制系统,它的目的是代替CVS下载. 
            在线安装更新地址 :  Eclipse update site URL: http://subclipse.tigris.org/update_1.2.x

2.PyDevPyDev是一个允许用户利用Eclipse进行Python开发。
                它提供了一些很好的功能如：代码填空，语法高亮显示，语法分析，重构(refactor)和调试等等．
                 在线安装更新地址 :http://pydev.sourceforge.net/updates/

3.  JyDT    Jython开发工具。

                  在线安装更新地址 : :   http://www.redrobinsoftware.net/jydt/updatesite

4.  基于Eclipse的Java反编译插件

                  在线更新地址 : http://www.technoetic.com/eclipse/update

5.  JSEclipse可以编辑JavaScript 文件，支持语法突出显示和包括了一些常用的面向对象的方法。

      支持的面向对象的功能有：构造函数，类方法，实例方法，类变量等等。支持代码错误提示，警靠报告等。 
     在线安装更新地址 : http://download.macromedia.com/pub/labs/jseclipse/autoinstall/

6.  Implementors当追踪方法代码时，Eclipse默认是转到方法的接口类，而接口中是只有方法名称没有具体的实现代码，
      此插件提供了追踪到具体实现类的实现代码的功能。
      在线更新地址 :  http://eclipse-tools.sourceforge.net/updates/

7.  Easy ExplorerEasy Explorer 打开在eclipse中选定文件所在的目录
     在线安装更新地址 : http://easystruts.sourceforge.net/eclipse/updates/

8.   JSEclipse可以编辑JavaScript 文件，支持语法突出显示和包括了一些常用的面向对象的方法。
       支持的面向对象的功能有：构造函数，类方法，实例方法，类变量等等。支持代码错误提示，警靠报告等。

9.   JAutodoc   JAutodoc是一个能够自动为你的源代码加上Javadoc注释的Eclipse插件。

      在线安装更新地址  :  http://jautodoc.sourceforge.net/update/

10. moreUnitmoreUnit这个插件用于帮助开发单元测试。它能够修饰一个有测试案例的类。
       在编辑器中标记被测试的方法。在编辑器中通过菜单或快捷键跳到测试案例。
       在编辑器中通过菜单或快捷键为光标所在位置的方法生成一个测试方法存根。
       在线安装更新地址 : http://moreunit.sourceforge.net/org.moreunit.updatesite/

11.Properties Editor  编辑java的属性文件，并可以自动存盘为Unicode格式
              http://propedit.sourceforge.jp/index_en.html 
             在线安装更新地址 : http://propedit.sourceforge.jp/eclipse/updates/

      我觉得这些插件集成完成以后会对开发有很大的帮助。

12. Maven2 Eclipse 插件
                http://m2eclipse.codehaus.org/

13. Spring IDE
               http://springide.org/project

14. XFire (WebService)
                http://dist.codehaus.org/xfire/update/

• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师

最近做python，下面是一段测试数据库性能的代码。

数据库表记录：1000000条。

开200个线程，100个同时并发。

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import os
import os.path
import re
import MySQLdb
import httplib, mimetypes
import traceback
import logging
import ConfigParser
import time
import threading
import string
import codecs
import random
import datetime

class SelectView(threading.Thread):
   
    def __init__(self, threadName):
        threading.Thread.__init__(self, name = threadName)
   
    def run(self):
       
       
        #global dbConn
        #dbConn = MySQLdb.connect(host=dbhost, port=dbport, user=dbuser, passwd=dbpass, db=dbschema, use_unicode=True, charset='utf8')
       
        for i in range(100):
       
            start =time.time()
       
            print self.getName(),"-->Thread start!"+getDbDateString()
            logger.info(self.getName()+"-->Thread start!"+getDbDateString())
            try:
                dbConn = None
                dbConn = MySQLdb.connect(host=dbhost, port=dbport, user=dbuser, passwd=dbpass, db=dbschema, use_unicode=True, charset='utf8')
       
                strss = string.join(random.sample(['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','T','Z'], 1)).replace(" ","")
                #print "query str----"+strss
                sql = "SELECT * FROM smartone_metainfo_view as s where songName like '%"+strss+"%' limit 200"
                cursor = dbConn.cursor()
                cursor.execute(sql)
                songid =""
                for counts in cursor.fetchall():
                   
                    songid= songid + str(counts[0])+str(counts[1])+str(counts[2])+str(counts[3])+str(counts[4])+str(counts[5])+str(counts[6])+str(counts[7])+str(counts[8])+str(counts[9])+str(counts[10])+str(counts[11])+str(counts[12])+str(counts[13])+str(counts[14])+str(counts[15])+ str(counts[16])+str(counts[17])+str(counts[18])+str(counts[19])+str(counts[20])+str(counts[21])+str(counts[22])+str(counts[23])+str(counts[24])+str(counts[25])+str(counts[26])+str(counts[27])+str(counts[28])+str(counts[29])+str(counts[30])+str(counts[31])
                end =time.time()
                sec = end - start
                print " thread,execute total time is----",sec," second"
                logger.info(" thread execute finish,execute total time is----"+str(sec)+" second")
                print songid
                #print "size --"+str(len(counts))+"songId---"+str(counts[0])# self.getName(),"--query result:--total count--"+str(counts[0])#+"----songName:"+counts[1]+"----isrc"+str(counts[2])  
                #logger.info("size --"+str(len(counts))+"songId---"+str(counts[0]))
               
                #print "command free----",os.system('free')
                dbConn.close()
            except:
               etype, evalue = sys.exc_info()[:2]
               logger.info(self.getName()+"--Thread,-query data failed!---Type: " +str(etype)+"----Value--:"+str(evalue))
              
               print "Type: " , etype
               print "Value: " , evalue
        #cmd = "mysqladmin -uMELODEO_USER -p6DF0FF9674EC1A397A430F9F2FCB2C64 -h202.153.121.172 status"
#        strs = os.system(cmd)
        #lines = os.popen(cmd).readlines()
        #for line in lines:
        #    print line.rstrip()
        #logger.info("".join(lines))     
       
           
        #sem.release()
       
 
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

def init_settings(profile, config_file):
        #read ini file
    #    config_file = "c:/contentstext/processCommonFormat.ini"
    #    print os.getcwd()
        cfg = ConfigParser.RawConfigParser()
        cfg.read(config_file)
    
        #define the directory we are writing out to and some other parameters.
        global dbhost
        dbhost = cfg.get(profile, "dbhost")
        global dbport
        dbport = int( cfg.get(profile, "dbport"))
        global dbuser
        dbuser = cfg.get(profile, "dbuser")
        global dbpass
        dbpass = cfg.get(profile, "dbpassword")
        global dbschema
        dbschema = cfg.get(profile, "db")
        global USE_UNICODE
        try:
            use_unicode = cfg.get(profile, "USE_UNICODE")
            if (use_unicode == 'Y'):
                USE_UNICODE=True
            else:
                USE_UNICODE=False
        except:
            USE_UNICODE=False 
    
        #set up logs - ripped from contentManager.py
        LOG_FILE = './smartone_200.log'
   
        val  = cfg.get(profile, "loglevel")                    # The configured log level
        if len(val) >0:
            if val == 'debug':
                log_level = logging.DEBUG
            elif val == 'info':
                log_level = logging.INFO
            elif val == 'warning':
                log_level = logging.WARNING
            elif val == 'error':
                log_level = logging.ERROR
            elif val == 'critical':
                log_level = logging.CRITICAL
        else:
            log_level = logging.INFO
   
        val  = cfg.get(profile, "log_format")        # The format string for this logging session
        if len(val) >0:
            log_format = val
        else:
            log_format = '%(asctime)s %(levelname)s %(message)s'
   
        ###################
        # Initialize logger
        global logger
        logger = logging.getLogger('sessioninfo')
        hdlr = logging.FileHandler(LOG_FILE)
        formatter = logging.Formatter(log_format)
        hdlr.setFormatter(formatter)
        logger.addHandler(hdlr)
        logger.setLevel(log_level)   

def getDbDateString():
    now = datetime.datetime.today()
    #should probably do this using a formatting string - don't feel like reading docs.
    return str(now.year) + "-" + str(now.month) + "-" + str(now.day) + " " + str(now.hour) + ":" + str(now.minute) + ":" + str(now.second)

       
if __name__ == "__main__":
   
    config_file = "./smartone_DataTest.ini"
    profile = "smartone"
   
    init_settings(profile, config_file)
    maxThread = 200
       
    #threading.
    import socket 
    socket.setdefaulttimeout(15)  
    threadList=[]
    #threading.BoundedSemaphore(maxThread)
    for i in range(maxThread):
        #sv = SelectView()
       
        threads = SelectView('thread'+str(i))
        threadList.append(threads)
    #threadList.remove(len(threadList))
    print '\nStarting threads'
   
    for i in threadList:
        i.start()
   
    print 'All threads started\n'
   
    for i in threadList:
        i.join()   
   
    print "All thread has create,Wait for all thread exit."
#      
    #sv.executeThread()
#    sv = SelectView()
#    cout = sv.selectView()
#    print "wewe----",cout

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

转自：http://www.ceocio.com.cn/blog/user1/4517/archives/2007/7350.html 

代码复用是绝大多数程序员所期望的，也是OO的目标之一。总结我多年的编码经验，为了使代码能够最大程度上复用，应该特别注意以下几个方面。

1、 对接口编程
 
　　"对接口编程"是面向对象设计（OOD）的第一个基本原则。它的含义是：使用接口和同类型的组件通讯，即，对于所有完成相同功能的组件，应该抽象出一个接口，它们都实现该接口。具体到JAVA中，可以是接口（interface），或者是抽象类（abstract class），所有完成相同功能的组件都实现该接口，或者从该抽象类继承。我们的客户代码只应该和该接口通讯，这样，当我们需要用其它组件完成任务时，只需要替换该接口的实现，而我们代码的其它部分不需要改变！

　　当现有的组件不能满足要求时，我们可以创建新的组件，实现该接口，或者，直接对现有的组件进行扩展，由子类去完成扩展的功能。

2、 优先使用对象组合，而不是类继承
 
　　"优先使用对象组合，而不是类继承"是面向对象设计的第二个原则。并不是说继承不重要，而是因为每个学习OOP的人都知道OO的基本特性之一就是继承，以至于继承已经被滥用了，而对象组合技术往往被忽视了。下面分析继承和组合的优缺点：

　　类继承允许你根据其他类的实现来定义一个类的实现。这种通过生成子类的复用通常被称为白箱复用(white-box reuse)。术语"白箱"是相对可视性而言：在继承方式中，父类的内部细节对子类可见。

　　对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组合对象来获得。对象组合要求对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为被组合的对象的内部细节是不可见的。对象只以"黑箱"的形式出现。

　　继承和组合各有优缺点。类继承是在编译时刻静态定义的，且可直接使用，类继承可以较方便地改变父类的实现。但是类继承也有一些不足之处。首先，因为继承在编译时刻就定义了，所以无法在运行时刻改变从父类继承的实现。更糟的是，父类通常至少定义了子类的部分行为，父类的任何改变都可能影响子类的行为。如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性。

　　对象组合是通过获得对其他对象的引用而在运行时刻动态定义的。由于组合要求对象具有良好定义的接口，而且，对象只能通过接口访问，所以我们并不破坏封装性；只要类型一致，运行时刻还可以用一个对象来替代另一个对象；更进一步，因为对象的实现是基于接口写的，所以实现上存在较少的依赖关系。

　　优先使用对象组合有助于你保持每个类被封装，并且只集中完成单个任务。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物（这正是滥用继承的后果）。另一方面，基于对象组合的设计会有更多的对象(但只有较少的类)，且系统的行为将依赖于对象间的关系而不是被定义在某个类中。

　　注意：理想情况下，我们不用为获得复用而去创建新的组件，只需要使用对象组合技术，通过组装已有的组件就能获得需要的功能。但是事实很少如此，因为可用的组件集合并不丰富。使用继承的复用使得创建新的组件要比组装已有的组件来得容易。这样，继承和对象组合常一起使用。然而，正如前面所说，千万不要滥用继承而忽视了对象组合技术。

　　相关的设计模式有：Bridge、Composite、Decorator、Observer、Strategy等。

　　下面的例子演示了这个规则，它的前提是：我们对同一个数据结构，需要以任意的格式输出。

　　第一个例子，我们使用基于继承的框架，可以看到，它很难维护和扩展。
　　abstract class AbstractExampleDocument
　　{
　　　// skip some code ...
　　　　public void output(Example structure)
　　　　{
　　　　　if( null != structure )
　　　　　　{
　　　　　　　this.format( structure );
　　　　　　}
　　　　}
　　　　protected void format(Example structure);
　　}

　　第二个例子，我们使用基于对象组合技术的框架，每个对象的任务都清楚的分离开来，我们可以替换、扩展格式类，而不用考虑其它的任何事情。
　　class DefaultExampleDocument
　　{
　　　// skip some code ...
　　　public void output(Example structure)
　　　{
　　　　　ExampleFormatter formatter =
　　　　　(ExampleFormatter) manager.lookup(Roles.FORMATTER);
　　　　　if( null != structure )
　　　　　{
　　　　　　　formatter.format(structure);
　　　　　}
　　　}
　　}

　　这里，用到了类似于"抽象工厂"的组件创建模式，它将组件的创建过程交给manager来完成；ExampleFormatter是所有格式的抽象父类；

3、 将可变的部分和不可变的部分分离
 
　　"将可变的部分和不可变的部分分离"是面向对象设计的第三个原则。如果使用继承的复用技术，我们可以在抽象基类中定义好不可变的部分，而由其子类去具体实现可变的部分，不可变的部分不需要重复定义，而且便于维护。如果使用对象组合的复用技术，我们可以定义好不可变的部分，而可变的部分可以由不同的组件实现，根据需要，在运行时动态配置。这样，我们就有更多的时间关注可变的部分。

　　对于对象组合技术而言，每个组件只完成相对较小的功能，相互之间耦合比较松散，复用率较高，通过组合，就能获得新的功能。

4、 减少方法的长度
 
　　通常，我们的方法应该只有尽量少的几行，太长的方法会难以理解，而且，如果方法太长，则应该重新设计。对此，可以总结为以下原则：

三十秒原则：
　　如果另一个程序员无法在三十秒之内了解你的函数做了什么（What），如何做(How)以及为什么要这样做(Why)，那就说明你的代码是难以维护的，必须得到提高；
一屏原则：
如果一个函数的代码长度超过一个屏幕，那么或许这个函数太长了，应该拆分成更小的子函数；
一行代码尽量简短，并且保证一行代码只做一件事

那种看似技巧性的冗长代码只会增加代码维护的难度。

5、 消除case / if语句
 
　　要尽量避免在代码中出现判断语句，来测试一个对象是否某个特定类的实例。通常，如果你需要这么做，那么，重新设计可能会有所帮助。我在工作中遇到这样的一个问题：我们在使用JAVA做XML解析时，对每个标签映射了一个JAVA类，采用SAX（简单的XML接口API：Simple API for XML）模型。结果，代码中反复出现了大量的判断语句，来测试当前的标签类型。为此，我们重新设计了DTD（文档类型定义：Document Type Definition），为每个标签增加了一个固定的属性：classname，而且重新设计了每个标签映射的JAVA类的接口，统一了每个对象的操作： addElement(Element aElement); //增加子元素
addAttribute(String attName, String att); //增加属性；

则彻底消除了所有的测试当前的标签类型的判断语句。每个对象通过 Class.forName(aElement.attributes.getAttribute("classname")).newInstence(); 动态创建，

6、 减少参数个数
 
　　有大量参数需要传递的方法，通常很难阅读。我们可以将所有参数封装到一个对象中来完成对象的传递，这也有利于错误跟踪。

许多程序员因为，太多层的对象包装对系统效率有影响。是的，但是，和它带来的好处相比，我们宁愿做包装。毕竟，"封装"也是OO的基本特性之一，而且，"每个对象完成尽量少（而且简单）的功能"，也是OO的一个基本原则。

7、 类层次的最高层应该是抽象类。
 
　　在许多情况下，提供一个抽象基类有利做特性化扩展。由于在抽象基类中，大部分的功能和行为已经定义好，使我们更容易理解接口设计者的意图是什么。

由于JAVA不允许"多继承"，从一个抽象基类继承，就无法再从其它基类继承了。所以，提供一个抽象接口(interface)是个好主意，一个类可以实现多个接口，从而模拟实现了"多继承"，为类的设计提供了更大的灵活性。

8、 尽量减少对变量的直接访问。
 
　　对数据的封装原则应该规范化，不要把一个类的属性暴露给其它类，而是应该通过访问方法去保护他们，这有利于避免产生波纹效应。如果某个属性的名字改变，你只需要修改它的访问方法，而不是修改所有相关的代码。

9、 子类应该特性化，完成特殊功能。
 
　　如果一个子类只是使一个组件变成组件管理器，而不是实现接口功能，或者，重载某个功能，那么，就应该使用一个外部的容器类，而不是创建一个子类。

　　建议：类层次结构图，不要太深；

　　例如：下面的接口定义了组件的功能：发送消息；类Transceiver实现了该接口；而其子类Pool只是管理多个Transceiver对象，而没有提供自己的接口实现。建议使用组合方式，而不是继承！

　　public interface ITransceiver{
　　　　public abstract send(String msg);
　　}

　　public class Transceiver implements ITransceiver {
　　　　public send(String msg){
　　　　　　System.out.println(msg);
　　　　}
　　}

//使用继承方式的实现
　　public class Pool extends Transceiver{
　　　　private List pool = new Vector();
　　　　public void add(Transceiver aTransceiver){
　　　　　　pool.add(aTransceiver);
　　　　}
　　　　public Transceiver get(int index){
　　　　　　pool.get(index);
　　　　}
　　}

//使用组合方式的实现
　　public class Pool {
　　　　private List pool = new Vector();
　　　　public void add(Transceiver aTransceiver){
　　　　　　pool.add(aTransceiver);
　　　　}
　　　　public Transceiver get(int index){
　　　　　　pool.get(index);
　　　　}
　　}

10、 拆分过大的类。
 
　　如果一个类有太多的方法（超过50个），那么它可能要做的工作太多，我们应该试着将它的功能拆分到不同的类中，类似于规则四。

11、 作用截然不同的对象应该拆分。
 
　　在构建的过程中，你有时会遇到这样的问题：对同样的数据，有不同的视图。某些属性描述的是数据结构怎样生成，而某些属性描述的是数据结构本身。最好将这两个视图拆分到不同的类中，从类名上就可以区分出不同视图的作用。类的域、方法也应该有同样的考虑！

12、 尽量减少对参数的隐含传递。
 
　　两个方法处理类内部同一个数据（域），并不意味着它们就是对该数据（域）做处理。许多时候，该数据（域）应该作为方法的参输入数，而不是直接存取，在工具类的设计中尤其应该注意。例如：
　　public class Test{
　　　　private List pool = new Vector();
　　　　public void testAdd(String str){
　　　　　　pool.add(str);
　　　　}
　　　　public Object testGet(int index){
　　　　　　pool.get(index);
　　　　}
　　}

　　两个方法都对List对象pool做了操作，但是，实际上，我们可能只是想对List接口的不同实现Vector、ArrayList等做存取测试。所以，代码应该这样写：
　　public class Test{
　　　　private List pool = new Vector();
　　　　public void testAdd(List pool, String str){
　　　　　　pool.add(str);
　　　　}
　　　　public Object testGet(List pool, int index){
　　　　　　pool.get(index);
　　　　}
　　}

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛

• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！

• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师

收集的JSF中文教程，拿出来给大家分享。

• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师

摘要

2002年9月，在Java Specification Request（JSR）127上发布了JavaServer Faces规范的早期访问（early access，EA）草案。JavaServer Faces具有定义良好的请求处理生命周期和丰富的组件层次结构，将会深远地影响到J2EE（Java 2 Platform, Enterprise Edition）应用程序的开发。本系列文章篇分为两部分，在第 1 部分中，David Geary 将介绍 JavaServer Faces并初步探讨它的基本概念。（2002年11月29日)

正文

最近，在使用Struts、Enterprise JavaBeans (EJB)、servlets, JavaServer Pages (JSP)和JSP标准标签库（JSP Standard Tag Library，JSTL）开发一个复杂的Web应用程序时，我有幸参与培训和指导了一群 Java的开发新手。结果，项目成功了，且在