JSP內(nèi)建對象- -                                      

① out - javax.servlet.jsp.jspWriter
   out對象用于把結(jié)果輸出到網(wǎng)頁上。

方法：
1. void clear() ;
   清除輸出緩沖區(qū)的內(nèi)容，但是不輸出到客戶端。

2. void clearBuffer() ;
   清除輸出緩沖區(qū)的內(nèi)容，并輸出到客戶端。

3. void close() ;
   關(guān)閉輸出流，清除所有內(nèi)容。

4. void flush() ;
   輸出緩沖區(qū)里面的數(shù)據(jù)。

5. int getBufferSize() ;
   獲取以kb為單位的目前緩沖區(qū)大小。

6. int getRemaining() ;
   獲取以kb為單位的緩沖區(qū)中未被占用的空間大小。

7. boolean isAutoFlush() ;
   是否自動刷新緩沖區(qū)。

8. void newLine() ;
   輸出一個換行字符。

9. void print( boolean b ) ;
   void print( char c ) ;
   void print( char[] s ) ;
   void print( double d ) ;
   void print( float f ) ;
   void print( int i ) ;
   void print( long l ) ;
   void print( Object obj ) ;
   void print( String s ) ;
   將指定類型的數(shù)據(jù)輸出到Http流，不換行。

10. void println( boolean b ) ;
    void println( char c ) ;
    void println( char[] s ) ;
    void println( double d ) ;
    void println( float f ) ;
    void println( int i ) ;
    void println( long l ) ;
    void println( Object obj ) ;
    void println( String s ) ;
    將指定類型的數(shù)據(jù)輸出到Http流，并輸出一個換行符。
   
11. Appendable append( char c ) ;
    Appendable append( CharSequence cxq, int start, int end ) ;
    Appendable append( CharSequence cxq ) ;
    將一個字符或者實現(xiàn)了CharSequence接口的對象添加到輸出流的后面。

成員：
int DEFAULT_BUFFER = 0    - 缺省緩沖區(qū)大小
int NO_BUFFER = -1        - writer是否處于緩沖輸出狀態(tài)
int UNBOUNDED_BUFFER = -2 - 是否限制緩沖區(qū)大小

② request - javax.servlet.http.HttpServletRequest
   request對象包含所有請求的信息，如請求的來源、標(biāo)頭、cookies和請求相關(guān)的參數(shù)值等。

方法：
1. Object getAttribute( String name ) ;
   返回由name指定的屬性值，該屬性不存在時返回null。

2. Enumeration getAttributeNames() ;
   返回request對象的所有屬性名稱的集合。

3. String getAuthType() ;
   返回用來保護(hù)servlet的認(rèn)證方法的名稱，未受保護(hù)時返回null。

4. String getCharacterEncoding() ;
   返回請求中的字符編碼方法，可以在response對象中設(shè)置。

5. int getContentLength() ;
   返回請求的BODY的長度，不能確定長度時返回-1。可以在response中設(shè)置。

6. String getContentType() ;
   返回在response中定義的內(nèi)容類型。

7. String getContentPath() ;
   返回請求的路徑。

8. Cookie[] getCookies() ;
   返回客戶端所有的Cookie的數(shù)組。

9. Enumeration getHeaderNames() ;
   返回所有HTTP頭的名稱的集合。

10. Enumeration getHeaders( String name ) ;
    返回指定HTTP頭的所有值的集合。

11. String getHeader( String name ) ;
    返回指定名稱的HTTP頭的信息。

12. long getDateHeader( String name ) ;
    返回指定名稱的Data類型的HTTP頭的信息。

13. int getIntHeader( String name ) ;
    返回指定名稱的Int類型的HTTP頭的信息。

14. ServletInputStream getInputStream() ;
    返回請求的輸入流。

15. Locale getLocale() ;
    返回當(dāng)前頁的Locale對象，可以在response中設(shè)定。

16. Enumeration getLocales() ;
    返回請求中所有的Locale對象的集合。

17. String getLocalName() ;
    獲取響應(yīng)請求的服務(wù)器端主機(jī)名。

18. String getLocalAddr() ;
    獲取響應(yīng)請求的服務(wù)器端地址。

19. int getLocalPort() ;
    獲取響應(yīng)請求的服務(wù)器端端口

20. String getMethod() ;
    獲取客戶端向服務(wù)器端發(fā)送請求的方法(GET、POST)。

21. String getParameter( String name ) ;
    獲取客戶端發(fā)送給服務(wù)器端的參數(shù)值。

22. Map getParameterMap() ;
    該方法返回包含請求中所有參數(shù)的一個Map對象。

23. Enumeration getParameterNames() ;
    返回請求中所有參數(shù)的集合。

24. String[] getParameterValues( String name ) ;
    獲得請求中指定參數(shù)的所有值。

25. String getQueryString() ;
    返回get方法傳遞的參數(shù)字符串，該方法不分解出單獨的參數(shù)。

26. String getPathInfo() ;
    取出請求中處于ServletPath和QueryString之間的額外信息。

27. String getPathTranslated() ;
    返回用getPathInfo()方法取得的路徑信息的實際路徑。

28. String getProtocol() ;
    返回請求使用的協(xié)議?？梢允荋TTP1.1或者HTTP1.0。

29. BufferedReader getReader() ;
    返回請求的輸入流對應(yīng)的Reader對象，該方法和getInputStream()方法在一個頁面中只能調(diào)用一個。

30. String getRemoteAddr() ;
    獲取發(fā)出請求的客戶端IP地址。

31. String getRemoteHost() ;
    獲取發(fā)出請求的客戶端主機(jī)名

32. String getRemoteUser() ;
    返回經(jīng)過客戶端驗證的用戶名，未經(jīng)驗證返回null。

33. int getRemotePort() ;
    返回發(fā)出請求的客戶端主機(jī)端口。

34. String getRealPath( String path ) ;
    返回給定虛擬路徑的物理路徑。

35. RequestDispatcher getRequestDispatcher( String path ) ;
    按給定的路徑生成資源轉(zhuǎn)向處理適配器對象。

36. String getRequestedSessionId() ;
    返回請求的session的標(biāo)識。

37. String RequestURI() ;
    返回發(fā)出請求的客戶端地址，但是不包括請求的參數(shù)字符串。

38. StringBuffer getRequestURI() ;
    返回響應(yīng)請求的服務(wù)器端地址

39. String getScheme() ;
    獲取協(xié)議名稱，缺省值為HTTP協(xié)議。

40. String getServerName() ;
    返回響應(yīng)請求的服務(wù)器名稱。

41. String getServletPath() ;
    獲取客戶端所請求的腳本文件的文件路徑。

42. int getServerPort() ;
    獲取響應(yīng)請求的服務(wù)器端主機(jī)端口號。

43. void removeAttribute( String name ) ;
    在屬性列表中刪除指定名稱的屬性。

44. void setAttribute( String name, Object value ) ;
    在屬性列表中添加/刪除指定的屬性。

45. void setCharacterEncoding( String name ) ;
    設(shè)置請求的字符編碼格式。

46. HttpSession getSession() ;
    HttpSession getSession( boolean create ) ;
    獲取session，如果create為true，在無session的情況下創(chuàng)建一個。
   
47. boolean isRequestedSessionIdFromCookie() ;
    檢查請求的會話ID是否為通過Cookie傳入。

48. boolean isRequestedSessionIdFromURL() ;
    檢查請求的會話ID是否為通過URL傳入。

49. boolean isRequestedSessionIdValid() ;
    檢查請求的會話ID是否仍然有效。

50. boolean isSecure() ;
    檢查請求是否使用安全鏈接，如果HTTPS等。

51. boolean isUserInRole( String role ) ;
    檢查已經(jīng)通過驗證的用戶是否在是role所指定的角色。

52. Principal getUserPrincipal() ;
    返回包含用戶登陸名的一個java.security.Principal對象。

成員：
String BASIC_AUTH = "BASIC"             -
String CLIENT_CERT_AUTH = "CLIENT_CERT" -
String DIGEST_AUTH = "DIGEST"           -
String FORM_AUTH = "FORM"               -

③ response - javax.servlet.http.HttpServletResponse
   response對象主要將JSP容器處理后的結(jié)果傳回到客戶端。

方法：
1. void addCookie( Cookie cookie ) ;
   添加一個Cookie對象，保存客戶端信息。

2. void addDateHeader( String name, long value ) ;
   添加一個日期類型的HTTP頭信息，覆蓋同名的HTTP頭信息。

3. void addHeader( String name, String value ) ;
   添加一個HTTP頭，覆蓋同名的舊HTTP頭。

4. void addIntHeader( String name, int value ) ;
   添加一個整型的HTTP頭，覆蓋同名的舊HTTP頭。

5. boolean containsHeader( String name ) ;
   判斷指定的HTTP頭是否存在。

6. String encodeRedirectURL( String url ) ;
   對sendRedirect()方法使用的URL進(jìn)行編碼。

7. String encodeURL( String url ) ;
   將URL予以編碼，回傳包含session ID的URL。
  
8. void flushBuffer() ;
   強制把當(dāng)前緩沖區(qū)的內(nèi)容發(fā)送到客戶端。

9. int getBufferSize() ;
   取得以kb為單位的緩沖區(qū)大小。

10. String getCharacterEncoding() ;
    獲取響應(yīng)的字符編碼格式。

11. String getContentType() ;
    獲取響應(yīng)的類型。

12. Locale getLocale() ;
    獲取響應(yīng)的Locale對象。

13. ServletOutputStream getOutputStream() ;
    返回客戶端的輸出流對象。

14. PrintWriter getWriter() ;
    獲取輸出流對應(yīng)的writer對象。

15. boolean isCommitted() ;
    判斷服務(wù)器端是否已經(jīng)將數(shù)據(jù)輸出到客戶端。

16. void reset() ;
    清空buffer中的所有內(nèi)容。

17. void resetBuffer() ;
    情況buffer中所有的內(nèi)容，但是保留HTTP頭和狀態(tài)信息。

18. void sendError( int xc, String msg ) ;
    void sendError( int xc ) ;
    發(fā)送錯誤，包括狀態(tài)碼和錯誤信息。

19. void sendRedirect( String locationg ) ;
    把響應(yīng)發(fā)送到另外一個位置進(jìn)行處理。

20. void setBufferSize( int size ) ;
    設(shè)置以kb為單位的緩沖區(qū)大小。

21. void setCharacterEncoding( String charset ) ;
    設(shè)置響應(yīng)使用的字符編碼格式。

22. void setContentLength( int length ) ;
    設(shè)置響應(yīng)的BODY長度。

23. void setContentType( String type ) ;
    設(shè)置響應(yīng)的類型。

24. void setDateHeader( String name, long value ) ;
    設(shè)置指定名稱的Data類型的HTTP頭的值。

25. void setHeader( String name, String value ) ;
    設(shè)置指定名稱的HTTP頭的值。

26. void setIntHeader( String name, int value ) ;
    設(shè)置指定名稱的int類型的HTTP頭的值。

27. void setStatus( int xc ) ;
    設(shè)置響應(yīng)狀態(tài)碼，新值會覆蓋當(dāng)前值。

成員(HTTP狀態(tài)碼)：
int SC_CONTINUE = 100                      int SC_SWITCHING_PROTOCOLS = 101
int SC_OK = 200                            int SC_NON_AUTHORITATIVE_INFORMATION = 203
int SC_ACCEPTED = 202                      int SC_CREATED = 201
int SC_NO_CONTENT = 204                    int SC_RESET_CONTENT = 205
int SC_PARTIAL_CONTENT = 206               int SC_MULTIPLE_CHOICES = 300
int SC_MOVED_PERMANENTLY = 301             int SC_MOVED_TEMPORARILY = 302
int SC_FOUND = 302                         int SC_SEE_OTHER = 303
int SC_NOT_MODIFIED = 304                  int SC_USE_PROXY = 305
int SC_TEMPORARY_REDIRECT = 307            int SC_BAD_REQUEST = 400
int SC_UNAUTHORIZED = 401                  int SC_PAYMENT_REQUIRED = 402
int SC_FORBIDDEN = 403                     int SC_NOT_FOUND = 404
int SC_METHOD_NOT_ALLOWED = 405            int SC_NOT_ACCEPTABLE = 406
int SC_PROXY_AUTHENTICATION_REQUIRED = 407 int SC_REQUEST_TIMEOUT = 408
int SC_CONFLICT = 409                      int SC_GONE = 410
int SC_LENGTH_REQUIRED = 411               int SC_PRECONDITION_FAILED = 412
int SC_REQUEST_ENTITY_TOO_LARGE = 413      int SC_REQUEST_URI_TOO_LONG = 414
int SC_UNSUPPORTED_MEDIA_TYPE = 415        int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416
int SC_EXPECTATION_FAILED = 417            int SC_INTERNAL_SERVER_ERROR = 500
int SC_NOT_IMPLEMENTED = 501               int SC_BAD_GATEWAY = 502
int SC_SERVICE_UNAVAILABLE = 503           int SC_GATEWAY_TIMEOUT = 504
int SC_HTTP_VERSION_NOT_SUPPORTED = 505

④ session - javax.servlet.http.HttpSession
   session對象表示目前個別用戶的會話狀態(tài)，用來識別每個用戶。

方法：
1. Object getAttribute( String name ) ;
   獲取與指定名字相關(guān)聯(lián)的session屬性值。

2. Enumeration getAttributeNames() ;
   取得session內(nèi)所有屬性的集合。

3. long getCreationTime() ;
   返回session的創(chuàng)建時間，最小單位千分之一秒。

4. String getId() ;
   取得session標(biāo)識。

5. long getLastAccessedTime() ;
   返回與當(dāng)前session相關(guān)的客戶端最后一次訪問的時間，由1970-01-01算起，單位毫秒。

6. int getMaxInactiveInterval( int interval ) ;
   返回總時間，以秒為單位，表示session的有效時間(session不活動時間)。-1為永不過期。

7. ServletContext getServletContext() ;
   返回一個該JSP頁面對應(yīng)的ServletContext對象實例。

8. HttpSessionContext getSessionContext() ;
  

9. Object getValue( String name ) ;
   取得指定名稱的session變量值，不推薦使用。

10. String[] getValueNames() ;
    取得所有session變量的名稱的集合，不推薦使用。

11. void invalidate() ;
    銷毀這個session對象。

12. boolean isNew() ;
    判斷一個session是否由服務(wù)器產(chǎn)生，但是客戶端并沒有使用。

13. void pubValue( String name, Object value ) ;
    添加一個session變量，不推薦使用。

14. void removeValue( String name ) ;
    移除一個session變量的值，不推薦使用。

15. void setAttribute( String name, String value ) ;
    設(shè)置指定名稱的session屬性值。

16. void setMaxInactiveInterval( int interval ) ;
    設(shè)置session的有效期。

17. void removeAttribute( String name ) ;
    移除指定名稱的session屬性。

⑤ pageContext - javax.servlet.jsp.PageContext
   pageContext對象存儲本JSP頁面相關(guān)信息，如屬性、內(nèi)建對象等。

方法：
1. void setAttribute( String name, Object value, int scope ) ;
   void setAttribute( String name, Object value ) ;
   在指定的共享范圍內(nèi)設(shè)置屬性。

2. Object getAttribute( String name, int scope ) ;
   Object getAttribute( String name ) ;
   取得指定共享范圍內(nèi)以name為名字的屬性值。

3. Object findAttribute( String name ) ;
   按頁面、請求、會話和應(yīng)用程序共享范圍搜索已命名的屬性。

4. void removeAttribute( String name, int scope ) ;
   void removeAttribute( String name ) ;
   移除指定名稱和共享范圍的屬性。

5. void forward( String url ) ;
   將頁面導(dǎo)航到指定的URL。

6. Enumeration getAttributeNamesScope( int scope ) ;
   取得指定共享范圍內(nèi)的所有屬性名稱的集合。

7. int getAttributeScope( String name ) ;
   取得指定屬性的共享范圍。

8. ErrorData getErrorDate() ;
   取得頁面的errorData對象。

9. Exception getException() ;
   取得頁面的exception對象。

10. ExpressionEvaluator getExpressionEvaluator() ;
    取得頁面的expressionEvaluator對象。

11. JspWriter getOut() ;
    取得頁面的out對象。

12. Object getPage() ;
    取得頁面的page對象。

13. ServletRequest getRequest() ;
    取得頁面的request對象。

14. ServletResponse getResponse() ;
    取得頁面的response對象。

15. ServletConfig getConfig() ;
    取得頁面的config對象。

16. ServletContext getServletContext() ;
    取得頁面的servletContext對象。

17. HttpSession getSession() ;
    取得頁面的session對象。

18. VariableResolver getVariableResolver() ;
    取得頁面的variableResolver對象。

19. void include( String url, boolean flush ) ;
    void include( String url ) ;
    包含其他的資源，并指定是否自動刷新。

20. void release() ;
    重置pageContext內(nèi)部狀態(tài)，釋放所有內(nèi)部引用。

21. void initialize( Servlet servlet, ServletRequest request, ServletResponse response,
                     String errorPageURL, boolean needSession, int bufferSize, boolean autoFlush ) ;
    初始化未經(jīng)初始化的pageContext對象。

22. BodyContext pushBody() ;
    BodyContext pushBody( Writer writer ) ;
    保存當(dāng)前的out對象，并更新pageContext中page范圍內(nèi)的out對象。

23. JspWrite popBody() ;
    取出由pushBody()方法保存的out對象。

24. void handlePageException( Exception e ) ;
    void handlePageException( Thrwoable t ) ;
   

成員：
int PAGE_SCOPE = 1        - 頁面共享范圍
int REQUEST_SCOPE = 2     - 請求共享范圍
int SESSION_SCOPE = 3     - 會話共享范圍
int APPLICATION_SCOPE = 4 - 應(yīng)用程序共享范圍
String PAGE = "javax.servlet.jsp.jspPage"
String PAGECONTEXT = "javax.servlet.jsp.jspPageContext"
String REQUEST = "javax.servlet.jsp.jspRequest"
String RESPONSE = "javax.servlet.jsp.jspResponse"
String CONFIG = "javax.servlet.jsp.jspConfig"
String SESSION = "javax.servlet.jsp.jspSession"
String OUT = "javax.servlet.jsp.jspOut"
String APPLICATION = "javax.servlet.jsp.jspApplication"
String EXCEPTION = "javax.servlet.jsp.jspException"

⑥ application - javax.servlet.ServletContext
   application主要功用在于取得或更改Servlet的設(shè)定。

方法：
1. Object getAttribute( String name ) ;
   返回由name指定的application屬性。

2. Enumeration getAttributes() ;
   返回所有的application屬性。

3. ServletContext getContext( String uripath ) ;
   取得當(dāng)前應(yīng)用的ServletContext對象。

4. String getInitParameter( String name ) ;
   返回由name指定的application屬性的初始值。

5. Enumeration getInitParameters() ;
   返回所有的application屬性的初始值的集合。

6. int getMajorVersion() ;
   返回servlet容器支持的Servlet API的版本號。

7. String getMimeType( String file ) ;
   返回指定文件的類型，未知類型返回null。一般為"text/html"和"image/gif"。

8. int getMinorVersion() ;
   返回servlet容器支持的Servlet API的副版本號。

9. String getRealPath( String path ) ;
   返回給定虛擬路徑所對應(yīng)物理路徑。

10. RequestDispatcher getNamedDispatcher( String name ) ;
    為指定名字的Servlet對象返回一個RequestDispatcher對象的實例。

11. RequestDispatcher getRequestDispatcher( String path ) ;
    返回一個RequestDispatcher對象的實例。

12. URL getResource( String path ) ;
    返回指定的資源路徑對應(yīng)的一個URL對象實例，參數(shù)要以"/"開頭。

13. InputStream getResourceAsStream( String path ) ;
    返回一個由path指定位置的資源的InputStream對象實例。

14. Set getResourcePaths( String path ) ;
    返回存儲在web-app中所有資源路徑的集合。

15. String getServerInfo() ;
    取得應(yīng)用服務(wù)器版本信息。

16. Servlet getServlet( String name ) ;
    在ServletContext中檢索指定名稱的servlet。

17. Enumeration getServlets() ;
    返回ServletContext中所有servlet的集合。

18. String getServletContextName() ;
    返回本web應(yīng)用的名稱。

19. Enumeration getServletContextNames() ;
    返回ServletContext中所有servlet的名稱集合。

20. void log( Exception ex, String msg ) ;
    void log( String msg, Throwable t ) ;
    void log( String msg ) ;
    把指定的信息寫入servlet log文件。

21. void removeAttribute( String name ) ;
    移除指定名稱的application屬性。

22. void setAttribute( String name, Object value ) ;
    設(shè)定指定的application屬性的值。

⑦ config - javax.servlet.ServletConfig
   config對象用來存放Servlet初始的數(shù)據(jù)結(jié)構(gòu)。

方法：
1. String getInitParameter( String name ) ;
   返回名稱為name的促使參數(shù)的值。

2. Enumeration getInitParameters() ;
   返回這個JSP所有的促使參數(shù)的名稱集合。

3. ServletContext getContext() ;
   返回執(zhí)行者的servlet上下文。

4. String getServletName() ;
   返回servlet的名稱。

⑧ exception - java.lang.Throwable
   錯誤對象，只有在JSP頁面的page指令中指定isErrorPage="true"后，才可以在本頁面使用exception對象。

方法：
1. Throwable fillInStackTrace() ;
   將當(dāng)前stack信息記錄到exception對象中。

2. String getLocalizedMessage() ;
   取得本地語系的錯誤提示信息。

3. String getMessage()
   取得錯誤提示信息。

4. StackTrackElement[] getStackTrace() ;
   返回對象中記錄的call stack track信息。

5. Throwable initCause( Throwable cause ) ;
   將另外一個異常對象嵌套進(jìn)當(dāng)前異常對象中。
  
6. Throwable getCause() ;
   取出嵌套在當(dāng)前異常對象中的異常。

7. void printStackTrace() ;
   void printStackTrace( printStream s ) ;
   void printStackTrace( printWriter s ) ;
   打印出Throwable及其call stack trace信息。

8. void setStackTrace( StackTraceElement[] stackTrace )
   設(shè)置對象的call stack trace信息。

⑨ page - javax.servlet.jsp.HttpJspPage
   page對象代表JSP對象本身，或者說代表編譯后的servlet對象，
   可以用( (javax.servlet.jsp.HttpJspPage)page )來取用它的方法和屬性。

為什么GenericServlet在init(ServletConfig config)基礎(chǔ)上增加了一個init()方法？

init()方法被GenericServlet.init(ServletConfig config)方法調(diào)用。
init()方法方便了開發(fā)人員定制Servlet的初始化，而無須去維護(hù)ServletConfig對象的存儲工作。
重寫GenericServlet.init(ServletConfig config)必須要顯示的調(diào)用super.init(config)方法。

ServletContext.getContect(java.lang.String uripath)的作用是什么？

返回同一Server中指定的path對應(yīng)的ServletContext對象,通過該對象可以實現(xiàn)與Server中的其他Context打交道。
uripath必須是以"/"開始（該路徑的含義是相對于整個Servlet文檔的根路徑，而不是當(dāng)前ServletContext的根路徑）。

Servlet生命周期是什么？

一般的Servlet(GenericServlet,即與協(xié)議無關(guān)的Servlet)的生命周期：init() --> GenericServlet.service(ServletRequest req, ServletResponse res) --> destroy.
HttpServlet的生命周期: init() --> GenericServlet.service(ServletRequest req, ServletResponse res)---> service(HttpServletRequest req, HttpServletResponse resp) --> doXXXX()-->destroy.

有沒有必要重寫GenericServlet.service()方法？

對于HttpServlet來說沒有必要。只需要重寫它的doXXXX()方法就可以了。HttpServlet中service()方法會自動的根據(jù)用戶請求類型把請求轉(zhuǎn)發(fā)給相應(yīng)的doXXXX()方法（例如doGet()方法）。

ServletRequest.getReader()和ServletRequest.getInputStream()如何使用？

注意兩個方法不能同時使用。

ServletRequest.getRealPath(String path)方法已經(jīng)不推薦使用。

請使用ServletContext.getRealPath(String path)方法。

ServletResponse缺省的字符集(charset)是什么?

ServletResponse缺省的字符集(charset)是ISO-8859-1,可以通過setContentType(java.lang.String)方法改變新的字符集。
例如：setContentType("text/html; charset=Shift_JIS").
關(guān)于字符集信息，可以瀏覽RFC 2045

HttpServletRequest.getRequestURI()和HttpServletRequest.getRequestURL()區(qū)別是什么?

request.getRequestURI() 返回值類似：/xuejava/requestdemo.jsp
request.getRequestURL() 返回值類似：http://localhost:8080/xuejava/requestdemo.jsp

HttpServletRequest.encodeURL()和HttpServletRequest.encodeRedirectURL(()區(qū)別是什么?為什么要有兩個不同的方法呢？

當(dāng)用URL-rewriting方式來管理Session的時候，需要用到以上的兩個方法。
兩個方法的不同點是：兩個方法確定是否需要包含session ID的邏輯不同。
在調(diào)用HttpServletResponse.sendRedirect前，應(yīng)該先調(diào)用encodeRedirectURL()方法，否則可能會丟失Sesssion信息。 ...

如何使你的Servlet或者JSP實現(xiàn)Single Thread Model?

對于Servlet實現(xiàn)javax.single.SingleThreadModel接口。
對于JSP,在Page Directive中寫如下的語句

JSP Tag 和 JSP XML-based Tag

...

如何把某一個JSP Page定義成為Error Page?為什么要這樣做？

實現(xiàn)方法：
為什么？ 因為需要獲取Exception 對象（缺省情況下，在JSP Page中是不能直接使用“隱含對象” exception的）。

JSP Page的執(zhí)行順序是如何的？

JSP Page的執(zhí)行順序如下：

JSP Page Translation. JSP Page --> Servlet source code.

JSP Page Compilation. Servlet source code --> Servlet class.

Load Class(First time or the server restarted)

Create instance(可能會很多次，如果JSP Page中聲明了)

Call jspInit method（一般的JSP Page都沒有重寫這個方法，重寫需要在聲明語句段中）。

Call _jspService method（類似與一般HttpServlet的doGet和doPost方法，但是可以同時用來處理Post和Getq請求）。

Call jspDestroy method（Server在卸載Servet的時候，例如當(dāng)Servlet很久沒有使用的情況）。

JSP Page中有哪些隱含對象(Implicity Object)?各自的類型和作用是什么？

request --

reponse --

session --

application --

out --

page --

pagecontext --

exception -- 只有在當(dāng)前JSP Page為Error Page的時候才有效。

config --

和 <@ include file="/foo/foo.jsp" %>的區(qū)別是什么？

<@ include ... -- Page translation time.

Servlets/JSP Container(Engine)有幾種運行方式？

Standalone

Tomcat standalone mode

In-process

Tomcat running inside Apache Web Server.

Out-of-process

Apache + mod_jk + Tomcat

Servlet,Servlet開發(fā)人員，Servlet API, Servlet Container的關(guān)系是什么？

Servlet,Servlet開發(fā)人員 --->Servlet API --> Servlet Container

The parts of an HTTP message

 
    Message part Description
    The initial line： Specifies the purpose of the request or response message
                       例子：GET /reports/sales/index.html HTTP/1.0 
    The header section:Specifies the meta-information, such as size, type, and encoding, 
                       about the content of the message
    A blank line: 
    An optional message body: The main content of the request or response message

下面是一個Response的例子：

 
    

    HTTP/1.0 200 OK
    Date: Tue, 01 Dec 2001 23:59:59 GMT
    Content-Type: text/html
    Content-Length: 52
    
    
    
    
Hello, John!
    
    

---

HTTP規(guī)范中定義了哪些方法？各自有什么用途？

GET

HEAD

POST
從 Http 1.1規(guī)范開始，增加了以下的方法:

PUT

OPTIONS

TRACE

DELETE

CONNECT

ServetRequest中為什么要定義:getContentType(),getContentLength()方法。

根據(jù)HTTP協(xié)議規(guī)范，Request 和 Response一樣也有這些必不可少的內(nèi)容！
所以需要首先了解 HTTP Message的概念和其內(nèi)容的格式，這些東西對于Request和Reponse是一樣的。
對于GET方式發(fā)送的請求，其內(nèi)容類型為：null
對于POST方式發(fā)送的請求，其內(nèi)容類型為：application/x-www-form-urlencoded

POST方式發(fā)送請求的內(nèi)容類似于：username=xuejava.

RequestDispatcher.forward()和HttpServletResponse.sendRedirect()的區(qū)別是什么？

RequestDispatcher.forward()是在服務(wù)器端運行；HttpServletResponse.sendRedirect()是通過向客戶瀏覽器發(fā)送命令來完成。
所以RequestDispatcher.forward()對于瀏覽器來說是“透明的”；而HttpServletResponse.sendRedirect()則不是。
另外，還要注意RequestDispatcher.forward()在調(diào)用的時候Response不能已經(jīng)Commit了（Response.isCommitted()）。

ServletContext.getRequestDispatcher(String url)和ServletRequest.getRequestDispatcher(String url)的區(qū)別是什么？為什么？

ServletContext.getRequestDispatcher(String url)中的url只能使用絕對路徑；而ServletRequest.getRequestDispatcher(String url)中的url可以使用相對路徑。
因為ServletRequest具有相對路徑的概念；而ServletContext對象無次概念。

如何把請求轉(zhuǎn)移到另外一個Web App中的某個地址？

ServletContext.getRequestDispatcher(String url)和ServletRequest.getRequestDispatcher(String url)只能把請求轉(zhuǎn)移到同一個Web App中的地址。
如果需要把請求轉(zhuǎn)移到另外一個Web App中的某個地址，可以按下面的做法：
1. 獲得另外一個Web App的ServletConext對象(currentServletContext.getContext(uripath)).
2. 調(diào)用ServletContext.getRequestDispatcher(String url)方法。

全面理解String(JAVA復(fù)習(xí))- -

                                      

1.      首先String不屬于8種基本數(shù)據(jù)類型，String是一個對象。

因為對象的默認(rèn)值是null，所以String的默認(rèn)值也是null；

但它又是一種特殊的對象，有其它對象沒有的一些特性。

2.      new String()和new String(“”)都是申明一個新的空字符串，是空串不是null；

3.      String str=”kvill”；

String str=new String (“kvill”);的區(qū)別：

在這里，我們不談堆，也不談棧，只先簡單引入常量池這個簡單的概念。

常量池(constant pool)指的是在編譯期被確定，并被保存在已編譯的.class文件中的一些數(shù)據(jù)。它包括了關(guān)于類、方法、接口等中的常量，也包括字符串常量。

看例1：

        String s0=”kvill”;

        String s1=”kvill”;

        String s2=”kv” + “ill”;

        System.out.println( s0==s1 );

System.out.println( s0==s2 );

        結(jié)果為：

true

true

       首先，我們要知道Java會確保一個字符串常量只有一個拷貝。

因為例子中的s0和s1中的”kvill”都是字符串常量，它們在編譯期就被確定了，所以s0==s1為true；而”kv”和”ill”也都是字符串常量，當(dāng)一個字符串由多個字符串常量連接而成時，它自己肯定也是字符串常量，所以s2也同樣在編譯期就被解析為一個字符串常量，所以s2也是常量池中”kvill”的一個引用。

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

用new String() 創(chuàng)建的字符串不是常量，不能在編譯期就確定，所以new String() 創(chuàng)建的字符串不放入常量池中，它們有自己的地址空間。

看例2：

        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 );

        結(jié)果為：

false

false

false

       例2中s0還是常量池中”kvill”的應(yīng)用，s1因為無法在編譯期確定，所以是運行時創(chuàng)建的新對象”kvill”的引用，s2因為有后半部分new String(“ill”)所以也無法在編譯期確定，所以也是一個新創(chuàng)建對象”kvill”的應(yīng)用;明白了這些也就知道為何得出此結(jié)果了。

 

4.      String.intern()：

再補充介紹一點：存在于.class文件中的常量池，在運行期被JVM裝載，并且可以擴(kuò)充。String的intern()方法就是擴(kuò)充常量池的一個方法；當(dāng)一個String實例str調(diào)用intern()方法時，Java查找常量池中是否有相同Unicode的字符串常量，如果有，則返回其的引用，如果沒有，則在常量池中增加一個Unicode等于str的字符串并返回它的引用；看例3就清楚了

例3：

        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 );

        結(jié)果為：

false      

**********

false       //雖然執(zhí)行了s1.intern(),但它的返回值沒有賦給s1

true    //說明s1.intern()返回的是常量池中”kvill”的引用

true

      

       最后我再破除一個錯誤的理解：

有人說，“使用String.intern()方法則可以將一個String類的保存到一個全局String表中

如果具有相同值的Unicode字符串已經(jīng)在這個表中，那么該方法返回表中已有字符串的地址

如果在表中沒有相同值的字符串，則將自己的地址注冊到表中“

如果我把他說的這個全局的String表理解為常量池的話，他的最后一句話，“如果在表中沒有相同值的字符串，則將自己的地址注冊到表中”是錯的：

看例4：

        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() );

結(jié)果：

false

kvill  kvill

true

在這個類中我們沒有聲名一個”kvill”常量，所以常量池中一開始是沒有”kvill”的

當(dāng)我們調(diào)用s1.intern()后就在常量池中新添加了一個”kvill”常量，原來的不在常量池中的”kvill”仍然存在，也就不是“將自己的地址注冊到常量池中”了。

       s1==s1.intern()為false說明原來的“kvill”仍然存在；

       s2現(xiàn)在為常量池中“kvill”的地址，所以有s2==s1.intern()為true。

5.      關(guān)于equals()和==:

這個對于String簡單來說就是比較兩字符串的Unicode序列是否相當(dāng)，如果相等返回true;而==是比較兩字符串的地址是否相同，也就是是否是同一個字符串的引用。

6.      關(guān)于String是不可變的。

這一說又要說很多，大家只要知道String的實例一旦生成就不會再改變了，

比如說：String str=”kv”+”ill”+”  “+”ans”;

就是有4個字符串常量，首先”kv”和”ill”生成了”kvill”存在內(nèi)存中，然后”kvill”又和”  “ 生成 ”kvill  “存在內(nèi)存中，最后又和生成了”kvill  ans”;并把這個字符串的地址賦給了str,就是因為String的“不可變”產(chǎn)生了很多臨時變量，這也就是為什么建議用StringBuffer的原因了，因為StringBuffer是可改變的

Vector、ArrayList和List的異同[zz]

線性表，鏈表，哈希表是常用的數(shù)據(jù)結(jié)構(gòu)，在進(jìn)行Java開發(fā)時，JDK已經(jīng)為我們提供了一系列相應(yīng)的類來實現(xiàn)基本的數(shù)據(jù)結(jié)構(gòu)。這些類均在java.util包中。本文試圖通過簡單的描述，向讀者闡述各個類的作用以及如何正確使用這些類。 Collection ├List │├LinkedList │├ArrayList │└Vector │　└Stack └Set Map ├Hashtable ├HashMap └WeakHashMap Collection接口 　　Collection是最基本的集合接口，一個Collection代表一組Object，即Collection的元素（Elements）。一些Collection允許相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類，Java SDK提供的類都是繼承自Collection的“子接口”如List和Set。 　　所有實現(xiàn)Collection接口的類都必須提供兩個標(biāo)準(zhǔn)的構(gòu)造函數(shù)：無參數(shù)的構(gòu)造函數(shù)用于創(chuàng)建一個空的Collection，有一個Collection參數(shù)的構(gòu)造函數(shù)用于創(chuàng)建一個新的Collection，這個新的Collection與傳入的Collection有相同的元素。后一個構(gòu)造函數(shù)允許用戶復(fù)制一個Collection。 　　如何遍歷Collection中的每一個元素？不論Collection的實際類型如何，它都支持一個iterator()的方法，該方法返回一個迭代子，使用該迭代子即可逐一訪問Collection中每一個元素。典型的用法如下： 　　　　Iterator it = collection.iterator(); // 獲得一個迭代子 　　　　while(it.hasNext()) { 　　　　　　Object obj = it.next(); // 得到下一個元素 　　　　} 　　由Collection接口派生的兩個接口是List和Set。 List接口 　　List是有序的Collection，使用此接口能夠精確的控制每個元素插入的位置。用戶能夠使用索引（元素在List中的位置，類似于數(shù)組下標(biāo)）來訪問List中的元素，這類似于Java的數(shù)組。 和下面要提到的Set不同，List允許有相同的元素。 　　除了具有Collection接口必備的iterator()方法外，List還提供一個listIterator()方法，返回一個ListIterator接口，和標(biāo)準(zhǔn)的Iterator接口相比，ListIterator多了一些add()之類的方法，允許添加，刪除，設(shè)定元素，還能向前或向后遍歷。 　　實現(xiàn)List接口的常用類有LinkedList，ArrayList，Vector和Stack。 LinkedList類 　　LinkedList實現(xiàn)了List接口，允許null元素。此外LinkedList提供額外的get，remove，insert方法在LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧（stack），隊列（queue）或雙向隊列（deque）。 　　注意LinkedList沒有同步方法。如果多個線程同時訪問一個List，則必須自己實現(xiàn)訪問同步。一種解決方法是在創(chuàng)建List時構(gòu)造一個同步的List： 　　　　List list = Collections.synchronizedList(new LinkedList(...)); ArrayList類 　　ArrayList實現(xiàn)了可變大小的數(shù)組。它允許所有元素，包括null。ArrayList沒有同步。 size，isEmpty，get，set方法運行時間為常數(shù)。但是add方法開銷為分?jǐn)偟某?shù)，添加n個元素需要O(n)的時間。其他的方法運行時間為線性。 　　每個ArrayList實例都有一個容量（Capacity），即用于存儲元素的數(shù)組的大小。這個容量可隨著不斷添加新元素而自動增加，但是增長算法并沒有定義。當(dāng)需要插入大量元素時，在插入前可以調(diào)用ensureCapacity方法來增加ArrayList的容量以提高插入效率。 　　和LinkedList一樣，ArrayList也是非同步的（unsynchronized）。 Vector類 　　Vector非常類似ArrayList，但是Vector是同步的。由Vector創(chuàng)建的Iterator，雖然和ArrayList創(chuàng)建的Iterator是同一接口，但是，因為Vector是同步的，當(dāng)一個Iterator被創(chuàng)建而且正在被使用，另一個線程改變了Vector的狀態(tài)（例如，添加或刪除了一些元素），這時調(diào)用Iterator的方法時將拋出ConcurrentModificationException，因此必須捕獲該異常。 Stack 類 　　Stack繼承自Vector，實現(xiàn)一個后進(jìn)先出的堆棧。Stack提供5個額外的方法使得Vector得以被當(dāng)作堆棧使用?；镜膒ush和pop方法，還有peek方法得到棧頂?shù)脑兀琫mpty方法測試堆棧是否為空，search方法檢測一個元素在堆棧中的位置。Stack剛創(chuàng)建后是空棧。 Set接口 　　Set是一種不包含重復(fù)的元素的Collection，即任意的兩個元素e1和e2都有e1.equals(e2)=false，Set最多有一個null元素。 　　很明顯，Set的構(gòu)造函數(shù)有一個約束條件，傳入的Collection參數(shù)不能包含重復(fù)的元素。 　　請注意：必須小心操作可變對象（Mutable Object）。如果一個Set中的可變元素改變了自身狀態(tài)導(dǎo)致Object.equals(Object)=true將導(dǎo)致一些問題。 Map接口 　　請注意，Map沒有繼承Collection接口，Map提供key到value的映射。一個Map中不能包含相同的key，每個key只能映射一個value。Map接口提供3種集合的視圖，Map的內(nèi)容可以被當(dāng)作一組key集合，一組value集合，或者一組key-value映射。 Hashtable類 　　Hashtable繼承Map接口，實現(xiàn)一個key-value映射的哈希表。任何非空（non-null）的對象都可作為key或者value。 　　添加數(shù)據(jù)使用put(key, value)，取出數(shù)據(jù)使用get(key)，這兩個基本操作的時間開銷為常數(shù)。 Hashtable通過initial capacity和load factor兩個參數(shù)調(diào)整性能。通常缺省的load factor 0.75較好地實現(xiàn)了時間和空間的均衡。增大load factor可以節(jié)省空間但相應(yīng)的查找時間將增大，這會影響像get和put這樣的操作。 使用Hashtable的簡單示例如下，將1，2，3放到Hashtable中，他們的key分別是”one”，”two”，”three”： 　　　　Hashtable numbers = new Hashtable(); 　　　　numbers.put(“one”, new Integer(1)); 　　　　numbers.put(“two”, new Integer(2)); 　　　　numbers.put(“three”, new Integer(3)); 　　要取出一個數(shù)，比如2，用相應(yīng)的key： 　　　　Integer n = (Integer)numbers.get(“two”); 　　　　System.out.println(“two = ” + n); 　　由于作為key的對象將通過計算其散列函數(shù)來確定與之對應(yīng)的value的位置，因此任何作為key的對象都必須實現(xiàn)hashCode和equals方法。hashCode和equals方法繼承自根類Object，如果你用自定義的類當(dāng)作key的話，要相當(dāng)小心，按照散列函數(shù)的定義，如果兩個對象相同，即obj1.equals(obj2)=true，則它們的hashCode必須相同，但如果兩個對象不同，則它們的hashCode不一定不同，如果兩個不同對象的hashCode相同，這種現(xiàn)象稱為沖突，沖突會導(dǎo)致操作哈希表的時間開銷增大，所以盡量定義好的hashCode()方法，能加快哈希表的操作。 　　如果相同的對象有不同的hashCode，對哈希表的操作會出現(xiàn)意想不到的結(jié)果（期待的get方法返回null），要避免這種問題，只需要牢記一條：要同時復(fù)寫equals方法和hashCode方法，而不要只寫其中一個。 　　Hashtable是同步的。 HashMap類 　　HashMap和Hashtable類似，不同之處在于HashMap是非同步的，并且允許null，即null value和null key。，但是將HashMap視為Collection時（values()方法可返回Collection），其迭代子操作時間開銷和HashMap的容量成比例。因此，如果迭代操作的性能相當(dāng)重要的話，不要將HashMap的初始化容量設(shè)得過高，或者load factor過低。 WeakHashMap類 　　WeakHashMap是一種改進(jìn)的HashMap，它對key實行“弱引用”，如果一個key不再被外部所引用，那么該key可以被GC回收。 總結(jié) 　　如果涉及到堆棧，隊列等操作，應(yīng)該考慮用List，對于需要快速插入，刪除元素，應(yīng)該使用LinkedList，如果需要快速隨機(jī)訪問元素，應(yīng)該使用ArrayList。 　　如果程序在單線程環(huán)境中，或者訪問僅僅在一個線程中進(jìn)行，考慮非同步的類，其效率較高，如果多個線程可能同時操作一個類，應(yīng)該使用同步的類。 　　要特別注意對哈希表的操作，作為key的對象要正確復(fù)寫equals和hashCode方法。 　　盡量返回接口而非實際的類型，如返回List而非ArrayList，這樣如果以后需要將ArrayList換成LinkedList時，客戶端代碼不用改變。這就是針對抽象編程。 [b]同步性 Vector是同步的。這個類中的一些方法保證了Vector中的對象是線程安全的。而ArrayList則是異步的，因此ArrayList中的對象并不是線程安全的。因為同步的要求會影響執(zhí)行的效率，所以如果你不需要線程安全的集合那么使用ArrayList是一個很好的選擇，這樣可以避免由于同步帶來的不必要的性能開銷。 數(shù)據(jù)增長 從內(nèi)部實現(xiàn)機(jī)制來講ArrayList和Vector都是使用數(shù)組(Array)來控制集合中的對象。當(dāng)你向這兩種類型中增加元素的時候，如果元素的數(shù)目超出了內(nèi)部數(shù)組目前的長度它們都需要擴(kuò)展內(nèi)部數(shù)組的長度，Vector缺省情況下自動增長原來一倍的數(shù)組長度，ArrayList是原來的50%,所以最后你獲得的這個集合所占的空間總是比你實際需要的要大。所以如果你要在集合中保存大量的數(shù)據(jù)那么使用Vector有一些優(yōu)勢，因為你可以通過設(shè)置集合的初始化大小來避免不必要的資源開銷。 使用模式 在ArrayList和Vector中，從一個指定的位置（通過索引）查找數(shù)據(jù)或是在集合的末尾增加、移除一個元素所花費的時間是一樣的，這個時間我們用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花費的時間會呈線形增長：O(n-i)，其中n代表集合中元素的個數(shù)，i代表元素增加或移除元素的索引位置。為什么會這樣呢？以為在進(jìn)行上述操作的時候集合中第i和第i個元素之后的所有元素都要執(zhí)行位移的操作。這一切意味著什么呢？ 這意味著，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好選擇其他的集合操作類。比如，LinkList集合類在增加或移除集合中任何位置的元素所花費的時間都是一樣的—O(1)，但它在索引一個元素的使用缺比較慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因為你可以簡單的使用索引來代替創(chuàng)建iterator對象的操作。LinkList也會為每個插入的元素創(chuàng)建對象，所有你要明白它也會帶來額外的開銷。 最后，在《Practical Java》一書中Peter Haggar建議使用一個簡單的數(shù)組（Array）來代替Vector或ArrayList。尤其是對于執(zhí)行效率要求高的程序更應(yīng)如此。因為使用數(shù)組(Array)避免了同步、額外的方法調(diào)用和不必要的重新分配空間的操作。

ArrayList是List接口的一個可變長數(shù)組實現(xiàn)。實現(xiàn)了所有List接口的操作，并允許存儲null值。除了沒有進(jìn)行同步，ArrayList基本等同于Vector。在Vector中幾乎對所有的方法都進(jìn)行了同步，但ArrayList僅對writeObject和readObject進(jìn)行了同步，其它比如add(Object)、remove(int)等都沒有同步。

1.存儲
ArrayList使用一個Object的數(shù)組存儲元素。
private transient Object elementData[];
ArrayList實現(xiàn)了java.io.Serializable接口，這兒的transient標(biāo)示這個屬性不需要自動序列化。下面會在writeObject()方法中詳細(xì)講解為什么要這樣作。

2.add和remove


    public boolean add(Object o) { 
    ensureCapacity(size + 1);  // Increments modCount!! 
    elementData[size++] = o; 
    return true; 
    } 

注意這兒的ensureCapacity()方法，它的作用是保證elementData數(shù)組的長度可以容納一個新元素。在“自動變長機(jī)制”中將詳細(xì)講解。

    public Object remove(int index) { 
    RangeCheck(index); 
    modCount++; 
    Object oldValue = elementData[index]; 
    int numMoved = size - index - 1; 
    if (numMoved > 0) 
        System.arraycopy(elementData, index+1, elementData, index, 
                 numMoved); 
    elementData[--size] = null; // Let gc do its work 
    return oldValue; 
    } 

RangeCheck()的作用是進(jìn)行邊界檢查。由于ArrayList采用一個對象數(shù)組存儲元素，所以在刪除一個元素時需要把后面的元素前移。刪除一個元素時只是把該元素在elementData數(shù)組中的引用置為null，具體的對象的銷毀由垃圾收集器負(fù)責(zé)。
modCount的作用將在下面的“iterator()中的同步”中說明。
注：在前移時使用了System提供的一個實用方法：arraycopy()，在本例中可以看出System.arraycopy()方法可以對同一個數(shù)組進(jìn)行操作，這個方法是一個native方法，如果對同一個數(shù)組進(jìn)行操作時，會首先把從源部分拷貝到一個臨時數(shù)組，在把臨時數(shù)組的元素拷貝到目標(biāo)位置。

3.自動變長機(jī)制
在實例化一個ArrayList時，你可以指定一個初始容量。這個容量就是elementData數(shù)組的初始長度。如果你使用：

    ArrayList list = new ArrayList(); 

則使用缺省的容量：10。

    public ArrayList() { 
    this(10); 
    } 

ArrayList提供了四種add()方法，

public boolean add(Object o)

public void add(int index, Object element)

public boolean addAll(Collection c)

public boolean addAll(int index, Collection c)

在每一種add()方法中，都首先調(diào)用了一個ensureCapacity(int miniCapacity)方法，這個方法保證elementData數(shù)組的長度不小于miniCapacity。ArrayList的自動變長機(jī)制就是在這個方法中實現(xiàn)的。

    public void ensureCapacity(int minCapacity) { 
    modCount++; 
    int oldCapacity = elementData.length; 
    if (minCapacity > oldCapacity) { 
        Object oldData[] = elementData; 
        int newCapacity = (oldCapacity * 3)/2 + 1; 
            if (newCapacity < minCapacity) 
        newCapacity = minCapacity; 
        elementData = new Object[newCapacity]; 
        System.arraycopy(oldData, 0, elementData, 0, size); 
    } 
    } 

從這個方法實現(xiàn)中可以看出ArrayList每次擴(kuò)容，都擴(kuò)大到原來大小的1.5倍。
每種add()方法的實現(xiàn)都大同小異，下面給出add(Object)方法的實現(xiàn)：

    public boolean add(Object o) { 
    ensureCapacity(size + 1);  // Increments modCount!! 
    elementData[size++] = o; 
    return true; 
    } 


4.iterator()中的同步
在父類AbstractList中定義了一個int型的屬性：modCount，記錄了ArrayList結(jié)構(gòu)性變化的次數(shù)。

    protected transient int modCount = 0; 

在ArrayList的所有涉及結(jié)構(gòu)變化的方法中都增加modCount的值，包括：add()、remove()、addAll()、removeRange()及clear()方法。這些方法每調(diào)用一次，modCount的值就加1。
注：add()及addAll()方法的modCount的值是在其中調(diào)用的ensureCapacity()方法中增加的。

AbstractList中的iterator()方法（ArrayList直接繼承了這個方法）使用了一個私有內(nèi)部成員類Itr，生成一個Itr對象（Iterator接口）返回：

    public Iterator iterator() { 
    return new Itr(); 
    } 

Itr實現(xiàn)了Iterator()接口，其中也定義了一個int型的屬性：expectedModCount，這個屬性在Itr類初始化時被賦予ArrayList對象的modCount屬性的值。

    int expectedModCount = modCount; 

注：內(nèi)部成員類Itr也是ArrayList類的一個成員，它可以訪問所有的AbstractList的屬性和方法。理解了這一點，Itr類的實現(xiàn)就容易理解了。

在Itr.hasNext()方法中：

    public boolean hasNext() { 
        return cursor != size(); 
    } 

調(diào)用了AbstractList的size()方法，比較當(dāng)前光標(biāo)位置是否越界。

在Itr.next()方法中，Itr也調(diào)用了定義在AbstractList中的get(int)方法，返回當(dāng)前光標(biāo)處的元素：

    public Object next() { 
        try { 
        Object next = get(cursor); 
        checkForComodification(); 
        lastRet = cursor++; 
        return next; 
        } catch(IndexOutOfBoundsException e) { 
        checkForComodification(); 
        throw new NoSuchElementException(); 
        } 
    } 

注意，在next()方法中調(diào)用了checkForComodification()方法，進(jìn)行對修改的同步檢查：

    final void checkForComodification() { 
        if (modCount != expectedModCount) 
        throw new ConcurrentModificationException(); 
    } 

現(xiàn)在對modCount和expectedModCount的作用應(yīng)該非常清楚了。在對一個集合對象進(jìn)行跌代操作的同時，并不限制對集合對象的元素進(jìn)行操作，這些操作包括一些可能引起跌代錯誤的add()或remove()等危險操作。在AbstractList中，使用了一個簡單的機(jī)制來規(guī)避這些風(fēng)險。這就是modCount和expectedModCount的作用所在。

5.序列化支持
ArrayList實現(xiàn)了java.io.Serializable接口，所以ArrayList對象可以序列化到持久存儲介質(zhì)中。ArrayList的主要屬性定義如下：

private static final long serialVersionUID = 8683452581122892189L;

private transient Object elementData[];

private int size;

可以看出serialVersionUID和size都將自動序列化到介質(zhì)中，但elementData數(shù)組對象卻定義為transient了。也就是說ArrayList中的所有這些元素都不會自動系列化到介質(zhì)中。為什么要這樣實現(xiàn)？因為elementData數(shù)組中存儲的“元素”其實僅是對這些元素的一個引用，并不是真正的對象，序列化一個對象的引用是毫無意義的，因為序列化是為了反序列化，當(dāng)你反序列化時，這些對象的引用已經(jīng)不可能指向原來的對象了。所以在這兒需要手工的對ArrayList的元素進(jìn)行序列化操作。這就是writeObject()的作用。

    private synchronized void writeObject(java.io.ObjectOutputStream s) 
        throws java.io.IOException{ 
    // Write out element count, and any hidden stuff 
    s.defaultWriteObject(); 
   // Write out array length 
    s.writeInt(elementData.length); 
    // Write out all elements in the proper order. 
    for (int i=0; i<size; i++) 
            s.writeObject(elementData[i]); 
    } 

這樣元素數(shù)組elementData中的所以元素對象就可以正確地序列化到存儲介質(zhì)了。
對應(yīng)的readObject()也按照writeObject()方法的順序從輸入流中讀?。?BR>
    private synchronized void readObject(java.io.ObjectInputStream s) 
        throws java.io.IOException, ClassNotFoundException { 
    // Read in size, and any hidden stuff 
    s.defaultReadObject(); 
    // Read in array length and allocate array 
    int arrayLength = s.readInt(); 
    elementData = new Object[arrayLength]; 
    // Read in all elements in the proper order. 
    for (int i=0; i<size; i++) 
            elementData[i] = s.readObject(); 
    } 

本章介紹Java的實用工具類庫java.util包。在這個包中，Java提供了一些實用的方法和數(shù)據(jù)結(jié)構(gòu)。例如，Java提供日期(Data)類、日歷(Calendar)類來產(chǎn)生和獲取日期及時間，提供隨機(jī)數(shù)(Random)類產(chǎn)生各種類型的隨機(jī)數(shù)，還提供了堆棧(Stack)、向量(Vector) 、位集合(Bitset)以及哈希表(Hashtable)等類來表示相應(yīng)的數(shù)據(jù)結(jié)構(gòu)。
　　圖1.1給出了java.util包的基本層次結(jié)構(gòu)圖。下面我們將具體介紹其中幾個重要的類。
　　　　　　　　　　　┌java.util.BitSet
　　　　　　　　　　　│java.util.Calendar
　　　　　　　　　　　│　　　　　　└java.util.GregorianCalendar
　　　　　　　　　　　│java.util.Date
　　　　　　　　　　　│java.util.Dictionary
　　　　　　　　　　　│　　　　　　└java.util.Hashtable
　　　　　　　　　　　│　　　　　　　　　　　　　└java.util.Properties
　　　　　　　　　　　│java.util.EventObject
　　　　　　　　　　　│java.util.ResourceBundle
　　　　　　　┌普通類┤　　　　　　├java.util.ListResourceBundle
　　　　　　　│　　　│　　　　　　└java.util.PropertyResourceBundle
　　　　　　　│　　　│java.util.Local
　　　　　　　│　　　│java.util.Observable
　　　　　　　│　　　│java.util.Random
　　　　　　　│　　　│java.util.StringTokenizer
　　　　　　　│　　　│java.util.Vector
　　　　　　　│　　　│　　　　　　└java.util.Stack
　　Java.util┤　　　└java.util.TimeZone
　　　　　　　│　　　　　　　　　　└java.util.SimpleTimeZone
　　　　　　　│　　　┌java.util.Enumeration
　　　　　　　├接　口┤java.util.EventListener
　　　　　　　│　　　└java.util.Observer
　　　　　　　│　　　┌java.util.EmptyStackException
　　　　　　　└異常類┤java.util.MissingResourceException
　　　　　　　　　　　│java.util.NoSuchElementException
　　　　　　　　　　　└java.util.TooManyListenersException
　　　　　　　圖1.1 java.util包的基本層次結(jié)構(gòu)


1.2 日期類Date

　　Java在日期類中封裝了有關(guān)日期和時間的信息，用戶可以通過調(diào)用相應(yīng)的方法來獲取系統(tǒng)時間或設(shè)置日期和時間。Date類中有很多方法在JDK1.0公布后已經(jīng)過時了，在8.3中我們將介紹JDK1.0中新加的用于替代Date的功能的其它類。
　　在日期類中共定義了六種構(gòu)造函數(shù)。
　　(1)public Date()
　　創(chuàng)建的日期類對象的日期時間被設(shè)置成創(chuàng)建時刻相對應(yīng)的日期時間。
　　例 Date today=new Date()；//today被設(shè)置成創(chuàng)建時刻相對應(yīng)的日期時間。
　　(2)public Date (long date)
　　long 型的參數(shù)date可以通過調(diào)用Date類中的static方法parse(String s)來獲得。
　　例 long l=Date.parse("Mon 6 Jan 1997 13:3:00");
　　　　Date day=new Date(l);
　　//day中時間為1997年 1月6號星期一，13:3:00。
　　(3)public Date(String s)
　　按字符串s產(chǎn)生一日期對象。s的格式與方法parse中字符串參數(shù)的模式相同。
　　例 Date day=new Date("Mon 6 Jan 1997 13:3:00");
　　//day 中時間為1997年1月6號星期一，13:3:00.
　　(4)public Date(int year,int month,int date)
　　(5)public Date(int year,int month,int date,int hrs,int min)
　　(6)public Date(int year,int month,int date,int hrs,int min,int sec)
　　按給定的參數(shù)創(chuàng)建一日期對象。
　　參數(shù)說明：
　　year的值為：需設(shè)定的年份-1900。例如需設(shè)定的年份是1997則year的值應(yīng)為97，即1997-1900的結(jié)果。所以Date中可設(shè)定的年份最小為1900；
　　month的值域為0～11，0代表1月，11表代表12月；
　　date的值域在1～31之間；
　　hrs的值域在0～23之間。從午夜到次日凌晨1點間hrs=0，從中午到下午1點間hrs=12；
　　min和sec的值域在0～59之間。
　　例 Date day=new Date(11,3,4);
　　//day中的時間為：04-Apr-11 12:00:00 AM
另外，還可以給出不正確的參數(shù)。
　　例　設(shè)定時間為1910年2月30日，它將被解釋成3月2日。
　　Date day=new Date(10,1,30,10,12,34);
　　System.out.println("Day's date is:"+day);
　　//打印結(jié)果為：Day's date is:Web Mar 02 10:13:34 GMT+08:00 1910
　　下面我們給出一些Date類中常用方法。
　　(1)public static long UTC(int year,int month,int date,int hrs. int min,int sec)
　　該方法將利用給定參數(shù)計算UTC值。UTC是一種計時體制，與GMT(格林威治時間)的計時體系略有差別。UTC計時體系是基于原子時鐘的，而GTMT計時體系是基于天文學(xué)觀測的。計算中使用的一般為GMT計時體系。
　　(2)public static long parse(String s)
　　該方法將字符串s轉(zhuǎn)換成一個long型的日期。在介紹構(gòu)造方法Date(long date)時曾使用過這個方法。
　　字符串s有一定的格式，一般為：
　　(星期 日 年 時間GMT+時區(qū))
　　若不注明時區(qū)，則為本地時區(qū)。
　　(3)public void setMonth(int month)
　　(4)public int getMonth()
　　這兩個方法分別為設(shè)定和獲取月份值。
　　獲取的月份的值域為0～11，0代表1月，11代表12月。
　　(5)public String toString()
　　(6)public String toLocalString()
　　(7)public String toGMTString()
　　將給定日期對象轉(zhuǎn)換成不同格式的字符串。它們對應(yīng)的具體的格式可參看例子8.1。
　　(8)public int getTimezoneOffset()
　　該方法用于獲取日期對象的時區(qū)偏移量。
　　例8.1中對上面介紹的Date類中的基本方法進(jìn)行了具體的應(yīng)用，并打印了相應(yīng)的結(jié)果。由于使用了一些過時的方法，所以編譯時會有警告信息。另外，由于本例中的時間表示與平臺有關(guān)，不同的JDK版本對此處理不完全相同，因此不同版本的JDK執(zhí)行本例的結(jié)果可能有細(xì)微差異。
　　例1.1 DateApp.java
　　import java.lang.System;
　　import java.util.Date;
　　public class DateApp{
　　　public static void main(String args[]){
　　　　Date today=new Date();
　　　　//today中的日期被設(shè)成創(chuàng)建時刻的日期和時間，假設(shè)創(chuàng)建時刻為1997年3月
　　　　//23日17時51分54秒。
　　　　System.out.println("Today's date is "+today);
　　　　//返回一般的時間表示法，本例中結(jié)果為
　　　　//Today's date is Fri May 23 17:51:54 1997
　　　　System.out.println("Today's date(Internet GMT)is:"
　　　　　+today.toGMTString());
　　　　//返回結(jié)果為GMT時間表示法，本例中結(jié)果為
　　　　//Today's date(Internet GMT)is: 23 May 1997 09:51:54:GMT
　　　　System.out.println("Today's date(Locale) is:"
　　　　　+today.toLocaleString());
　　　　//返回結(jié)果為本地習(xí)慣的時間表示法，結(jié)果為
　　　　//Today's date(Locale)is:05/23/97 17:51:54
　　　　System.out.println("Today's year is: "+today.getYear());
　　　　System.out.println("Today's month is: "+(today.getMonth()+1));
　　　　System.out.println("Today's date is: "+today.getDate());
　　　　//調(diào)用Date類中方法，獲取年月日的值。
　　　　//下面調(diào)用了不同的構(gòu)造方法來創(chuàng)建Date類的對象。
　　　　Date day1=new Date(100,1,23,10,12,34);
　　　　System.out.println("Day1's date is: "+day1);
　　　　Date day2=new Date("Sat 12 Aug 1996 13:3:00");
　　　　System.out.println("Day2's date is: "+day2);
　　　　long l= Date.parse("Sat 5 Aug 1996 13:3:00 GMT+0800");
　　　　Date day3= new Date(l);
　　　　System.out.println("Day3's date(GMT)is: "+day3.toGMTString());
　　　　System.out.println("Day3's date(Locale)is: "
　　　　　+day3.toLocaleString());
　　　　System.out.println("Day3's time zone offset is:"
　　　　　+day3.getTimezoneOffset());
　　　}
　　}

　　運行結(jié)果(JDK1.3版，與原文不同，原文是JDK1.0版)：
　　E:\java\tutorial\java01>java DateApp
　　Today's date is Thu Dec 27 17:58:16 CST 2001
　　Today's date(Internet GMT)is:27 Dec 2001 09:58:16 GMT
　　Today's date(Locale) is:2001-12-27 17:58:16
　　Today's year is: 101
　　Today's month is: 12
　　Today's date is: 27
　　Day1's date is: Wed Feb 23 10:12:34 CST 2000
　　Day2's date is: Fri Aug 12 13:03:00 CST 1996
　　Day3's date(GMT)is: 5 Aug 1996 05:03:00 GMT
　　Day3's date(Locale)is: 1996-8-5 13:03:00
　　Day3's time zone offset is:-480

　　E:\java\tutorial\java01>

1.3 日歷類Calendar

　　在早期的JDK版本中，日期(Date)類附有兩大功能：(1)允許用年、月、日、時、分、秒來解釋日期：(2)允許對表示日期的字符串進(jìn)行格式化和句法分析。在JDK1.1中提供了類Calendar來完成第一種功能，類DateFormat來完成第二項功能。dateFormat是java.text包中的一個類。與Date類有所不同的是，DateFormat類接受用各種語言和不同習(xí)慣表示的日期字符串。本節(jié)將介紹java.util包中的類Calendar及其它新增加的相關(guān)的類。
　　類Calendar是一個抽象類，它完成日期(Date)類和普通日期表示法(即用一組整型域如YEAR，MONTH，DAY，HOUR表示日期)之間的轉(zhuǎn)換。
　　由于所使用的規(guī)則不同，不同的日歷系統(tǒng)對同一個日期的解釋有所不同。在JDK1.1中提供了Calendar類一個子類GregorianCalendar??它實現(xiàn)了世界上普遍使用的公歷系統(tǒng)。當(dāng)然用戶也可以通過繼承Calendar類，并增加所需規(guī)則，以實現(xiàn)不同的日歷系統(tǒng)。
　　第GregorianCalendar繼承了Calendar類。本節(jié)將在介紹類GregorianCalendar的同時順帶介紹Calendar類中的相關(guān)方法。
　　類GregorianCalendar提供了七種構(gòu)造函數(shù)：
　　(1)public GregorianCalendar()
　　創(chuàng)建的對象中的相關(guān)值被設(shè)置成指定時區(qū)，缺省地點的當(dāng)前時間，即程序運行時所處的時區(qū)、地點的當(dāng)前時間。
　　(2)public GregorianCalendar(TimeZone zone)
　　創(chuàng)建的對象中的相關(guān)值被設(shè)置成指定時區(qū)zone，缺省地點的當(dāng)前時間。
　　(3)public GregorianCalendar(Locale aLocale)
　　創(chuàng)建的對象中的相關(guān)值被設(shè)置成缺省時區(qū)，指定地點aLocale的當(dāng)前時間。
　　(4)public GregorianCalendar(TimeZone zone,Local aLocale)
　　創(chuàng)建的對象中的相關(guān)值被設(shè)置成指定時區(qū)，指定地點的當(dāng)前時間。
　　上面使用到的類TimeZone的性質(zhì)如下：
　　TimeZone是java.util包中的一個類，其中封裝了有關(guān)時區(qū)的信息。每一個時區(qū)對應(yīng)一組ID。類TimeZone提供了一些方法完成時區(qū)與對應(yīng)ID兩者之間的轉(zhuǎn)換。
　　(Ⅰ)已知某個特定的ID，可以調(diào)用方法
　　public static synchronized TimeZone getTimeZone(String ID)
來獲取對應(yīng)的時區(qū)對象。
　　例 太平洋時區(qū)的ID為PST，用下面的方法可獲取對應(yīng)于太平洋時區(qū)的時區(qū)對象：
　　TimeZone tz=TimeZone.getTimeZone("PST");
　　調(diào)用方法getDefault()可以獲取主機(jī)所處時區(qū)的對象。
　　TimeZone tz=TimeZone.getDefault();
　　(Ⅱ)調(diào)用以下方法可以獲取時區(qū)的ID
　　■public static synchronized String[] getavailableIDs(int rawOffset)
　　根據(jù)給定時區(qū)偏移值獲取ID數(shù)組。同一時區(qū)的不同地區(qū)的ID可能不同，這是由于不同地區(qū)對是否實施夏時制意見不統(tǒng)一而造成的。
　　例String s[]=TimeZone.getAvailableIDs(-7*60*60*1000);
　　打印s，結(jié)果為s[0]=PNT，s[1]=MST
　　■public static synchronized String[] getAvailableIDs()
　　獲取提供的所有支持的ID。
　　■public String getID()
　　獲取特定時區(qū)對象的ID。
　　例 TimeZone tz=TimeZone.getDefault();
　　String s=tz.getID();
　　打印s，結(jié)果為s=CTT。
　　上面使用類的對象代表了一個特定的地理、政治或文化區(qū)域。Locale只是一種機(jī)制，它用來標(biāo)識一類對象，Local本身并不包含此類對象。
　　要獲取一個Locale的對象有兩種方法：
　　(Ⅰ)調(diào)用Locale類的構(gòu)造方法
　　Locale(String language,String country)
　　Locale(String language,String country,String variant)
　　參數(shù)說明：language??在ISO-639中定義的代碼，由兩個小寫字母組成。
　　　　　　　country??在ISO-3166中定義的代碼，由兩個大寫字母組成。
　　　　　　　variant??售貨商以及特定瀏覽器的代碼，例如使用WIN代表Windows。
　　(Ⅱ)調(diào)用Locale類中定義的常量
　　Local類提供了大量的常量供用戶創(chuàng)建Locale對象。
　　例 Locale.CHINA
　　　　為中國創(chuàng)建一個Locale的對象。
　　類TimeZone和類Locale中的其它方法，讀者可查閱API。
　　(5)public GregorianCalendar(int year,int month,int date)
　　(6)public GregorianCalendar(int year,int month,int date,int hour,int minute)
　　(7)public GregorianCalendar(int year,int month,int date,int hour,int minute,int second)
　　用給定的日期和時間創(chuàng)建一個GregorianCalendar的對象。
　　參數(shù)說明：
　　year-設(shè)定日歷對象的變量YEAR；month-設(shè)定日歷對象的變量MONTH；
　　date-設(shè)定日歷對象的變量DATE；hour-設(shè)定日歷對象的變量HOUR_OF_DAY；
　　minute-設(shè)定日歷對象的變量MINUTE；second-設(shè)定日歷對象的變量SECOND。
　　與Date類中不同的是year的值沒有1900這個下限，而且year的值代表實際的年份。month的含義與Date類相同，0代表1月，11代表12月。
　　例 GregorianCalendar cal=new GregorianCalendar(1991,2,4)
　　cal的日期為1991年3月4號。
　　除了與Date中類似的方法外，Calendar類還提供了有關(guān)方法對日歷進(jìn)行滾動計算和數(shù)學(xué)計算。計算規(guī)則由給定的日歷系統(tǒng)決定。進(jìn)行日期計算時，有時會遇到信息不足或信息不實等特殊情況。Calendar采取了相應(yīng)的方法解決這些問題。當(dāng)信息不足時將采用缺省設(shè)置，在GregorianCalendar類中缺省設(shè)置一般為YEAR=1970,MONTH=JANUARY,DATE=1。
　　當(dāng)信息不實時，Calendar將按下面的次序優(yōu)先選擇相應(yīng)的Calendar的變量組合，并將其它有沖突的信息丟棄。
　　MONTH+DAY_OF_MONTH
　　MONTH+WEEK_OF_MONTH+DAY_OF_WEEK
　　MONTH+DAY_OF_WEEK_OF_MONTH+DAY_OF_WEEK
　　DAY_OF+YEAR
　　DAY_OF_WEEK_WEEK_OF_YEAR
　　HOUR_OF_DAY

1.4 隨機(jī)數(shù)類Random

　　Java實用工具類庫中的類java.util.Random提供了產(chǎn)生各種類型隨機(jī)數(shù)的方法。它可以產(chǎn)生int、long、float、double以及Goussian等類型的隨機(jī)數(shù)。這也是它與java.lang.Math中的方法Random()最大的不同之處，后者只產(chǎn)生double型的隨機(jī)數(shù)。
　　類Random中的方法十分簡單，它只有兩個構(gòu)造方法和六個普通方法。
　　構(gòu)造方法：
　　(1)public Random()
　　(2)public Random(long seed)
　　Java產(chǎn)生隨機(jī)數(shù)需要有一個基值seed，在第一種方法中基值缺省，則將系統(tǒng)時間作為seed。
　　普通方法：
　　(1)public synonronized void setSeed(long seed)
　　該方法是設(shè)定基值seed。
　　(2)public int nextInt()
　　該方法是產(chǎn)生一個整型隨機(jī)數(shù)。
　　(3)public long nextLong()
　　該方法是產(chǎn)生一個long型隨機(jī)數(shù)。
　　(4)public float nextFloat()
　　該方法是產(chǎn)生一個Float型隨機(jī)數(shù)。
　　(5)public double nextDouble()
　　該方法是產(chǎn)生一個Double型隨機(jī)數(shù)。
　　(6)public synchronized double nextGoussian()
　　該方法是產(chǎn)生一個double型的Goussian隨機(jī)數(shù)。
　　例1.2 RandomApp.java。
　　//import java.lang.*;
　　import java.util.Random;

　　public class RandomApp{
　　　public static void main(String args[]){
　　　　Random ran1=new Random();
　　　　Random ran2=new Random(12345);
　　　　//創(chuàng)建了兩個類Random的對象。
　　　　System.out.println("The 1st set of random numbers:");
　　　　System.out.println("\t Integer:"+ran1.nextInt());
　　　　System.out.println("\t Long:"+ran1.nextLong());
　　　　System.out.println("\t Float:"+ran1.nextFloat());
　　　　System.out.println("\t Double:"+ran1.nextDouble());
　　　　System.out.println("\t Gaussian:"+ran1.nextGaussian());
　　　　//產(chǎn)生各種類型的隨機(jī)數(shù)
　　　　System.out.print("The 2nd set of random numbers:");
　　　　for(int i=0;i<5;i++){
　　　　　System.out.println(ran2.nextInt()+" ");
　　　　　if(i==2) System.out.println();
　　　　　//產(chǎn)生同種類型的不同的隨機(jī)數(shù)。
　　　　　System.out.println();//原文如此
　　　　}
　　　}
　　}

　　運行結(jié)果：
　　E:\java01>java RandomApp
　　The 1st set of random numbers:
　　　　Integer:-173899656
　　　　Long:8056223819738127077
　　　　Float:0.6293638
　　　　Double:0.7888394520265607
　　　　Gaussian:0.5015701094568733
　　The 2nd set of random numbers:1553932502
　　-2090749135
　　-287790814
　　-355989640
　　-716867186
　　E:\java01>

1.5 向量類Vector

　　Java.util.Vector提供了向量(Vector)類以實現(xiàn)類似動態(tài)數(shù)組的功能。在Java語言中。正如在一開始就提到過，是沒有指針概念的，但如果能正確靈活地使用指針又確實可以大大提高程序的質(zhì)量，比如在C、C++中所謂“動態(tài)數(shù)組”一般都由指針來實現(xiàn)。為了彌補這點缺陷，Java提供了豐富的類庫來方便編程者使用，Vector類便是其中之一。事實上，靈活使用數(shù)組也可完成向量類的功能，但向量類中提供的大量方法大大方便了用戶的使用。
　　創(chuàng)建了一個向量類的對象后，可以往其中隨意地插入不同的類的對象，既不需顧及類型也不需預(yù)先選定向量的容量，并可方便地進(jìn)行查找。對于預(yù)先不知或不愿預(yù)先定義數(shù)組大小，并需頻繁進(jìn)行查找、插入和刪除工作的情況，可以考慮使用向量類。
　　向量類提供了三種構(gòu)造方法：
　　public vector()
　　public vector(int initialcapacity,int capacityIncrement)
　　public vector(int initialcapacity)
　　使用第一種方法，系統(tǒng)會自動對向量對象進(jìn)行管理。若使用后兩種方法，則系統(tǒng)將根據(jù)參數(shù)initialcapacity設(shè)定向量對象的容量(即向量對象可存儲數(shù)據(jù)的大小)，當(dāng)真正存放的數(shù)據(jù)個數(shù)超過容量時，系統(tǒng)會擴(kuò)充向量對象的存儲容量。參數(shù)capacityIncrement給定了每次擴(kuò)充的擴(kuò)充值。當(dāng)capacityIncrement為0時，則每次擴(kuò)充一倍。利用這個功能可以優(yōu)化存儲。
　　在Vector類中提供了各種方法方便用戶使用：
　　■插入功能
　　(1)public final synchronized void addElement(Object obj)
　　將obj插入向量的尾部。obj可以是任何類的對象。對同一個向量對象，可在其中插入不同類的對象。但插入的應(yīng)是對象而不是數(shù)值，所以插入數(shù)值時要注意將數(shù)值轉(zhuǎn)換成相應(yīng)的對象。
　　例 要插入一個整數(shù)1時，不要直接調(diào)用v1.addElement(1)，正確的方法為：
　　Vector v1=new Vector();
　　Integer integer1=new Integer(1);
　　v1.addElement(integer1);
　　(2)public final synchronized void setElementAt(object obj,int index)
　　將index處的對象設(shè)成obj，原來的對象將被覆蓋。
　　(3)public final synchronized void insertElementAt(Object obj,int index)
　　在index指定的位置插入obj，原來對象以及此后的對象依次往后順延。
　　■刪除功能
　　(1)public final synchronized void removeElement(Object obj)
　　從向量中刪除obj。若有多個存在，則從向量頭開始試，刪除找到的第一個與obj相同的向量成員。
　　(2)public final synchronized void removeAllElement()
　　刪除向量中所有的對象。
　　(3)public final synchronized void removeElementlAt(int index)
　　刪除index所指的地方的對象。
　　■查詢搜索功能
　　(1)public final int indexOf(Object obj)
　　從向量頭開始搜索obj ,返回所遇到的第一個obj對應(yīng)的下標(biāo)，若不存在此obj，返回-1。
　　(2)public final synchronized int indexOf(Object obj,int index)
　　從index所表示的下標(biāo)處開始搜索obj。
　　(3)public final int lastIndexOf(Object obj)
　　從向量尾部開始逆向搜索obj。
　　(4)public final synchronized int lastIndexOf(Object obj,int index)
　　從index所表示的下標(biāo)處由尾至頭逆向搜索obj。
　　(5)public final synchronized Object firstElement()
　　獲取向量對象中的首個obj。
　　(6)public final synchronized Object lastelement()
　　獲取向量對象中的最后一個obj。
　　了解了向量的最基本的方法后，我們來看一下例8.3VectorApp.java。
　　例1.3 VectorApp.java。
　　import java.util.Vector;
　　import java.lang.*;//這一句不應(yīng)該要，但原文如此
　　import java.util.Enumeration;
　　public class VectorApp{
　　　public static void main(String[] args){
　　　　Vector v1=new Vector();
　　　　Integer integer1=new Integer(1);
　　　　v1.addElement("one");
　　　　//加入的為字符串對象
　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　//加入的為Integer的對象
　　　　v1.addElement("two");
　　　　v1.addElement(new Integer(2));
　　　　v1.addElement(integer1);
　　　　v1.addElement(integer1);
　　　　System.out.println("The vector v1 is:\n\t"+v1);
　　　　//將v1轉(zhuǎn)換成字符串并打印
　　　　v1.insertElementAt("three",2);
　　　　v1.insertElementAt(new Float(3.9),3);
　　　　System.out.println("The vector v1(used method insertElementAt()) is:\n\t "+v1);
　　　　//往指定位置插入新的對象，指定位置后的對象依次往后順延
　　　　v1.setElementAt("four",2);
　　　　System.out.println("The vector v1(used method setElementAt()) is:\n\t "+v1);
　　　　//將指定位置的對象設(shè)置為新的對象
　　　　v1.removeElement(integer1);
　　　　//從向量對象v1中刪除對象integer1由于存在多個integer1所以從頭開始
　　　　//找，刪除找到的第一個integer1
　　　　Enumeration enum=v1.elements();
　　　　System.out.print("The vector v1(used method removeElement())is:");
　　　　while(enum.hasMoreElements())
　　　　System.out.print(enum.nextElement()+" ");
　　　　System.out.println();
　　　　//使用枚舉類(Enumeration)的方法來獲取向量對象的每個元素
　　　　System.out.println("The position of object 1(top-to-bottom):"
　　　　　+ v1.indexOf(integer1));
　　　　System.out.println("The position of object 1(tottom-to-top):"
　　　　　+v1.lastIndexOf(integer1));
　　　　//按不同的方向查找對象integer1所處的位置
　　　　v1.setSize(4);
　　　　System.out.println("The new vector(resized the vector)is:"+v1);
　　　　//重新設(shè)置v1的大小，多余的元素被行棄
　　　}
　　}
　　運行結(jié)果：
　　E:\java01>java VectorApp
　　The vector v1 is:
　　　　　[one, 1, 1, two, 2, 1, 1]
　　The vector v1(used method insertElementAt()) is:
　　　　　[one, 1, three, 3.9, 1, two, 2, 1, 1]
　　The vector v1(used method setElementAt()) is:
　　　　　[one, 1, four, 3.9, 1, two, 2, 1, 1]
　　The vector v1(used method removeElement())is:one four 3.9 1 two 2 1 1
　　The position of object 1(top-to-bottom):3
　　The position of object 1(tottom-to-top):7
　　The new vector(resized the vector)is:[one, four, 3.9, 1]
　　E:\java01>
　　從例1.3運行的結(jié)果中可以清楚地了解上面各種方法的作用，另外還有幾點需解釋。
　　(1)類Vector定義了方法
　　public final int size()
　　此方法用于獲取向量元素的個數(shù)。它的返回值是向是中實際存在的元素個數(shù)，而非向量容量。可以調(diào)用方法capactly()來獲取容量值。
　　方法：
　　public final synchronized void setsize(int newsize)
　　此方法用來定義向量大小。若向量對象現(xiàn)有成員個數(shù)已超過了newsize的值，則超過部分的多余元素會丟失。
　　(2)程序中定義了Enumeration類的一個對象
　　Enumeration是java.util中的一個接口類，在Enumeration中封裝了有關(guān)枚舉數(shù)據(jù)集合的方法。
　　在Enumeration中提供了方法hawMoreElement()來判斷集合中是束還有其它元素和方法nextElement()來獲取下一個元素。利用這兩個方法可以依次獲得集合中元素。
　　Vector中提供方法：
　　public final synchronized Enumeration elements()
　　此方法將向量對象對應(yīng)到一個枚舉類型。java.util包中的其它類中也大都有這類方法，以便于用戶獲取對應(yīng)的枚舉類型。

1.6 棧類Stack

　　Stack類是Vector類的子類。它向用戶提供了堆棧這種高級的數(shù)據(jù)結(jié)構(gòu)。棧的基本特性就是先進(jìn)后出。即先放入棧中的元素將后被推出。Stack類中提供了相應(yīng)方法完成棧的有關(guān)操作。
　　基本方法：
　　public Object push(Object Hem)
　　將Hem壓入棧中，Hem可以是任何類的對象。
　　public Object pop()
　　彈出一個對象。
　　public Object peek()
　　返回棧頂元素，但不彈出此元素。
　　public int search(Object obj)
　　搜索對象obj,返回它所處的位置。
　　public boolean empty()
　　判別棧是否為空。
　　例1.4 StackApp.java使用了上面的各種方法。
　　例1.4 StackApp.java。
　　import java.lang.*;
　　import java.util.*;
　　public class StackApp{
　　　public static void main(String args[]){
　　　　Stack sta=new Stack();
　　　　sta.push("Apple");
　　　　sta.push("banana");
　　　　sta.push("Cherry");
　　　　//壓入的為字符串對象
　　　　sta.push(new Integer(2));
　　　　//壓入的為Integer的對象，值為2
　　　　sta.push(new Float(3.5));
　　　　//壓入的為Float的對象，值為3.5
　　　　System.out.println("The stack is,"+sta);
　　　　//對應(yīng)棧sta
　　　　System.out.println("The top of stack is:"+sta.peek());
　　　　//對應(yīng)棧頂元素，但不將此元素彈出
　　　　System.out.println("The position of object Cherry is:"
　　　　+sta.search("cherry"));
　　　　//打印對象Cherry所處的位置
　　　　System.out.print("Pop the element of the stack:");
　　　　while(!sta.empty())
　　　　System.out.print(sta.pop()+" ");
　　　　System.out.println();
　　　　//將棧中的元素依次彈出并打印。與第一次打印的sta的結(jié)果比較，可看出棧
　　　　//先進(jìn)后出的特點
　　　}
　　}
　　運行結(jié)果(略)


1.7 哈希表類Hashtable

　　哈希表是一種重要的存儲方式，也是一種常見的檢索方法。其基本思想是將關(guān)系碼的值作為自變量，通過一定的函數(shù)關(guān)系計算出對應(yīng)的函數(shù)值，把這個數(shù)值解釋為結(jié)點的存儲地址，將結(jié)點存入計算得到存儲地址所對應(yīng)的存儲單元。檢索時采用檢索關(guān)鍵碼的方法?，F(xiàn)在哈希表有一套完整的算法來進(jìn)行插入、刪除和解決沖突。在Java中哈希表用于存儲對象，實現(xiàn)快速檢索。
　　Java.util.Hashtable提供了種方法讓用戶使用哈希表，而不需要考慮其哈希表真正如何工作。
　　哈希表類中提供了三種構(gòu)造方法，分別是：
　　public Hashtable()
　　public Hashtable(int initialcapacity)
　　public Hashtable(int initialCapacity,float loadFactor)
　　參數(shù)initialCapacity是Hashtable的初始容量，它的值應(yīng)大于0。loadFactor又稱裝載因子，是一個0.0到0.1之間的float型的浮點數(shù)。它是一個百分比，表明了哈希表何時需要擴(kuò)充，例如，有一哈希表，容量為100，而裝載因子為0.9，那么當(dāng)哈希表90%的容量已被使用時，此哈希表會自動擴(kuò)充成一個更大的哈希表。如果用戶不賦這些參數(shù)，系統(tǒng)會自動進(jìn)行處理，而不需要用戶操心。
　　Hashtable提供了基本的插入、檢索等方法。
　　■插入
　　public synchronized void put(Object key,Object value)
給對象value設(shè)定一關(guān)鍵字key,并將其加到Hashtable中。若此關(guān)鍵字已經(jīng)存在，則將此關(guān)鍵字對應(yīng)的舊對象更新為新的對象Value。這表明在哈希表中相同的關(guān)鍵字不可能對應(yīng)不同的對象(從哈希表的基本思想來看，這也是顯而易見的)。
　　■檢索
　　public synchronized Object get(Object key)
　　根據(jù)給定關(guān)鍵字key獲取相對應(yīng)的對象。
　　public synchronized boolean containsKey(Object key)
　　判斷哈希表中是否包含關(guān)鍵字key。
　　public synchronized boolean contains(Object value)
　　判斷value是否是哈希表中的一個元素。
　　■刪除
　　public synchronized object remove(object key)
　　從哈希表中刪除關(guān)鍵字key所對應(yīng)的對象。
　　public synchronized void clear()
　　清除哈希表
　　另外，Hashtalbe還提供方法獲取相對應(yīng)的枚舉集合：
　　public synchronized Enumeration keys()
　　返回關(guān)鍵字對應(yīng)的枚舉對象。
　　public synchronized Enumeration elements()
　　返回元素對應(yīng)的枚舉對象。
　　例1.5 Hashtable.java給出了使用Hashtable的例子。
　　例1.5 Hashtalbe.java。
　　//import java.lang.*;
　　import java.util.Hashtable;
　　import java.util.Enumeration;
　　public class HashApp{
　　　public static void main(String args[]){
　　　　Hashtable hash=new Hashtable(2,(float)0.8);
　　　　//創(chuàng)建了一個哈希表的對象hash，初始容量為2，裝載因子為0.8

　　　　hash.put("Jiangsu","Nanjing");
　　　　//將字符串對象“Jiangsu”給定一關(guān)鍵字“Nanjing”,并將它加入hash
　　　　hash.put("Beijing","Beijing");
　　　　hash.put("Zhejiang","Hangzhou");

　　　　System.out.println("The hashtable hash1 is: "+hash);
　　　　System.out.println("The size of this hash table is "+hash.size());
　　　　//打印hash的內(nèi)容和大小

　　　　Enumeration enum1=hash.elements();
　　　　System.out.print("The element of hash is: ");
　　　　while(enum1.hasMoreElements())
　　　　　System.out.print(enum1.nextElement()+" ");
　　　　System.out.println();
　　　　//依次打印hash中的內(nèi)容
　　　　if(hash.containsKey("Jiangsu"))
　　　　　System.out.println("The capatial of Jiangsu is "+hash.get("Jiangsu"));
　　　　hash.remove("Beijing");
　　　　//刪除關(guān)鍵字Beijing對應(yīng)對象
　　　　System.out.println("The hashtable hash2 is: "+hash);
　　　　System.out.println("The size of this hash table is "+hash.size());
　　　}
　　}

　　運行結(jié)果：
　　The hashtable hash1 is: {Beijing=Beijing, Zhejiang=Hangzhou, Jiangsu=Nanjing}
　　The size of this hash table is 3
　　The element of hash is: Beijing Hangzhou Nanjing
　　The capatial of Jiangsu is Nanjing
　　The hashtable hash2 is: {Zhejiang=Hangzhou, Jiangsu=Nanjing}
　　The size of this hash table is 2

　　Hashtable是Dictionary(字典)類的子類。在字典類中就把關(guān)鍵字對應(yīng)到數(shù)據(jù)值。字典類是一個抽象類。在java.util中還有一個類Properties，它是Hashtable的子類。用它可以進(jìn)行與對象屬性相關(guān)的操作。

1.8 位集合類BitSet

　　位集合類中封裝了有關(guān)一組二進(jìn)制數(shù)據(jù)的操作。
　　我們先來看一下例8.6 BitSetApp.java。
　　例8.6 BitSetApp.java
　　//import java.lang.*;
　　import java.util.BitSet;
　　public class BitSetApp{
　　　private static int n=5;
　　　public static void main(String[] args){
　　　　BitSet set1=new BitSet(n);
　　　　for(int i=0;i<n;i++) set1.set(i);
　　　　//將set1的各位賦1，即各位均為true
　　　　BitSet set2= new BitSet();
　　　　set2=(BitSet)set1.clone();
　　　　//set2為set1的拷貝
　　　　set1.clear(0);
　　　　set2.clear(2);
　　　　//將set1的第0位set2的第2位清零
　　　　System.out.println("The set1 is: "+set1);
　　　　//直接將set1轉(zhuǎn)換成字符串輸出，輸出的內(nèi)容是set1中值true所處的位置
　　　　//打印結(jié)果為The set1 is:{1,2,3,4}
　　　　System.out.println("The hash code of set2 is: "+set2.hashCode());
　　　　//打印set2的hashCode
　　　　printbit("set1",set1);
　　　　printbit("set2",set2);
　　　　//調(diào)用打印程序printbit(),打印對象中的每一個元素
　　　　//打印set1的結(jié)果為The bit set1 is: false true true true true
　　　　set1.and(set2);
　　　　printbit("set1 and set2",set1);
　　　　//完成set1 and set2,并打印結(jié)果
　　　　set1.or(set2);
　　　　printbit("set1 or set2",set1);
　　　　//完成set1 or set2,并打印結(jié)果
　　　　set1.xor(set2);
　　　　printbit("set1 xor set2",set1);
　　　　//完成set1 xor set2,并打印結(jié)果
　　　}
　　　//打印BitSet對象中的內(nèi)容
　　　public static void printbit(String name,BitSet set){
　　　　System.out.print("The bit "+name+" is: ");
　　　　for(int i=0;i<n;i++)
　　　　　System.out.print(set.get(i)+" ");
　　　　System.out.println();
　　　}
　　}

　　運行結(jié)果：
　　The set1 is: {1, 2, 3, 4}
　　The hash code of set2 is: 1225
　　The bit set1 is: false true true true true
　　The bit set2 is: true true false true true
　　The bit set1 and set2 is: false true false true true
　　The bit set1 or set2 is: true true false true true
　　The bit set1 xor set2 is: false false false false false

　　程序中使用了BitSet類提供的兩種構(gòu)造方法：
　　　　public BitSet();
　　　　public BitSet(int n);
　　參數(shù)n代表所創(chuàng)建的BitSet類的對象的大小。BitSet類的對象的大小在必要時會由系統(tǒng)自動擴(kuò)充。
　　其它方法：
　　public void set(int n)
　　將BitSet對象的第n位設(shè)置成1。
　　public void clear(int n)
　　將BitSet對象的第n位清零。
　　public boolean get(int n)
　　讀取位集合對象的第n位的值，它獲取的是一個布爾值。當(dāng)?shù)趎位為1時，返回true；第n位為0時，返回false。
　　另外，如在程序中所示，當(dāng)把一BitSet類的對象轉(zhuǎn)換成字符串輸出時，輸出的內(nèi)容是此對象中true所處的位置。
　　在BitSet中提供了一組位操作，分別是：
　　public void and(BitSet set)
　　public void or(BitSet set)
　　public void xor(BitSet set)
利用它們可以完成兩個位集合之間的與、或、異或操作。
　　BitSet類中有一方法public int size()來取得位集合的大小，它的返回值與初始化時設(shè)定的位集合大小n不一樣，一般為64。

小結(jié)

　　本章我們介紹了Java的實用工具類庫java.util中一些常用的類。java.util包中還有其它一些類。它們的具體用法用戶可以自行查閱API。 

     package untitled4;
import java.util.*;
class compare implements Comparator
{
    public int compare(Object o1,Object o2)
    { 
        int i=((Person)o1).getFirstName().compareTo(((Person)o2).getFirstName());
        return (i!=0?i:((Person)o1).getLastName().compareTo(((Person)o2).getLastName()));
    }
}
class Person implements Comparable
{   private String firstName;
    private String lastName;
    public String getFirstName()
    {
      return firstName;
    }
    public String getLastName()
    {      return lastName;
    }
    public Person(String f,String l)
    {
       firstName=f;
       lastName=l;
    }
    public int compareTo(Object o)
    {  Person p=(Person)o;
        int l=firstName.compareTo(p.firstName);
       return (l!=0?l:(lastName.compareTo(p.lastName)));
    }
    public String toString()
    {
        return firstName+" "+lastName;
    }

}
public class ArrayTest {
    public ArrayTest() {
    }
public static void main(String args[])
    {
        int a[];
        a = new int[5];
        Arrays.fill(a, 5);  //用5填充數(shù)組
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        int b[] = {10, 3, 5, 6, 8, 9};
        Arrays.sort(b);
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }
   
        Person p[] = {
                     new Person("John", "Lennon"),
                     new Person("Karl", "Marx"),
                     new Person("Groucho", "Marx"),
                     new Person("Oscar", "Grouch")
        };
        for (int i = 0; i < p.length; i++) {
            System.out.println(p[i]);
        }
   
        //Arrays.sort(p);
        Arrays.sort(p, new compare());
        for (int i = 0; i < p.length; i++) {
           System.out.println(p[i]);
       }

        int s = Arrays.binarySearch(p, new Person("Groucho", "Marx"), new compare());
        System.out.println(s);
        Person person[];
        person = new Person[4];
        System.arraycopy(p, 0, person, 0, p.length);
        for (int c= 0; c < person.length; c++)
        {
            System.out.println(person[c]);
   
        }
    }
}
當(dāng)用Arrays的sort方法時,需要排序的數(shù)組必須實現(xiàn)Comparable借口.或者實現(xiàn)Comparator接口
Arrays的fill方法是用一個基本類型或者一個對象填充數(shù)組.
當(dāng)調(diào)用binarySearch()時如果是調(diào)用sort(Objiec a[],Comparator a)時,,應(yīng)調(diào)用相應(yīng)的binarySearch(Object a[],Object value,Comparator)方法.
equals()方法用于比較非基本類型數(shù)組時,調(diào)用他們的equals方法..比如
 int a[]={5,4,3,2,1};
 int c[]={5,4,3,2,1};  基本類型比較他們的值,
 System.out.println(Arrays.equals(a,c));  TRUE
Integer a[]={new Integer(1),new Integer(2),new Integer(3)};
Integer b[]={new Integer(1),new Integer(2),new Integer(3)};
System.out.println(Arrays.equals(a,b));   調(diào)用Integer.equals()方法
對于沒有覆蓋Object equals方法的對象數(shù)組,他們之間比較的是對象的引用.
System.arraycopy()方法對與基本類型來說只是復(fù)制他們的值.而對于非基本類型時他們復(fù)制引用
  person person[]={new person("guo",20),new person("cher",21)};
         person per[]={new person("guo",20),new person("cher",21)};
       person []p=new person[2];
       System.arraycopy(person,0,p,0,person.length);
       System.out.println(person==p);    //輸出  false
       person[1].setName("hao");
       System.out.println(person[1].equals(p[1]));  輸出 true
       System.out.println(Arrays.equals(person,p));   輸出 true
        System.out.println(Arrays.equals(person,per));  輸出 false

如果子類繼承了父類的方法（未重寫），則運行時系統(tǒng)調(diào)用父類的方法。
在例3-6中，父類對象a引用的是子類的實例，所以，java運行時調(diào)用子類B的callme方法。
importjava.io.*;
　　classA{
　　　　　voidcallme(){
　　　　　　System.out.println("InsideA'scallme()method");
　　　　　}
　　}
　　classBextendsA{
　　　　　voidcallme(){
　　　　　　System.out.println("InsideB'scallme()Method");
　　　　　}
　　}
　　publicclassDispatch{
　　　　　publicstaticvoidmain(Stringargs[]){
　　　　　　Aa=newB();
　　　　　　a.callme();
　　　　　}
　　}

◇方法重寫時應(yīng)遵循的原則：
　　1）改寫后的方法不能比被重寫的方法有更嚴(yán)格的訪問權(quán)限（可以相同）。
　　2）改寫后的方法不能比重寫的方法產(chǎn)生更多的例外。

品味Java子類型多態(tài)的魅力

減小字體 增大字體 顏色 默認(rèn) 灰度 橄欖色 綠色 藍(lán)色 褐色 紅色

“polymorphism(多態(tài)）”一詞來自希臘語，意為“多種形式”。多數(shù)Java程序員把多態(tài)看作對象的一種能力，使其能調(diào)用正確的方法版本。盡管如此，這種面向?qū)崿F(xiàn)的觀點導(dǎo)致了多態(tài)的神奇功能，勝于僅僅把多態(tài)看成純粹的概念。 　　Java中的多態(tài)總是子類型的多態(tài)。幾乎是機(jī)械式產(chǎn)生了一些多態(tài)的行為，使我們不去考慮其中涉及的類型問題。本文研究了一種面向類型的對象觀點，分析了如何將對象能夠表現(xiàn)的行為和對象即將表現(xiàn)的行為分離開來。拋開Java中的多態(tài)都是來自繼承的概念，我們?nèi)匀豢梢愿械?，Java中的接口是一組沒有公共代碼的對象共享實現(xiàn)。 　　多態(tài)的分類 　　多態(tài)在面向?qū)ο笳Z言中是個很普遍的概念.雖然我們經(jīng)常把多態(tài)混為一談，但實際上有四種不同類型的多態(tài)。在開始正式的子類型多態(tài)的細(xì)節(jié)討論前，然我們先來看看普通面向?qū)ο笾械亩鄳B(tài)。 　　Luca Cardelli和Peter Wegner（"On Understanding Types, Data Abstraction, and Polymorphism"一文的作者， 文章參考資源鏈接）把多態(tài)分為兩大類----特定的和通用的----四小類：強制的，重載的，參數(shù)的和包含的。他們的結(jié)構(gòu)如下： screen.width-600)this.style.width=screen.width-600;"> 　　在這樣一個體系中，多態(tài)表現(xiàn)出多種形式的能力。通用多態(tài)引用有相同結(jié)構(gòu)類型的大量對象，他們有著共同的特征。特定的多態(tài)涉及的是小部分沒有相同特征的對象。四種多態(tài)可做以下描述： 　　強制的：一種隱式做類型轉(zhuǎn)換的方法。 　　重載的：將一個標(biāo)志符用作多個意義。 　　參數(shù)的：為不同類型的參數(shù)提供相同的操作。 　　包含的：類包含關(guān)系的抽象操作。 　　我將在講述子類型多態(tài)前簡單介紹一下這幾種多態(tài)。 　　強制的多態(tài) 　　強制多態(tài)隱式的將參數(shù)按某種方法，轉(zhuǎn)換成編譯器認(rèn)為正確的類型以避免錯誤。在以下的表達(dá)式中，編譯器必須決定二元運算符‘+’所應(yīng)做的工作： 　　2.0 + 2.0 　　2.0 + 2 　　2.0 + "2" 　　第一個表達(dá)式將兩個double的操作數(shù)相加；Java中特別聲明了這種用法。 　　第二個表達(dá)式將double型和int相加。Java中沒有明確定義這種運算。不過，編譯器隱式的將第二個操作數(shù)轉(zhuǎn)換為double型，并作double型的加法。做對程序員來說十分方便，否則將會拋出一個編譯錯誤，或者強制程序員顯式的將int轉(zhuǎn)換為double。 　　第三個表達(dá)式將double與一個String相加。Java中同樣沒有定義這樣的操作。所以，編譯器將double轉(zhuǎn)換成String類型，并將他們做串聯(lián)。 　　強制多態(tài)也會發(fā)生在方法調(diào)用中。假設(shè)類Derived繼承了類Base，類C有一個方法，原型為m(Base)，在下面的代碼中，編譯器隱式的將Derived類的對象derived轉(zhuǎn)化為Base類的對象。這種隱式的轉(zhuǎn)換使m(Base)方法使用所有能轉(zhuǎn)換成Base類的所有參數(shù)。 C c = new C(); Derived derived = new Derived(); c.m( derived ); 　　并且，隱式的強制轉(zhuǎn)換，可以避免類型轉(zhuǎn)換的麻煩，減少編譯錯誤。當(dāng)然，編譯器仍然會優(yōu)先驗證符合定義的對象類型。 　　重載的多態(tài) 　　重載允許用相同的運算符或方法，去表示截然不同的意義?！?’在上面的程序中有兩個意思：兩個double型的數(shù)相加；兩個串相連。另外還有整型相加，長整型，等等。這些運算符的重載，依賴于編譯器根據(jù)上下文做出的選擇。以往的編譯器會把操作數(shù)隱式轉(zhuǎn)換為完全符合操作符的類型。雖然Java明確支持重載，但不支持用戶定義的操作符重載。 　　Java支持用戶定義的函數(shù)重載。一個類中可以有相同名字的方法，這些方法可以有不同的意義。這些重載的方法中，必須滿足參數(shù)數(shù)目不同，相同位置上的參數(shù)類型不同。這些不同可以幫助編譯器區(qū)分不同版本的方法。 　　編譯器以這種唯一表示的特征來表示不同的方法，比用名字表示更為有效。據(jù)此，所有的多態(tài)行為都能編譯通過。 　　強制和重載的多態(tài)都被分類為特定的多態(tài)，因為這些多態(tài)都是在特定的意義上的。這些被劃入多態(tài)的特性給程序員帶來了很大的方便。強制多態(tài)排除了麻煩的類型和編譯錯誤。重載多態(tài)像一塊糖，允許程序員用相同的名字表示不同的方法，很方便。 　　參數(shù)的多態(tài) 　　參數(shù)多態(tài)允許把許多類型抽象成單一的表示。例如，List抽象類中，描述了一組具有同樣特征的對象，提供了一個通用的模板。你可以通過指定一種類型以重用這個抽象類。這些參數(shù)可以是任何用戶定義的類型，大量的用戶可以使用這個抽象類，因此參數(shù)多態(tài)毫無疑問的成為最強大的多態(tài)。 　　乍一看，上面抽象類好像是java.util.List的功能。然而，Java實際上并不支持真正的安全類型風(fēng)格的參數(shù)多態(tài)，這也是java.util.List和java.util的其他集合類是用原始的java.lang.Object寫的原因（參考我的文章"A Primordial Interface?" 以獲得更多細(xì)節(jié)）。Java的單根繼承方式解決了部分問題，但沒有發(fā)揮出參數(shù)多態(tài)的全部功能。Eric Allen有一篇精彩的文章“Behold the Power of Parametric Polymorphism”，描述了Java通用類型的需求，并建議給Sun的Java規(guī)格需求#000014號文檔"Add Generic Types to the Java Programming Language."（參考資源鏈接） 　　包含的多態(tài) 　　包含多態(tài)通過值的類型和集合的包含關(guān)系實現(xiàn)了多態(tài)的行為.在包括Java在內(nèi)的眾多面向?qū)ο笳Z言中，包含關(guān)系是子類型的。所以，Java的包含多態(tài)是子類型的多態(tài)。 　　在早期，Java開發(fā)者們所提及的多態(tài)就特指子類型的多態(tài)。通過一種面向類型的觀點，我們可以看到子類型多態(tài)的強大功能。以下的文章中我們將仔細(xì)探討這個問題。為簡明起見，下文中的多態(tài)均指包含多態(tài)。 　　面向類型觀點 　　圖1的UML類圖給出了類和類型的簡單繼承關(guān)系，以便于解釋多態(tài)機(jī)制。模型中包含5種類型，4個類和一個接口。雖然UML中稱為類圖，我把它看成類型圖。如"Thanks Type and Gentle Class," 一文中所述，每個類和接口都是一種用戶定義的類型。按獨立實現(xiàn)的觀點（如面向類型的觀點），下圖中的每個矩形代表一種類型。從實現(xiàn)方法看，四種類型運用了類的結(jié)構(gòu)，一種運用了接口的結(jié)構(gòu)。 screen.width-600)this.style.width=screen.width-600;"> 圖1：示范代碼的UML類圖 　　以下的代碼實現(xiàn)了每個用戶定義的數(shù)據(jù)類型，我把實現(xiàn)寫得很簡單。 /* Base.java */ public class Base { 　public String m1() 　{ 　　return "Base.m1()"; 　} 　public String m2( String s ) 　{ 　　return "Base.m2( " + s + " )"; 　} } /* IType.java */ interface IType { 　String m2( String s ); 　String m3(); } /* Derived.java */ public class Derived extends Base implements IType { 　public String m1() 　{ 　　return "Derived.m1()"; 　} 　public String m3() 　{ 　　return "Derived.m3()"; 　} } /* Derived2.java */ public class Derived2 extends Derived { 　public String m2( String s ) 　{ 　　return "Derived2.m2( " + s + " )"; 　} 　public String m4() 　{ 　　return "Derived2.m4()"; 　} } /* Separate.java */ public class Separate implements IType { 　public String m1() 　{ 　　return "Separate.m1()"; 　} 　public String m2( String s ) 　{ 　　return "Separate.m2( " + s + " )"; 　} 　public String m3() 　{ 　　return "Separate.m3()"; 　} } 　　用這樣的類型聲明和類的定義，圖2從概念的觀點描述了Java指令。 Derived2 derived2 = new Derived2(); screen.width-600)this.style.width=screen.width-600;"> 圖2 ：Derived2 對象上的引用 　　上文中聲明了derived2這個對象，它是Derived2類的。圖2種的最頂層把Derived2引用描述成一個集合的窗口，雖然其下的Derived2對象是可見的。這里為每個Derived2類型的操作留了一個孔。Derived2對象的每個操作都去映射適當(dāng)?shù)拇a，按照上面的代碼所描述的那樣。例如，Derived2對象映射了在Derived中定義的m1()方法。而且還重載了Base類的m1()方法。一個Derived2的引用變量無權(quán)訪問Base類中被重載的m1()方法。但這并不意味著不可以用super.m1()的方法調(diào)用去使用這個方法。關(guān)系到derived2這個引用的變量，這個代碼是不合適的。Derived2的其他的操作映射同樣表明了每種類型操作的代碼執(zhí)行。 　　既然你有一個Derived2對象，可以用任何一個Derived2類型的變量去引用它。如圖1所示，Derived, Base和IType都是Derived2的基類。所以，Base類的引用是很有用的。圖3描述了以下語句的概念觀點。 Base base = derived2; screen.width-600)this.style.width=screen.width-600;"> 圖3：Base類引用附于Derived2對象之上 　 　　雖然Base類的引用不用再訪問m3()和m4()，但是卻不會改變它Derived2對象的任何特征及操作映射。無論是變量derived2還是base，其調(diào)用m1()或m2(String)所執(zhí)行的代碼都是一樣的。 String tmp; // Derived2 reference (Figure 2) tmp = derived2.m1(); // tmp is "Derived.m1()" tmp = derived2.m2( "Hello" ); // tmp is "Derived2.m2( Hello )" // Base reference (Figure 3) tmp = base.m1(); // tmp is "Derived.m1()" tmp = base.m2( "Hello" ); // tmp is "Derived2.m2( Hello )" 　　兩個引用之所以調(diào)用同一個行為，是因為Derived2對象并不知道去調(diào)用哪個方法。對象只知道什么時候調(diào)用，它隨著繼承實現(xiàn)的順序去執(zhí)行。這樣的順序決定了Derived2對象調(diào)用Derived里的m1()方法，并調(diào)用Derived2里的m2(String)方法。這種結(jié)果取決于對象本身的類型，而不是引用的類型。 　　盡管如此，但不意味著你用derived2和base引用的效果是完全一樣的。如圖3所示，Base的引用只能看到Base類型擁有的操作。所以，雖然Derived2有對方法m3()和m4()的映射，但是變量base不能訪問這些方法。 String tmp; // Derived2 reference (Figure 2) tmp = derived2.m3(); // tmp is "Derived.m3()" tmp = derived2.m4(); // tmp is "Derived2.m4()" // Base reference (Figure 3) tmp = base.m3(); // Compile-time error tmp = base.m4(); // Compile-time error 　　運行期的Derived2對象保持了接受m3()和m4()方法的能力。類型的限制使Base的引用不能在編譯期調(diào)用這些方法。編譯期的類型檢查像一套鎧甲，保證了運行期對象只能和正確的操作進(jìn)行相互作用。換句話說，類型定義了對象間相互作用的邊界。 　　多態(tài)的依附性 　　類型的一致性是多態(tài)的核心。對象上的每一個引用，靜態(tài)的類型檢查器都要確認(rèn)這樣的依附和其對象的層次是一致的。當(dāng)一個引用成功的依附于另一個不同的對象時，有趣的多態(tài)現(xiàn)象就產(chǎn)生了。（嚴(yán)格的說，對象類型是指類的定義。）你也可以把幾個不同的引用依附于同一個對象。在開始更有趣的場景前，我們先來看一下下面的情況為什么不會產(chǎn)生多態(tài)。 　　多個引用依附于一個對象 　　圖2和圖3描述的例子是把兩個及兩個以上的引用依附于一個對象。雖然Derived2對象在被依附之后仍保持了變量的類型，但是，圖3中的Base類型的引用依附之后，其功能減少了。結(jié)論很明顯：把一個基類的引用依附于派生類的對象之上會減少其能力。 　　一個開發(fā)這怎么會選擇減少對象能力的方案呢？這種選擇是間接的。假設(shè)有一個名為ref的引用依附于一個包含如下方法的類的對象： public String poly1( Base base ) { 　return base.m1(); } 　　用一個Derived2的參數(shù)調(diào)用poly(Base)是符合參數(shù)類型檢查的： ref.poly1( derived2 ); 　　方法調(diào)用把一個本地Base類型的變量依附在一個引入的對象上。所以，雖然這個方法只接受Base類型的參數(shù)，但Derived2對象仍是允許的。開發(fā)這就不必選擇丟失功能的方案。從人眼在通過Derived2對象時所看到的情況，Base類型引用的依附導(dǎo)致了功能的喪失。但從執(zhí)行的觀點看，每一個傳入poly1(Base)的參數(shù)都認(rèn)為是Base的對象。執(zhí)行機(jī)并不在乎有多個引用指向同一個對象，它只注重把指向另一個對象的引用傳給方法。這些對象的類型不一致并不是主要問題。執(zhí)行器只關(guān)心給運行時的對象找到適當(dāng)?shù)膶崿F(xiàn)。面向類型的觀點展示了多態(tài)的巨大能力。 　　附于多個對象的引用 　　讓我們來看一下發(fā)生在poly1(Base)中的多態(tài)行為。下面的代碼創(chuàng)建了三個對象，并通過引用傳給poly1(Base): Derived2 derived2 = new Derived2(); Derived derived = new Derived(); Base base = new Base(); String tmp; tmp = ref.poly1( derived2 ); // tmp is "Derived.m1()" tmp = ref.poly1( derived ); // tmp is "Derived.m1()" tmp = ref.poly1( base ); // tmp is "Base.m1()" 　　poly1(Base)的實現(xiàn)代碼是調(diào)用傳進(jìn)來的參數(shù)的m1()方法。圖3和圖4展示了把三個類的對象傳給方法時，面向類型的所使用的體系結(jié)構(gòu)。 screen.width-600)this.style.width=screen.width-600;"> 圖4：將Base引用指向Derived類，以及Base對象 　　請注意每個圖中方法m1()的映射。圖3中，m1()調(diào)用了Derived類的代碼；上面代碼中的注釋標(biāo)明了ploy1(Base)調(diào)用Derived.m1()。圖4中Derived對象調(diào)用的仍然是Derived類的m1()方法。最后，圖4中，Base對象調(diào)用的m1()是Base類中定義的代碼。 　　多態(tài)的魅力何在？再來看一下poly1(Base)的代碼，它可以接受任何屬于Base類范疇的參數(shù)。然而，當(dāng)他收到一個Derived2的對象時，它實際上卻調(diào)用了Derived版本的方法。當(dāng)你根據(jù)Base類派生出其他類時，如Derived，Derived2，poly1(Base)都可以接受這些參數(shù)，并作出選擇調(diào)用合適的方法。多態(tài)允許你在完成poly1(Base)后擴(kuò)展它的用途。 　　這看起來當(dāng)然很神奇?；镜睦斫庹故玖硕鄳B(tài)的內(nèi)部工作原理。在面向類型的觀點中，底層的對象所實現(xiàn)的代碼是非實質(zhì)性的。重要的是，類型檢查器會在編譯期間為每個引用選擇合適的代碼以實現(xiàn)其方法。多態(tài)使開發(fā)者運用面向類型的觀點，不考慮實現(xiàn)的細(xì)節(jié)。這樣有助于把類型和實現(xiàn)分離（實際用處是把接口和實現(xiàn)分離）。 　　對象接口 　　多態(tài)依賴于類型和實現(xiàn)的分離，多用來把接口和實現(xiàn)分離。但下面的觀點好像把Java的關(guān)鍵字interface搞得很糊涂。 　　更為重要的使開發(fā)者們怎樣理解短語“the interface to an object"，典型地，根據(jù)上下文，這個短語的意思是指一切對象類中所定義的方法，至一切對象公開的方法。這種傾向于以實現(xiàn)為中心的觀點較之于面向類型的觀點來說，使我們更加注重于對象在運行期的能力。圖3中，引用面板的對象表面被標(biāo)志成"Derived2 Object"。這個面板上列出了Derived2對象的所有可用的方法。但是要理解多態(tài)，我們必須從實現(xiàn)這一層次上解放出來，并注意面向類型的透視圖中被標(biāo)為"Base Reference"的面板。在這一層意思上，引用變量的類型指明了一個對象的表面。這只是一個表面，不是接口。在類型一致的原則下，我們可以用面向類型的觀點，為一個對象依附多個引用。對interface to an object這個短語的理解沒有確定的理解。 　　在類型概念中，the interface to an object refers 引用了面向類型觀點的最大可能----如圖2的情形。把一個基類的引用指向相同的對象縮小了這樣的觀點----如圖3所示。類型概念能使人獲得把對象間的相互作用同實現(xiàn)細(xì)節(jié)分離的要領(lǐng)。相對于一個對象的接口，面向類型的觀點更鼓勵人們?nèi)ナ褂靡粋€對象的引用。引用類型規(guī)定了對象間的相互作用。當(dāng)你考慮一個對象能做什么的時候，只需搞明白他的類型，而不需要去考慮他的實現(xiàn)細(xì)節(jié)。 　　Java接口 　　以上所談到的多態(tài)行為用到了類的繼承關(guān)系所建立起來的子類型關(guān)系。Java接口同樣支持用戶定義的類型，相對地，Java的接口機(jī)制啟動了建立在類型層次結(jié)構(gòu)上的多態(tài)行為。假設(shè)一個名為ref的引用變量，并使其指向一個包含一下方法的類對象： public String poly2( IType iType ) { 　return iType.m3(); } 　　為了弄明白poly2(IType)中的多態(tài)，以下的代碼從不同的類創(chuàng)建兩個對象，并分別把他們傳給poly2(IType)： Derived2 derived2 = new Derived2(); Separate separate = new Separate(); String tmp; tmp = ref.poly2( derived2 ); // tmp is "Derived.m3()" tmp = ref.poly2( separate ); // tmp is "Separate.m3()" 　　上面的代碼類似于關(guān)于poly1(Base)中的多態(tài)的討論。poly2(IType)的實現(xiàn)代碼是調(diào)用每個對象的本地版本的m3()方法。如同以前，代碼的注釋表明了每次調(diào)用所返回的CString類型的結(jié)果。圖5表明了兩次調(diào)用poly2(IType)的概念結(jié)構(gòu)： screen.width-600)this.style.width=screen.width-600;"> 圖5：指向Derived2和Separate對象的IType引用 　　方法poly1(Base)和poly2(IType)中所表現(xiàn)的多態(tài)行為的相似之處可以從透視圖中直接看出來。把我們在實現(xiàn)在一層上的理解再提高一層，就可以看到這兩段代碼的技巧。基類的引用指向了作為參數(shù)傳進(jìn)的類，并且按照類型的限制調(diào)用對象的方法。引用既不知道也不關(guān)心執(zhí)行哪一段代碼。編譯期間的子類型關(guān)系檢查保證了通過的對象有能力在被調(diào)用的時候選擇合適的實現(xiàn)代碼。 　　然而，他們在實現(xiàn)層上有一個重要的差別。在poly1(Base)的例子中（圖3和圖4），Base-Derived-Derived2的類繼承結(jié)構(gòu)為子類型關(guān)系的建立提供了條件，并決定了方法去調(diào)用哪段代碼。在poly2(IType)的例子中（如圖5），則是完全不同的動態(tài)發(fā)生的。Derived2和Separate不共享任何實現(xiàn)的層次，但是他們還是通過IType的引用展示了多態(tài)的行為。 　　這樣的多態(tài)行為使Java的接口的功能的重大意義顯得很明顯。圖1中的UML類圖說明了Derived是Base和IType的子類型。通過完全脫離實現(xiàn)細(xì)節(jié)的類型的定義方法，Java實現(xiàn)了多類型繼承，并且不存在Java所禁止的多繼承所帶來的煩人的問題。完全脫離實現(xiàn)層次的類可以按照J(rèn)ava接口實現(xiàn)分組。在圖1中，接口IType和Derived,Separate以及這類型的其他子類型應(yīng)該劃為一組。 　　按照這種完全不同于實現(xiàn)層次的分類方法，Java的接口機(jī)制是多態(tài)變得很方便，哪怕不存在任何共享的實現(xiàn)或者復(fù)寫的方法。如圖5所示，一個IType的引用，用多態(tài)的方法訪問到了Derived2和Separate對象的m3()方法。 　　再次探討對象的接口 　　注意圖5中的Derived2和Separate對象的對m1()的映射方法。如前所述，每一個對象的接口都包含方法m1()。但卻沒有辦法用這兩個對象使方法m1()表現(xiàn)出多態(tài)的行為。每一個對象占有一個m1()方法是不夠的。必須存在一個可以操作m1()方法的類型，通過這個類型可以看到對象。這些對象似乎是共享了m1()方法，但在沒有共同基類的條件下，多態(tài)是不可能的。通過對象的接口來看多態(tài)，會把這個概念搞混。 　　結(jié)論 　　從全文所述的面向?qū)ο蠖鄳B(tài)所建立起來的子類型多態(tài)，你可以清楚地認(rèn)識到這種面向類型的觀點。如果你想理解子類型多態(tài)的思想，就應(yīng)該把注意力從實現(xiàn)的細(xì)節(jié)轉(zhuǎn)移到類型的上。類型把對象分成組，并且管理著這些對象的接口。類型的繼承層次結(jié)構(gòu)決定了實現(xiàn)多態(tài)所需的類型關(guān)系。 　　有趣的是，實現(xiàn)的細(xì)節(jié)并不影響子類型多態(tài)的層次結(jié)構(gòu)。類型決定了對象調(diào)用什么方法，而實現(xiàn)則決定了對象怎么執(zhí)行這個方法。也就是說，類型表明了責(zé)任，而負(fù)責(zé)實施的則是具體的實現(xiàn)。將實現(xiàn)和類型分離后，我們好像看到了這兩個部分在一起跳舞，類型決定了他的舞伴和舞蹈的名字，而實現(xiàn)則是舞蹈動作的設(shè)計師。

J2EE學(xué)習(xí)者越來越多，J2EE本身技術(shù)不斷在發(fā)展，涌現(xiàn)出各種概念，本文章試圖從一種容易理解的角度對這些概念向初學(xué)者進(jìn)行解釋，以便掌握學(xué)習(xí)J2EE學(xué)習(xí)方向。首先我們需要知道Java和J2EE是兩個不同概念，Java不只是指一種語言，已經(jīng)代表與微軟不同的另外一個巨大陣營，所以Java有時是指一種軟件系統(tǒng)的流派，當(dāng)然目前主要是.NET和Java兩大主流體系。

　　J2EE可以說指Java在數(shù)據(jù)庫信息系統(tǒng)上實現(xiàn)，數(shù)據(jù)庫信息系統(tǒng)從早期的dBase、到Delphi/VB等C/S結(jié)構(gòu)，發(fā)展到B/S（Browser瀏覽器/Server服務(wù)器）結(jié)構(gòu)，而J2EE主要是指B/S結(jié)構(gòu)的實現(xiàn)。

　　J2EE又是一種框架和標(biāo)準(zhǔn)，框架類似API、庫的概念，但是要超出它們。如果需要詳細(xì)了解框架，可先從設(shè)計模式開始學(xué)習(xí)。

　　J2EE是一個虛的大的概念，J2EE標(biāo)準(zhǔn)主要有三種子技術(shù)標(biāo)準(zhǔn)：WEB技術(shù)、EJB技術(shù)和JMS，談到J2EE應(yīng)該說最終要落實到這三個子概念上。

　　這三種技術(shù)的每個技術(shù)在應(yīng)用時都涉及兩個部分：容器部分和應(yīng)用部分，Web容器也是指Jsp/Servlet容器，你如果要開發(fā)一個Web應(yīng)用，無論是編譯或運行，都必須要有Jsp/Servlet庫或API支持（除了JDK/J2SE以外）。

　　Web技術(shù)中除了Jsp/Servlet技術(shù)外，還需要JavaBeans或Java Class實現(xiàn)一些功能或者包裝攜帶數(shù)據(jù)，所以Web技術(shù)最初裸體簡稱為Jsp/Servlet+JavaBeans系統(tǒng)。
談到JavaBeans技術(shù)，就涉及到組件構(gòu)件技術(shù)（component），這是Java的核心基礎(chǔ)部分，很多軟件設(shè)計概念（設(shè)計模式）都是通過JavaBeans實現(xiàn)的。

　　JavaBeans不屬于J2EE概念范疇中，如果一個JavaBeans對象被Web技術(shù)（也就是Jsp/Servlet）調(diào)用，那么JavaBeans就運行在J2EE的Web容器中；如果它被EJB調(diào)用，它就運行在EJB容器中。

　　EJB（企業(yè)JavaBeans）是普通JavaBeans的一種提升和規(guī)范，因為企業(yè)信息系統(tǒng)開發(fā)中需要一個可伸縮的性能和事務(wù)、安全機(jī)制，這樣能保證企業(yè)系統(tǒng)平滑發(fā)展，而不是發(fā)展到一種規(guī)模重新更換一套軟件系統(tǒng)。

　　至此，JavaBeans組件發(fā)展到EJB后，并不是說以前的那種JavaBeans形式就消失了，這就自然形成了兩種JavaBeans技術(shù)：EJB和POJO，POJO完全不同于EJB概念，指的是普通JavaBeans，而且這個JavaBeans不依附某種框架，或者干脆可以說：這個JavaBeans是你為這個應(yīng)用程序單獨開發(fā)創(chuàng)建的。

　　J2EE應(yīng)用系統(tǒng)開發(fā)工具有很多：如JBuilder、Eclipse等，這些IDE首先是Java開發(fā)工具，也就是說，它們首要基本功能是可以開發(fā)出JavaBeans或Java class，但是如果要開發(fā)出J2EE系統(tǒng)，就要落實到要么是Web技術(shù)或EJB技術(shù)，那么就有可能要一些專門模塊功能(如eclipse需要lomboz插件)，最重要的是，因為J2EE系統(tǒng)區(qū)分為容器和應(yīng)用兩個部分，所以，在任何開發(fā)工具中開發(fā)J2EE都需要指定J2EE容器。

　　J2EE容器分為WEB容器和EJB容器，Tomcat/Resin是Web容器；JBoss是EJB容器+Web容器等，其中Web容器直接使用Tomcat實現(xiàn)的。所以你開發(fā)的Web應(yīng)用程序可以在上面兩種容器運行，而你開發(fā)的Web+EJB應(yīng)用則只可以在JBoss服務(wù)器上運行，商業(yè)產(chǎn)品Websphere/Weblogic等和JBoss屬于同一種性質(zhì)。

　　J2EE容器也稱為J2EE服務(wù)器，大部分時它們概念是一致的。
如果你的J2EE應(yīng)用系統(tǒng)的數(shù)據(jù)庫連接是通過JNDI獲得，也就是說是從容器中獲得，那么你的J2EE應(yīng)用系統(tǒng)基本與數(shù)據(jù)庫無關(guān)，如果你在你的J2EE應(yīng)用系統(tǒng)耦合了數(shù)據(jù)庫JDBC驅(qū)動的配置，那么你的J2EE應(yīng)用系統(tǒng)就有數(shù)據(jù)庫概念色彩，作為一個成熟需要推廣的J2EE應(yīng)用系統(tǒng)，不推薦和具體數(shù)據(jù)庫耦合，當(dāng)然這其中如何保證J2EE應(yīng)用系統(tǒng)運行性能又是體現(xiàn)你的設(shè)計水平了。

　　衡量J2EE應(yīng)用系統(tǒng)設(shè)計開發(fā)水平高低的標(biāo)準(zhǔn)就是：解耦性；你的應(yīng)用系統(tǒng)各個功能是否能夠徹底脫離？是否不相互依賴，也只有這樣，才能體現(xiàn)可維護(hù)性、可拓展性的軟件設(shè)計目標(biāo)。

　　為了達(dá)到這個目的，誕生各種框架概念，J2EE框架標(biāo)準(zhǔn)將一個系統(tǒng)劃分為WEB和EJB主要部分，當(dāng)然我們有時不是以這個具體技術(shù)區(qū)分，而是從設(shè)計上抽象為表現(xiàn)層、服務(wù)層和持久層，這三個層次從一個高度將J2EE分離開來，實現(xiàn)解耦目的。

　　因此，我們實際編程中，也要將自己的功能向這三個層次上靠，做到大方向清楚，涇渭分明，但是沒有技術(shù)上約束限制要做到這點是很不容易的，因此我們還是必須借助J2EE具體技術(shù)來實現(xiàn)，這時，你可以使用EJB規(guī)范實現(xiàn)服務(wù)層和持久層，Web技術(shù)實現(xiàn)表現(xiàn)層；

　　EJB為什么能將服務(wù)層從Jsp/Servlet手中分離出來，因為它對JavaBeans編碼有強制的約束，現(xiàn)在有一種對JavaBeans弱約束，使用Ioc模式實現(xiàn)的（當(dāng)然EJB 3.0也采取這種方式），在Ioc模式誕生前，一般都是通過工廠模式來對JavaBeans約束，形成一個服務(wù)層，這也是是Jive這樣開源論壇設(shè)計原理之一。

　　由此，將服務(wù)層從表現(xiàn)層中分離出來目前有兩種可選架構(gòu)選擇：管理普通JavaBeans（POJO）框架(如Spring、JdonFramework)以及管理EJB的EJB框架，因為EJB不只是框架，還是標(biāo)準(zhǔn)，而標(biāo)準(zhǔn)可以擴(kuò)展發(fā)展，所以，這兩種區(qū)別將來是可能模糊，被納入同一個標(biāo)準(zhǔn)了?！〉?，個人認(rèn)為：標(biāo)準(zhǔn)制定是為某個目的服務(wù)的，總要犧牲一些換取另外一些，所以，這兩種架構(gòu)會長時間并存。

　　這兩種架構(gòu)分歧也曾經(jīng)誕生一個新名詞：完全POJO的系統(tǒng)也稱為輕量級系統(tǒng)(lightweight)，其實這個名詞本身就沒有一個嚴(yán)格定義，更多是一個吸引人的招牌，輕量是指容易學(xué)習(xí)容易使用嗎？按照這個定義，其實輕量Spring等系統(tǒng)并不容易學(xué)習(xí)；而且EJB 3.0（依然叫EJB）以后的系統(tǒng)是否可稱為輕量級了呢？
前面談了服務(wù)層框架，使用服務(wù)層框架可以將JavaBeans從Jsp/Servlet中分離出來，而使用表現(xiàn)層框架則可以將Jsp中剩余的JavaBeans完全分離，這部分JavaBeans主要負(fù)責(zé)顯示相關(guān)，一般是通過標(biāo)簽庫（taglib）實現(xiàn)，不同框架有不同自己的標(biāo)簽庫，Struts是應(yīng)用比較廣泛的一種表現(xiàn)層框架。

　　這樣，表現(xiàn)層和服務(wù)層的分離是通過兩種框架達(dá)到目的，剩余的就是持久層框架了，通過持久層的框架將數(shù)據(jù)庫存儲從服務(wù)層中分離出來是其目的，持久層框架有兩種方向：直接自己編寫JDBC等SQL語句（如iBatis）；使用O/R Mapping技術(shù)實現(xiàn)的Hibernate和JDO技術(shù)；當(dāng)然還有EJB中的實體Bean技術(shù)。

　　持久層框架目前呈現(xiàn)百花齊放，各有優(yōu)缺點的現(xiàn)狀，所以正如表現(xiàn)層框架一樣，目前沒有一個框架被指定為標(biāo)準(zhǔn)框架，當(dāng)然，表現(xiàn)層框架現(xiàn)在又出來了一個JSF，它代表的頁面組件概念是一個新的發(fā)展方向，但是復(fù)雜的實現(xiàn)讓人有些忘而卻步。

　　在所有這些J2EE技術(shù)中，雖然SUN公司發(fā)揮了很大的作用，不過總體來說：網(wǎng)絡(luò)上有這樣一個評價：SUN的理論天下無敵；SUN的產(chǎn)品用起來撞墻；對于初學(xué)者，特別是那些試圖通過或已經(jīng)通過SUN認(rèn)證的初學(xué)者，趕快擺脫SUN的陰影，立即開溜，使用開源領(lǐng)域的產(chǎn)品來實現(xiàn)自己的應(yīng)用系統(tǒng)。

　　最后，你的J2EE應(yīng)用系統(tǒng)如果采取上面提到的表現(xiàn)層、服務(wù)層和持久層的框架實現(xiàn)，基本你也可以在無需深刻掌握設(shè)計模式的情況下開發(fā)出一個高質(zhì)量的應(yīng)用系統(tǒng)了。

　　還要注意的是: 開發(fā)出一個高質(zhì)量的J2EE系統(tǒng)還需要正確的業(yè)務(wù)需求理解，那么域建模提供了一種比較切實可行的正確理解業(yè)務(wù)需求的方法，相關(guān)詳細(xì)知識可從UML角度結(jié)合理解。

　　當(dāng)然，如果你想設(shè)計自己的行業(yè)框架，那么第一步從設(shè)計模式開始吧，因為設(shè)計模式提供你一個實現(xiàn)JavaBeans或類之間解耦參考實現(xiàn)方法，當(dāng)你學(xué)會了系統(tǒng)基本單元JavaBean或類之間解耦時，那么系統(tǒng)模塊之間的解耦你就可能掌握，進(jìn)而你就可以實現(xiàn)行業(yè)框架的提煉了，這又是另外一個發(fā)展方向了。

public class statictest {
    public statictest()
    {   
    }
    public static void prin(String s)
    {
    System.out.println(s);
    }
    public static int i=printy("hehe");
    public static int printy(String s)
      {
          System.out.println(s);
          return 4;
       }
    public static void main(String[] args) {
        statictest.prin("fdsafa");
    }
}
輸出結(jié)果 hehe fdsafa
當(dāng)生成一個類的對象時,或者首次訪問屬于哪個類的靜態(tài)數(shù)據(jù)成員時,,進(jìn)行初始化.
package untitled4;
class teststatic
{
   static int i=prin("test");
   static int prin(String s)
   {
       System.out.println(s);
       return 2;
   }
   static void play()
   {
   System.out.println("play");
   }

}
public class statictest2 {
    public statictest2() {
    }

    public static void main(String[] args) {
      teststatic.play();
    }
}
輸出結(jié)果   TEST PLAY
對于類CLASS A的執(zhí)行相當(dāng)于調(diào)用A.main(),,他首先對A的元素初始化(遵循,從A的基類開始,STATIC)
非STATIC在對象生成時候才初始化

Static  :
對于類的屬性來說
有類變量和實例變量
class StaticTest
{  static int i=47;
}
對于不同的對象  StaticTest st1=new StaticTest(),StaticTest st2=new StaticTest()都只有一個共享的存儲空間!
引用Static變量有兩種方法.可以用一個對象去定位他。.也可以用其類名直接調(diào)用!
如果一個成員被聲明為static，他就能夠在他的類的對象被創(chuàng)建之前被訪問，不必引用任何對象。最常見的例子是main()方法，
static定義的變量會優(yōu)先于任何其它非static變量，不論其出現(xiàn)的順序如何;
Java變量在類這個級別分兩種，類變量（static）和實例變量，而在靜態(tài)的方法中不能夠直接訪問實例變量，實例變量需要初始化一個類的實例才可以用。


靜態(tài)的東西之所以有這種區(qū)分是為了區(qū)別對待類和對象的成員。如果某個變量或者方法被聲明為static，意味著在類初始化時就必須分配內(nèi)存空間。而方法調(diào)用內(nèi)部需要的變量既然是臨時的，會隨著方法調(diào)用結(jié)束而失效的，那么沒有道理讓它成為static的對吧

1.靜態(tài)變量屬于類,為該類所有對象所分享,在程序開始執(zhí)行前就分配內(nèi)存空間,其作用可以類似VB中的全局變量,如果前面加上final,功能類似全局常量,不可以修改其值.比如圓周率

2.類的靜態(tài)方法不能訪問類的實例變量,可以訪問類的靜態(tài)變量、實例化的類的實例變量

3.靜態(tài)方法中不能定義靜態(tài)變量的

前幾天在csdn上看了一篇關(guān)于static的帖子，看了之后感覺很多疑惑都澄清了，今天粘在這里。

public class ExplicitStatic{
  public static void main(String[] args){
    System.out.println("Inside main()");
      Cups.c1.f(99);
 }
 static Cups x=new Cups();
 static Cups y=new Cups();
}
class Cup{
      Cup(int marker){
         System.out.println("Cup("+marker+")");
      }
      void f(int marker){
         System.out.println("f("+marker+")");
      }
}
class Cups{
  static Cup c1=new Cup(11);
  static Cup c2;
  Cup c3=new Cup(33);
  Cup c4;
 { c3=new Cup(3);
   c4=new Cup(4);
 }
 static{
   c1=new Cup(1);
   c2=new Cup(2);
 }
 Cups(){
 System.out.println("Cups()");
  }
}
/*輸出結(jié)果：
cup(11)
cup(1)
cup(2)
cup(33)
cup(3)
cup(4)
cups()
cup(33)
cup(3)
cup(4)
cup()
inside main()
f(99)
*/
/*
首先初始化的是static，順序是代碼順序up-to-down！然后在是自己調(diào)用的方法！
上面的執(zhí)行順序是
1： static Cups x=new Cups(); 轉(zhuǎn)入 Cups對象
2： static Cup c1=new Cup(11); 轉(zhuǎn)入 Cup對象
3： 執(zhí)行Cup的輸出 Cup(11);
4:  cups對象里的 static Cup c2；
5： static{
   c1=new Cup(1);轉(zhuǎn)入Cup對象 輸出 Cup(1)
   c2=new Cup(2);轉(zhuǎn)入Cup對象 輸出 Cup(2)
 }
6: cups對象里的 Cup c3=new Cup(33); 輸出 Cup(33)
7：c3=new Cup(3); 輸出 Cup(3)
   c4=new Cup(4); 輸出 Cup(4)
8：Cups(){
 System.out.println("Cups()"); 輸出 Cups()
  }
9:static Cups y=new Cups();
 注意Cups里的static成員已經(jīng)初始化 所以 static Cup c1=new Cup(11);
 static Cup c2;static{
   c1=new Cup(1);
   c2=new Cup(2);
 }
 不在執(zhí)行！
下面的就和上面一樣了！
*/

首次使用的地方也是static初始化發(fā)生的地方。裝載的時候，所有static對象和static代碼塊都會按照本來的順序初始化（亦即它們在類定義代碼里寫入的順序）。當(dāng)然，static數(shù)據(jù)只會初始化一次。

程序一開始訪問MAIN方法,然后開始一加載對應(yīng)的CLASS文件,如果他具有基類,加載基類,最后完成STATIC的初始化,

對于繼承,static :hide;non static :override.
  
關(guān)鍵字:包訪問權(quán)
當(dāng)屬性或方法前不聲明訪問權(quán)是默認(rèn)為包訪問權(quán).
具有包訪問權(quán)的方法或者屬性只能被同一個包內(nèi)的其他類訪問.
處于相同目錄的類之間具有默認(rèn)的包訪問權(quán)限.即可以訪問其他文件的包訪問權(quán)限方法.
//處于不同包類不能訪問具有包訪問權(quán)限的方法或?qū)傩?
package animal;
public class animal
{
 void bite()
 {
 System.out.println("bite");
 }
}
package test;
import animal.*;
public class test
{
   public static void main(String args[])
   {

       animal animal=new animal();
       animal.bite();//因為bite()只具有包訪問權(quán)
}
}
// 處于相同目錄的類之間具有默認(rèn)的包訪問權(quán)限.即可以訪問其他文件的包訪問權(quán)限方法.
public class test
{
   public static void main(String args[])
   {
   animal animal=new animal();
   animal.bite();
  }
}
public class test
{
   public static void main(String args[])
   {
   animal animal=new animal();
   animal.bite();
  }
}

package test;
import animal.*;
public class dog extends animal    繼承但是不屬于同一個包
{
   public static void main(String args[])
   {
      dog dog=new dog();
      dog.bite();//bite只是具有包訪問權(quán)

   }
}
PROTECTED 關(guān)鍵字:繼承訪問權(quán)限! 
導(dǎo)出類可以使用在基類定義為PROTECTED的方法,對于同一個包的非繼承關(guān)系類具有包訪問權(quán)!
在同一個包中，可以通過在子類中超類的實例來訪問超類的protected變量，而不在同一個包中，就不能這樣做
protected 指定該變量可以被同一個包中的類或其子類訪問，但是不能通過超類的實例來實現(xiàn)，在子類中可以覆蓋此變量
public class animal
{
 protected void bite()
 {
System.out.println("bite");
 }
}
public class test
{
   public static void main(String args[])
   {
   animal animal=new animal();
   animal.bite();
  }
}
導(dǎo)出類可以使用基類的PROTECTED方法
package animal;
public class animal
{
 protected void bite()
 {
 System.out.println("bite");
 }
}

package test;
import animal.*;
public class dog extends animal
{
   public static void main(String args[])
   {
      dog dog=new dog();
      dog.bite();//bite只是具有包訪問權(quán)
}
}
Private關(guān)鍵字
具有Private關(guān)鍵字的方法只能被定義該方法的內(nèi)部
public class animal
{
  private String s="fasf";
  private void test()
  {}
 protected void bite()
 { System.out.println("bite");}
}
public class test
{
   public static void main(String args[])
   {
   animal animal=new animal();
   //animal.s="fafaf";  can not access private
  // animal.test();    can not access private 
   animal.bite();
  }
}
//私有構(gòu)造函數(shù)
class privatetest
{
    private privatetest()
    {}
    public static privatetest make()
    {
    return new privatetest();
    }
    public void f()
    {
  System.out.println("success");
 }
}
public class test
{
   public static void main(String srgs[])
   {
       privatetest pt=privatetest.make();
       pt.f();
 }
}
類的訪問權(quán)限  類的訪問權(quán)限只能是缺省或者是"public"
//包訪問權(quán)限:
package animal;
 class animal
{
 protected void bite()
 { System.out.println("bite");}
}
package test;
import animal.*;
public class test
{
   public static void main(String args[])
   {  animal animal=new animal();  // can  not access from outside package;
       animal.bite();//因為bite()只具有包訪問權(quán)
     }
}

JAVA事件的總結(jié)（轉(zhuǎn)）- -

                                      

在阿泠的自省上看到的文章，雖然我現(xiàn)在還沒有看到事件，不過先收錄過來^_^。

JAVA事件無非就是鍵盤事件，鼠標(biāo)事件，按鈕等事件。專業(yè)點可以分為語義事件（按鈕等到事件）和低層事件（鍵盤事件，鼠標(biāo)事件）；

下面我簡要的總結(jié)一下：

1、鼠標(biāo)事件：點鼠標(biāo)按鈕事它會調(diào)用三個監(jiān)聽器方法：mousePressed,mouseReleased,mouseClicked.

鼠標(biāo)事件提供了mousePressed,mouseClicked,mouseDragged,mouseEntered,mouseExited， mouseUp，mouseDown，mouseDrag等事件。下面介紹一個鼠標(biāo)一例子：
import java.awt.*;
import java.applet.Applet;
public class CountClick extends Applet
{int CurrentMarks=0;
int a,b;
 public boolean mouseDown(Event evt,int x,int y)//鼠標(biāo)按下時做的事
 { CurrentMarks++;//計錄按下次數(shù)
   repaint();//刷新面版
   a=x;//得到鼠標(biāo)的橫坐標(biāo)
   b=y;//得到鼠標(biāo)的豎坐標(biāo)
   return true;
 }
 public void paint(Graphics g)
 { g.drawString(" "+CurrentMarks,10,10);//打印按下次數(shù)
   g.drawString(" "+a,10,30);//打印鼠標(biāo)的橫坐標(biāo)
   g.drawString(" "+b,10,20);//打印鼠標(biāo)的堅坐標(biāo)
 }
}
//<applet code="CountClick.class" width="200" height="100"></applet>      

      
   2、鍵盤事件：如果我們希望使用鍵盤獲得輸入信息，就必須處理鍵盤事件。我們可以用在Conponent的keyDown來實現(xiàn)。如下例子：
import java.applet.Applet;import java.awt.*;
{   char Presskey;
     public boolean keyDown(Event evt, int key)
     {   Presskey=(char)key;//記錄你按下的鍵
     repaint(); return true;
}
      public void paint(Graphics g)
     {    g.drawString(Presskey,10,10); }//打印你按下的鍵值
}
   3、銨鈕等事件：這方面的內(nèi)容比較多，通過一個例子做一個簡單的介紹。

//*******注意Repaint()方法的使用******//
//**通過本程序?qū)AVA的數(shù)據(jù)隱藏有了一近一步的了解***///

import java.awt.*;
import java.applet.Applet;
import java.awt.event.*;
public class Awtactiontest2 extends Applet implements ItemListener ,ActionListener
//實現(xiàn)ItemListener ,ActionListener接口
{
 int num = 5;
  Choice ch=new Choice ();
 Button one=new Button("one");
 Button two=new Button("two"); 
 Button three=new Button("three");
 Image  aa[];
 Image  a;
 public void init()
 {
        aa = new Image[num];
        for(int i = 0; i < num; i++)//把圖片的路徑加到數(shù)組中存儲
        {
            aa[i] = getImage(getdocument．a(chǎn)se(),"A"+(i+1)+".JPG");
        }
        num=4;//給一個初值
 this.setBackground(Color.white);
 ch. addItem("A1.JPG" );
 ch. addItem ("A2.JPG" );
 ch. addItem ("A3.JPG" );
 ch. addItem ("A4.JPG" );
 add (ch);
 a = getImage(getdocument．a(chǎn)se(),"A1.JPG");//對a一個初值；
 add (one);
 add (two);
 add (three);
 ch.addItemListener(this);//注意把ItemListener接口implements進(jìn)來
 one.addActionListener(this);//注意把ActionListener接口implements進(jìn)來
 two.addActionListener(this);
 three.addActionListener(this);
 }
public void itemStateChanged (ItemEvent e)
  {
   
    a = getImage(getdocument．a(chǎn)se(),ch.getSelectedItem ());
    repaint();
  }
 public void actionPerformed(ActionEvent e)
 {
 if(e.getSource()==one)
 {
        num=1;
        repaint();//對程序刷新
 }
 if(e.getSource()==two)
 {
        num=2;
        repaint();
 }
 if(e.getSource()==three)
 {
        num=3;
        repaint();
 }
 }
 public void paint(Graphics g)
 {
        //g.drawImage(aa[i],0,0,this);
     
  int w=a.getWidth(this);
  int h=a.getHeight(this);
 // g.drawLine(100,1,200,500);
 try{ 
 g.drawImage(a,20,300,10+w,20+h,this);//要抓異常，如果圖片找不到呢
 g.drawImage(aa[num],50,50,200,200,this);
 }
 catch(Exception e)
 {
  System.out.println(e);
 }
  }
 public boolean handleEvent(Event ewt)//關(guān)窗體,我原以為這個可以把死循環(huán)給關(guān)了，其它不然.一樣的關(guān)不了程序
 {
         if(ewt.id==Event.WINDOW_DESTROY)
          System.exit(0);
          else 
          return super.handleEvent(ewt);
          return true;
 }
}
//<Applet code="Awtactiontest2.class" width=400 height=500></applet>

第2章 萬事萬物皆對象

一．所有對象都必須由你建立
1． 存儲在哪里
1. 寄存器：我們在程序中無法控制
2. stack：存放基本類型的數(shù)據(jù)和對象的reference，但對象本身不存放在stack中，而是存放在Heap中
3. Heap：存放用new產(chǎn)生的數(shù)據(jù)
4. Static storage：存放在對象中用static定義的靜態(tài)成員
5. Constant storage：存放常量
6. NON-RAM：硬盤等永久存儲空間
2． 特例：基本型別
基本類型數(shù)據(jù)存放在Stack中，存放的是數(shù)據(jù)。而產(chǎn)生對象時，只把對象的reference存放在stack中，用于指向某個對象，對象本身存放在Heap中。
3． Java中的數(shù)組
當(dāng)你產(chǎn)生某個存儲對象的數(shù)組時，真正產(chǎn)生的其實是存儲reference的數(shù)組。引數(shù)組建立后，其中的每一個reference都會被自動設(shè)為null，表示"不指向任何對象"。
二．建立新的數(shù)據(jù)型別：class
1． 數(shù)據(jù)成員和函數(shù)
1.1 基本成員的缺省值
1） 當(dāng)class的某個成員屬于基本型別時，即使你沒有為它提供初值，Java仍保證它有一個缺省值。
2） 只有當(dāng)變量身份是"class內(nèi)的成員時，Java才保證為該變量提供初值。
三．函數(shù)（Mehtods），引數(shù)（arguments），返回值（return values）
1． 引數(shù)列
當(dāng)引數(shù)傳遞的是對象時，傳遞的是對象的reference。
四．注解用內(nèi)嵌式文檔
Java提供兩種注解風(fēng)格：/*XXXX*/、//XXXX

第3章 控制程序流程

一．使用Java運算符
1.關(guān)系運算符
1.） 當(dāng)對兩個對象運用關(guān)系運算符進(jìn)行比較時，比較的是object reference，如：

Integer n1 = new Integer(3);
Integer n2 = new Integer(3);
System.out.println(n1==n2);

結(jié)果為false，因為兩個object reference（n1和n2）值是不同的
2） equals()的缺省行為也是拿referenct來比較。不過Java中的class覆寫了equals方法(覆寫時一般先做instanceof的比較，然后在做期望的值的比較，如Integer期望的比較值就是其數(shù)值)，如：

Integer n1 = new Integer(3);
Integer n2 = new Integer(3);
System.out.println(n1.quals(n2));//值為true

2． 邏輯運算符
1） 只能將and、or、not施用于boolean值身上。如果邏輯運算符兩邊的值存在non-boolean值，將會出錯，如：

int test1 = 1;
System.out.println((test && 1<2);//編輯出錯，test是non-boolean值

3． 位移運算符
如果所操作的位移對象是char、byte、short，位移動作發(fā)生之前，其值會先被晉升為int，運算結(jié)果會是int。
二．流程控制
1． 迭代（iteration）
1.1 逗號運算符
逗號運算符只能用于for循環(huán)的控制表達(dá)式中的initialization和step兩部分中，如：for(int i=0, j=I+1; I<5; i++, j=I*2)
1.2 break和continue
break表示退出循環(huán)；continue表示退出本次循環(huán)，回來循環(huán)起始位置。
1.3 label
label只有放在迭代語句之前才起作用，在label和迭代語句之間插入任何語句都不會起作用。
2． Switch
switch中的選擇器必須是int或char型，而且每個case段都應(yīng)該break，否則不管是否匹配，將按代碼順序執(zhí)行每個case段的代碼。如：

char c='c';
switch (c){

  case 'a':System.out.println("a");break;//如果不break將繼續(xù)執(zhí)行下面的case 'b',case 'c',default等段

  case 'b':System.out.println("b");break;

  default:System.out.println("default");break;

  case 'c':System.out.println("c");break;

}

3． 計算細(xì)節(jié)
1） 從float或double轉(zhuǎn)為整數(shù)值，總是以完全舍棄小數(shù)的方式進(jìn)行。
2)   默認(rèn)情況帶小數(shù)的為double型，如：1.23應(yīng)該是double型，如果你想要float型的話得寫為 1.23f 或 1.23F。
4． Math.random()的輸出范圍是[0, 1)。

第4章 初始化和清理

一．以構(gòu)造函數(shù)（constructor）確保初始化的進(jìn)行
如果某個class具備構(gòu)造函數(shù)，Java便會在對象生成之際，使用者有能力加以操作之前，自動調(diào)用其構(gòu)造函數(shù)，于是便能名確保初始化動作一定被執(zhí)行。
二．函數(shù)重載（Method overloading）
1． 區(qū)分重載函數(shù)
由于只能從函數(shù)名和函數(shù)的引數(shù)列來區(qū)分兩個函數(shù)，而重載函數(shù)具有相同的函數(shù)名稱，所以每個重載函數(shù)都必須具備獨一無二的引數(shù)列。
2． Default構(gòu)造函數(shù)
1） default構(gòu)造函數(shù)是一種不帶任何引數(shù)的構(gòu)造函數(shù)。如果你所開發(fā)的class不具任何構(gòu)造函數(shù)，編譯器會自動為你生成一個default構(gòu)造函數(shù)。
2） 如果你自行定義了任何一個構(gòu)造函數(shù)（不論有無引數(shù)），編譯器就不會為你生成default構(gòu)造函數(shù)。
3） 如果定義了一個class，如

class Bush{
  Bush(int I){}
}

當(dāng)想用new Bush();來產(chǎn)生class的實例時，會產(chǎn)生錯誤。因為在定義class時已定義了構(gòu)造函數(shù)，所以編譯器就不會為class生成default構(gòu)造函數(shù)。當(dāng)我們用new Bush()來產(chǎn)生實例時，會嘗試調(diào)用default構(gòu)造函數(shù)，但在class中沒有default構(gòu)造函數(shù)，所以會出錯。如：

class Sundae
{
    Sundae(int i) {}
}
public class IceCream
{
    public static void main(String[] args)
{
			//Sundae x = new Sundae();會編譯出錯，無構(gòu)造函數(shù)Sundae()
        Sundae y = new Sundae(1);
    }
}

＊：在定義一個class時，如果定義了自己的構(gòu)造函數(shù)，最好同時定義一個default構(gòu)造函數(shù)
3． 關(guān)鍵字this
1） this僅用于函數(shù)之內(nèi)，能取得"喚起此一函數(shù)"的那個object reference。
2） 在構(gòu)造函數(shù)中，通過this可以調(diào)用同一class中別的構(gòu)造函數(shù)，如

public class Flower{
		Flower (int petals){}
		Flower(String ss){}
		Flower(int petals, Sting ss){
		//petals++;調(diào)用另一個構(gòu)造函數(shù)的語句必須在最起始的位置
this(petals);
		//this(ss);會產(chǎn)生錯誤，因為在一個構(gòu)造函數(shù)中只能調(diào)用一個構(gòu)造函數(shù)
		}
}

＊＊：1）在構(gòu)造調(diào)用另一個構(gòu)造函數(shù)，調(diào)用動作必須置于最起始的位置
2）不能在構(gòu)造函數(shù)以外的任何函數(shù)內(nèi)調(diào)用構(gòu)造函數(shù)
3）在一個構(gòu)造函數(shù)內(nèi)只能調(diào)用一個構(gòu)造函數(shù)
4． Static的意義
無法在static函數(shù)中調(diào)用non-static函數(shù)（反向可行）。為什么不能呢，我們看下面的例子。
例4.2.4.1
假設(shè)能在static函數(shù)中調(diào)用non-static函數(shù)，那么（a）處就將出錯。因為在沒有產(chǎn)生Movie class實例之前，在就不存在Movie class內(nèi)的name實例，而在getName()中卻要使用name實例，顯然的錯誤的。

class Movie{
	String name = "";
	Movie(){}
	public Movie(String name) { this.name = name; }
	public static String getName() { return name; }
}
public class Test{
	public static void main(String[] args){
		//下面兩名先產(chǎn)生實例后再調(diào)用getName()沒有問題
		//Movie movie1 = new Movie("movie1");
		//String name1 = movie1.getName();
		//下面一名將出錯
		//String name2 = Movie.getname(); （a）
	}
}

三．清理（cleanup）：終結(jié)（finalization）與垃圾回收（garbage collection）
1）你的對象可能不會被回收
只有當(dāng)程序不夠內(nèi)存時，垃圾回收器才會啟動去回收不再被使用的對象的內(nèi)存空間。某個對象所占用的空間可能永遠(yuǎn)不會被釋放掉，因為你的程序可能永遠(yuǎn)不會逼近內(nèi)存用完的那一刻，而垃圾回收器完全沒有被啟動以釋放你的對象所占據(jù)的內(nèi)存，那些空間便會在程序終止時才一次歸還給操作系統(tǒng)
3） 只有在采用原生函數(shù)（native methods）時，才使用finalize()。

四．成員初始化（member initialization）
1） 函數(shù)中的變量不會被自動初始化，如

void f(){
		int i;
		i++;
}

將發(fā)生編譯錯誤，因為i沒有被初始化。
2） class的數(shù)據(jù)成員會被自動初始化，具體情況如下（見P220例子）：
基本型別：boolean：false、char：null（\u0000）、byte：0、short：0、int：0、
long：0 、float：0、double：0
對象（reference）：null

五． 初始化次序：
1） 所有變量一定會在任何一個函數(shù)（甚至是構(gòu)造函數(shù)）被調(diào)用之前完成初始化（見P233例子）
2） 在產(chǎn)生一個class的對象（包含static成員的class的代碼被裝載）時，首先自動按代碼排列順序初始化class中的static成員變量或static block，所有這些初始化操作只在第一次生成該對象時進(jìn)行。
3） 自動初始化class中的其它成員變量或non-static block。
4） 調(diào)用構(gòu)造函數(shù)。
例：

class Cup{
	Cup(int marker){
		System.out.println("Cup(" + marker + ")");
	}
	void f(int marker){
		System.out.println("f(" + marker + ")");	
	}	
}

class Cups{
	static Cup c1 = new Cup(11);
	static Cup c2;
    Cup c3 = new Cup(33); 
    Cup c4;
    {
        c3 = new Cup(3);
        c4 = new Cup(4);
    }
	static{
		c1 = new Cup(1);
		c2 = new Cup(2);
	}
	Cups(){
		System.out.println("Cups()");
	}
}

public class ExplicitStatic{
	public static void main(String[] args){
		System.out.println("Inside main()");
		Cups.c1.f(99);
	}
	static Cups x = new Cups();
	static Cups y = new Cups();
}

結(jié)果為：
Cup(11)
Cup(1)
Cup(2)
Cup(33)
Cup(3)
Cup(4)
Cups()
Cup(33)
Cup(3)
Cup(4)
Cups()
Inside main()
f(99)
2． Array的初始化
1） 定義數(shù)組時不能指定大小。如int[4] iArr = {0, 1, 2, 3};，由于指定了數(shù)組的大小，會編譯出錯。
2） 數(shù)組只是存放reference的數(shù)組。Array與non-array的結(jié)構(gòu)圖如下：
a）對于基本型別數(shù)據(jù)，存放的是數(shù)據(jù)。如
int i = 5;

b）對于class變量，存放的是reference，這個reference指向一個存有class實例的內(nèi)存空間。如

String s = "hello";

變量s存放的是一個reference，這個reference指向一個存有String實例的內(nèi)存空間。
c）對于基本型別數(shù)組，存放的是reference數(shù)組，數(shù)組中的每一個reference都指向一個class實例的內(nèi)存空間。如

int[] ia = {10, 11, 12};

數(shù)組ia存放的是一個reference數(shù)組，數(shù)組中的每一個reference都指向一個的int實例的內(nèi)存空間。
d）對于class數(shù)組，存放的是reference數(shù)組，數(shù)組中的每一個reference都指向一個的class實例的內(nèi)存空間。如

String[] sa = {"hello1", "hello2", "hello3"}; 

數(shù)組sa存放的是一個reference數(shù)組，數(shù)組中的每一個reference都指向一個的String實例的內(nèi)存空間。
3） 任何數(shù)組都要進(jìn)行初始化，使用沒有進(jìn)行初始化的數(shù)組會產(chǎn)生運行時錯誤，如：

int[] iArr;
System.out.pritnln(iArr[0]);//產(chǎn)生錯誤，因為iArr還未初始化

數(shù)組初始化可在任何地方，可用以下方法來對數(shù)組進(jìn)行初始化：
a） int[] iArr = {1,1,1,1};//數(shù)組的長度為{}元素的個數(shù)
b） int i = 10;

int[] iArr = new int[i];//數(shù)組的長度可為變量（這在C/C++中不行）
System.out.println(iArr[0]);//iArr[0]是一個int，自動初始化值為0
Integer[] iArr2 = new Integer[i];
System.out.println(iArr2[0]);//iArr[0]是一個reference，自動初始為null

I） 對于基本型別數(shù)組，new產(chǎn)生的是用于存放數(shù)據(jù)的數(shù)組；否則，產(chǎn)生的只是存放reference的數(shù)組。
II） new可用來初始化基本型別的數(shù)組，但不能產(chǎn)生non-array的　　基本型別數(shù)據(jù)。
c） int[] iArr = new int[]{1,1,1,1};

Integer[] iArr2 = new Integer[]{new Integer(1), new Integer(2)};

3． 多維數(shù)組（Multidimensional）arrays
多維數(shù)組每一維的大小可以不一樣，如：

Integer[][][] a5;
a5 = new Integer[3];
for(int i=0; i<a5.length; i++)
   a5[i] = new Integer[i+1];
   for(int j=0; j<a5[i].length
       a5[i][j] = new Integer[i+j+1];

Think In Java讀書筆記－1（第5——7章）- -

                                      

第5章 隱藏實現(xiàn)細(xì)節(jié)

一．Java訪問權(quán)限飾詞（access specifiers）
Java有public、protect、friendly、private四種訪問權(quán)限，并且這四訪問權(quán)限的訪問范圍越來越小。
1． friendly
1） 果一個class內(nèi)的數(shù)據(jù)成員或方法沒有任何權(quán)限飾詞，那么它的缺省訪問權(quán)限就是friendly。同一個package內(nèi)的其它所有classes都可以訪問friendly成員，但對package以外的classes則形同private。
2）　　對于同一個文件夾下的、沒有用package的classes，Java會自動將這些classes初見為隸屬于該目錄的default package，可以相互調(diào)用class中的friendly成員。如以下兩個class分別在同一個文件夾的兩個文件中，雖然沒有引入package，但隸屬于相同的default package。

class Sundae{
		//以下兩個方法缺省為friendly
    		Sundae(){}
		Void f() {System.out.println("Sundae.f()");
}
public class IceCream{
    		public static void main(String[] args){
			Sundae x = new Sundae();   
			x.f();
    		}
}

2． public：可以被任何class調(diào)用
3． private：private成員只能在成員所屬的class內(nèi)被調(diào)用，如：

class Sundae{
    private Sundae(){}//只能在Sundae class中被調(diào)用
    Sundae(int i) {}
    static Sundae makASundae()    {
        return new Sundae();
    }
}
public class IceCream{
    public static void main(String[] args){
        // Sundae class中構(gòu)造函數(shù)Sundae()是private，
        // 所以不能用它進(jìn)行初始化
        //Sundae x = new Sundae();
        Sundae y = new Sundae(1);//Sundae(int)是friendly，可以在此調(diào)用
        Sundae z = Sundae.makASundae();
    }
}

4． protected：具有friendly訪問權(quán)限的同時，又能被subclass（當(dāng)然包括子孫類，即子類的子類）所訪問。即，既能被同一package中的classes訪問，又能被protected成員所在class的subclass訪問。

二．Class的訪問權(quán)限
1．Class同樣具有public、protect、friendly、private四種訪問訪問權(quán)限：
1）public：在任何地方都可被使用
2）protect、private：除了它自己，沒有任何class可以使用，所以class不能是
protected或private（inner class除外）
3） friendly：同一個package中的classes能用
2． 如何調(diào)用構(gòu)造函數(shù)被聲明為private的class
1） 用static函數(shù)
2） 用Singteton模式

class Soup{
	private Soup(){}
 	//（1）靜態(tài)函數(shù)方法
		public static Soup makeSout(){
			return new Soup();
		}
     //（2）The "Singleton" pattern:
     private static Soup ps1 = new Soup();
     public static Soup access(){
         return ps1;
     }
     public void f(String msg){
         System.out.println("f(" + msg + ")");
     }
 }
 public class Lunch{
     public static void main(String[] args){
         //Soup priv1 = new Soup();編譯錯誤
         Soup priv2 = Soup.makeSout();
         Soup priv3 = Soup.access();
         priv2.f("priv2");
         priv3.f("priv3");
     }

第6章 重復(fù)運用classes

一．繼承（inheritance）
1． 在derived class中overriding某個函數(shù)時，只能覆寫base class中的接口，即base class中的public或protected或friendly函數(shù)。如果試圖overriding一個private函數(shù)，雖然編譯通過，但實際上你只是在derived class中添加了一個函數(shù)。如

class Cleanser{    
     private void prt(){//（b）
        System.out.println("Cleanser.prt()");
    }
 }
public class ExplicitStatic extends Cleanser{
    public void prt(){
        System.out.println("ExplicitStatic.prt()");
    }
    public static void main(String[] args){
        Cleanser x = new ExplicitStatic();
        x.prt();//（a）
    }
}

因為Cleanser中的prt()是private，所以不能在其derived　class中被覆寫。ExplicitStatic中的prt()只是ExplicitStatic中的一個函數(shù)，所以當(dāng)試圖在（a）處通過多態(tài)來調(diào)用prt()時，會發(fā)生錯誤。如果把（b）處的private去掉，則結(jié)果為
ExplicitStatic.prt()
2． Super的使用
1）通過關(guān)鍵字super可以調(diào)用當(dāng)前class的superclass（父類）。
例6.1.1.1

class Base{
    Base(){System.out.println("Base()");}
    public void scrub() { System.out.println(" Base.scrub()"); }
}
class Cleanser extends Base{
    private String s = new String("Cleanser");
    public void append(String a) { s+=a; }
    public void dilute() { append(" dilute()"); }
    public void apply() { append(" apply()"); }
    public void scrub() { append(" scrub()"); }
    public void print() { System.out.println(s); }
    Cleanser(){
        System.out.println("Cleanser(): " + s);
    }
    public static void testStatic(){
        System.out.println("testStatic()");
    }
    public static void main(String[] args){
        Cleanser x = new Cleanser();
        x.dilute(); x.apply(); x.scrub(); x.print();
    }
 }
public class ExplicitStatic extends Cleanser{
    ExplicitStatic(){
        System.out.println("ExplicitStatic()");
    }
    public void scrub(){
        append(" Detergen.scrub()"); 
        super.testStatic();
        super.scrub();//調(diào)用的是Cleanser.scrub()
    }
    public void foam() { append(" foam()"); }
    public static void main(String[] args){
        ExplicitStatic x = new ExplicitStatic();
        x.dilute(); x.apply(); x.scrub(); x.foam();
        x.print(); System.out.println("Test base class:");
        Cleanser.main(args);   
        testStatic();
    }
}

運行結(jié)果：
Base()
Cleanser(): Cleanser
ExplicitStatic()
testStatic()
Cleanser dilute() apply() Detergen.scrub() scrub() foam()
Test base class:
Base()
Cleanser(): Cleanser
Cleanser dilute() apply() scrub()
testStatic()
2）通過super來調(diào)用superclass中的成員時，調(diào)用的是最近成員。
例6.1.1.2

class Base{
    protected String baseS = "Base";//（a）
    //private String baseS = "Base";
    Base(){System.out.println("Base()");}
}
class Cleanser extends Base{
    protected String baseS = "Cleanser";//（b）
    public String s = new String("Cleanser");
    Cleanser(){
        System.out.println("Cleanser(): " + s);
    }
    Cleanser(String a){
        System.out.println("Cleanser(" + a + "): s = " + s );
    }
 }
public class ExplicitStatic extends Cleanser{
    String s2 = s;
    String baseS = super.baseS; //（c）
    ExplicitStatic(){
        super("ExplicitStatic");
        System.out.println("ExplicitStatic():s2 = " + s2 + ", baseS = "
+ baseS + "super.baseS = " + super.baseS); 
baseS = "ExplicitStatic";
System.out.println("baseS = " + baseS + " , super.baseS = " + super.baseS);
}
public static void main(String[] args){
ExplicitStatic x = new ExplicitStatic();
}
}

結(jié)果1：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Cleanser,super.baseS = Cleanser
baseS = ExplicitStatic , super.baseS = Cleanser
在上面例子中，在三個class中都存在String bases實例。在ExplicitStatic中如果直接調(diào)用baseS，則實際調(diào)用的是當(dāng)前類ExplicitStatic中的baseS（即（c）處的成員）；如果通過super.bases來調(diào)用baseS，則調(diào)用的是離當(dāng)前類ExplicitStatic最近的baseS成員，即Cleanser class中的baseS實例（即（b）處），產(chǎn)生的結(jié)果如結(jié)果1所示。如果把（b）處語句注釋掉，則將調(diào)用Base class中的baseS，結(jié)果如結(jié)果2所示。
結(jié)果2：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Base,super.baseS = Base
baseS = ExplicitStatic , super.baseS = Base
3． Base class的初始化
2.1 當(dāng)你產(chǎn)生derived class對象時，其中會包含base class子對象（subobject）。這個子對象就和你另外產(chǎn)生的base class對象一模一樣。
2.2 通過super()可調(diào)用base class的構(gòu)造函數(shù)，但必須放在構(gòu)造函數(shù)的第一行，并且只能在構(gòu)造函數(shù)中運用。
2.3 初始化順序為：
1） 加載代碼（.class文件）
2） 初始化class的靜態(tài)成員，初始化順序了"從里到外"，即從base　class開始。
3） 在derived class的構(gòu)造函數(shù)中調(diào)用base class的構(gòu)造函數(shù)。
如果在derived class的構(gòu)造函數(shù)中沒有通過super()顯式調(diào)用調(diào)用base class的構(gòu)造函數(shù)，編譯器會調(diào)用bass class的default構(gòu)造函數(shù)并自動生成相應(yīng)的調(diào)用語句，從而產(chǎn)生一個base class實例。如果在derived class的構(gòu)造函數(shù)中通過super()顯示調(diào)用了父類的構(gòu)造函數(shù)，則調(diào)用所指定的構(gòu)造函數(shù)。調(diào)用構(gòu)造函數(shù)的調(diào)用順序是"從里到外"。
4） 調(diào)用derived class的構(gòu)造函數(shù)。
＊＊：當(dāng)base class沒有default構(gòu)造函數(shù)時，必須在derived class的構(gòu)造函數(shù)中通過super顯示調(diào)用base class的構(gòu)造函數(shù)。
例：下面代碼的初始化過程為：
1） 裝載ExplicitStatic的代碼（裝載ExplicitStatic.class文件）。
2） 發(fā)現(xiàn)ExplicitStatic有關(guān)鍵字extends，裝載ExplicitStatic的base　class的代碼（裝載Cleanser.class文件）。
3） 發(fā)現(xiàn)Cleanser有關(guān)鍵字extends，裝載Cleanser的base　class的代碼（裝載Base.class文件）。
4） 初始化Base class中的靜態(tài)成員。
5） 初始化Cleanser class中的靜態(tài)成員。
6） 初始化ExplicitStatic class中的靜態(tài)成員。
如果把（c）處的代碼注釋掉，那么初始化工作到此就結(jié)束了。
7） 為ExplicitStatic對象分配存儲空間，并把存儲空間初始化為0。
8） 在ExplicitStatic class的構(gòu)造中調(diào)用super("ExplicitStatic")（在ExplicitStatic class的構(gòu)造函數(shù)中顯式調(diào)用父類的構(gòu)造函數(shù)），試圖產(chǎn)生一個Cleanser class實例。
9） 為Cleanser對象分配存儲空間，并把存儲空間初始化為0。
10） 由于Cleanser class又是繼承自Base class，會在Cleanser class的構(gòu)造函數(shù)中通過super()（由于沒有顯式調(diào)用父類的構(gòu)造函數(shù)，所以自動調(diào)用父類的default構(gòu)造函數(shù)）調(diào)用父類的構(gòu)造函數(shù)，試圖產(chǎn)生一個Cleanser class實例。
11） 產(chǎn)生一個Base class實例。先初始化成員變量，再調(diào)用構(gòu)造函數(shù)。
12） 回到Cleanser class，產(chǎn)生一個實例。首先初始化Cleanser class中的成員數(shù)據(jù)，再執(zhí)行構(gòu)造函數(shù)Cleanser(String a)中的其余部分。
13） 回到ExplicitStatic class，產(chǎn)生一個實例。首先初始化ExplicitStatic class中的成員數(shù)據(jù)，再執(zhí)行構(gòu)造函數(shù)ExplicitStatic ()中的其余部分（System.out.println("ExplicitStatic()")）。
class Base{
    static int s1 = prt("s1 initialized.", 11);
    int i1 = prt("i1 initialized.", 12);
    Base(){
        System.out.println("Base()");
        System.out.println("s1 = " + s1 + " ,i1 = " + i1);
        draw();//（d）
    }
    void draw(){
        System.out.println("base.draw：s1 = " + s1 + " ,i1 = " + i1);
    }
    static int prt(String s, int num) {
        System.out.println(s);
        return num;
    }
}
class Cleanser extends Base{
    static int s2 = prt("s2 initialized.", 21);
    int i2 = prt("i2 initialized.", 22);
    Cleanser(){
        System.out.println("Cleanser()");
        System.out.println("s2 = " + s2 + " ,i2 = " + i2);
    }
    Cleanser(String a){
        //super();（b）
        System.out.println("Cleanser(" + a + ")");
        System.out.println("s2 = " + s2 + " ,i2 = " + i2);
    }
    
    void draw(){
        System.out.println("Cleanser.draw：s2 = " + s2 + " ,i2 = " + i2);
    }
 }
public class ExplicitStatic extends Cleanser{
    static int s3 = prt("s3 initialized.", 31);
    int i3 = prt("i3 initialized", 31);
    ExplicitStatic(){
        super("ExplicitStatic");//（a）
        System.out.println("ExplicitStatic()");
        System.out.println("s3 = " + s3 + " ,i3 = " + i3);
    }
    public static void main(String[] args){
        ExplicitStatic x = new ExplicitStatic();//（c）
    }
}

結(jié)果：
s1 initialized.
s2 initialized.
s3 initialized. 
//如果把（c）處的代碼注釋掉，輸出結(jié)果到此為止，不會輸出下面結(jié)果
i1 initialized. 
Base()
s1 = 11 ,i1 = 12
Cleanser.draw：s2 = 21 ,i2 = 0//（d）處結(jié)果
i2 initialized.
Cleanser(ExplicitStatic)//（a）處結(jié)果
s2 = 21 ,i2 = 22
i3 initialized
ExplicitStatic()
s3 = 31 ,i3 = 31
由于在Base()中調(diào)用draw()時，Cleanser中的i2還未進(jìn)行初始化，而在為Cleanser對象分配存儲空間時，把存儲空間初始化為0，所以此時i2為0。
2.4 代碼及結(jié)果中的（a）說明了是先產(chǎn)生當(dāng)前class的base class的實例，否則在derived class中無法調(diào)用base class的成員。在調(diào)用Cleanser class的構(gòu)造函數(shù)Cleanser(String a)時，在Cleanser(String a)中沒有用super顯式調(diào)用Base class的構(gòu)造函數(shù)，所以系統(tǒng)會自動生成調(diào)用Base class的default構(gòu)造函數(shù)的語句，如（b）。
4． 組合與繼承之間的快擇
. 1）繼承表示的是一種"is-a（是一個）"的關(guān)系，如貨車是汽車中的一種；組合表示的是一種"has-a（有一個）"的關(guān)系，如汽車有四個輪子。
2）是否需要將新的class向上轉(zhuǎn)型為base class。
5． 在繼承中的訪問權(quán)限
protect變量能被子孫類所調(diào)用。如Base class中的baseS能被Cleanser class和ExplicitStatic class調(diào)用。
class Base{
    protected String baseS = "Base";
    //private String baseS = "Base";
    Base(){System.out.println("Base()");}
}
class Cleanser extends Base{
    protected String baseS = "Cleanser";
    public String s = new String("Cleanser");
    Cleanser(){
        System.out.println("Cleanser(): " + s);
    }
    Cleanser(String a){
        System.out.println("Cleanser(" + a + "): s = " + s );
    }
 }
public class ExplicitStatic extends Cleanser{
    String s2 = s;
    String baseS = super.baseS;
    ExplicitStatic(){
        super("ExplicitStatic");
        System.out.println("ExplicitStatic():s2 = " + s2 + ", baseS = " 
          + baseS + "super.baseS = " + super.baseS);
        baseS = "ExplicitStatic";
        System.out.println("baseS = " + baseS + " , super.baseS = " + super.baseS);
    }
    public static void main(String[] args){
        ExplicitStatic x = new ExplicitStatic();
    }
}

結(jié)果：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Cleanser, super.baseS = Cleanser
baseS = ExplicitStatic , super.baseS = Cleanser
二．關(guān)鍵字final
1．Final data
1.1　final data
1）當(dāng)基本型別被定義為final，表示它的數(shù)據(jù)值不能被改變。如
final int i = 9;
i++;//編譯錯誤，不能改變I的值
2) 當(dāng)object　reference被定義為final時，不能改變的只是reference而不是對象本身。如
class Value{  
int i = 1;
}
public class ExplicitStatic extends Cleanser{
public static void main(String[] args){
final Value v = new Value();//v.i = 1
v.i++;//v.i = 2
//v = new Value();
}
}

由于v為final，所以不能通過new Value()使v重新指向一個對象；但是v所指向的對象的值是可以改變的（v.i++）。
1.2　blank finals
我們可以將數(shù)據(jù)成員聲明為final但不給予初值，這就是blank　finals。但blank　finals必須且只能在構(gòu)造函數(shù)中進(jìn)行初始化。
public class ExplicitStatic {
    final int ib;
    final int i = 1;
    ExplicitStatic()
    {
        ib = 2;//（a）
        //i = 3;?。╞）
        System.out.println("i = " + i  + ", ib = " + ib);
    }
    public static void main(String[] args){
        ExplicitStatic ex = new ExplicitStatic();
    }
}

ib為blank　finals，所以可以在構(gòu)造函數(shù)中進(jìn)行初始化。如果把（a）處的代碼注釋掉，則ib沒有初值，編譯出錯。而i在定義處已進(jìn)行了初始化，則不能改變i的值，（b）處的代碼編譯錯誤。
＊＊：非blank　finals成員即使在構(gòu)造函數(shù)中也不能更改其值
2．Final　methods
1）被聲明為final的函數(shù)不能被覆寫
2）class中所有private函數(shù)自然而然會是final。
3． Final　classes
1）當(dāng)一個class被聲明為final時，表示它不能被繼承，但class的數(shù)據(jù)成員不是final，可以被改變。如
class SmallBrain{}

final class Dinosaur{
    		int i = 7;
    		int j = i;
    		SmallBrain x = new SmallBrain();
    		void f(){};
}

//不能繼承final函數(shù)
//class Further extends Dinosaur{}

public class ExplicitStatic{
    		public static void main(String[] args){
        		Dinosaur n = new Dinosaur();
        		n.f();
        		n.i = 40;//final class中的non-final數(shù)據(jù)成員可以被改變
       	 	n.j++;
    		}
}

2）final　class中的所有函數(shù)也都自然是final，因為沒有人能夠加以覆寫。

第7章 多態(tài)

一．再探向上轉(zhuǎn)型（upcasting）
將某個object　reference視為一個"reference　to　base　type"的動作，稱為向上轉(zhuǎn)型。
1． Upcasting后調(diào)用某個函數(shù)時，如果derived　class中覆寫了該函數(shù)，則會調(diào)用derived　class中的函數(shù)；否則，會調(diào)用base　class中的函數(shù)。如
class First{
    public void prt(){
        System.out.println("First");
    }
}
class Second extends First{
	//（a）
     public void prt(){
        System.out.println("Second");
    }
}
public class ExplicitStatic{
    public static void main(String[] args){
        First n = new Second();
        n.prt();;
    }
}

結(jié)果為Second。如果當(dāng)Second　class中的prt()函數(shù)注釋掉，將輸出First。
2． 向上轉(zhuǎn)型后只能調(diào)用base　class中被derived　class覆寫的函數(shù)。
/*
abstract class First{
    int i = 122;
    public void prt(){
        System.out.println("First.i = " + i);
    }
    public abstract void prt(First f);
}

class Second extends First{
     public void prt(){
        System.out.println("Second.i = " + i);
    }
    
    public void prt(First i)
    {
        
    }
    
    public void prt(int i)
    {
        
    }
}
public class ExplicitStatic{
    public static void main(String[] args){
        First n = new Second();
        n.prt(2);;
    }
}
*/
class First{
    public void prt(){
        System.out.println("First");
    }
}
class Second extends First{
	//（a）
     public void prt(){
        System.out.println("Second");
    }
    public void prt(int i){//（a）
        System.out.println("Second.i = " + i);
    }
}
public class ExplicitStatic{
    public static void main(String[] args){
        First n = new Second();
        n.prt(3);
    }
}

（a）處的函數(shù)只是Second　class中的函數(shù)，所以不能通過n.prt(3)進(jìn)行調(diào)用。
二．Abstract　class和Abstract　methods
1． 如果一個class中存在abstract　class，則class也必須被聲明為abstract　class。
2． abstract　class不能被實例化。
3． 如果base　class是一個abstract　class，那么derived　class必須實現(xiàn)base　class中所有的abstract　methods；否則，derived　class也必須被聲明為abstract　class。
三．其它要點
1． 純粹繼承與擴(kuò)充
純粹繼承：只有base　class所建議的函數(shù)，才被derived　class加以覆寫。
擴(kuò)充：除了覆寫base　class的函數(shù)，還實現(xiàn)了自己的函數(shù)
abstract class First{
    public abstract void f();
    public abstract void g();
}
//純粹繼承
class Second extends First{
     public void f(){}
     public void g(){}
}
//擴(kuò)充
class Third extends First{
     public void f(){}
     public void g(){}
     public void u(){}//base　class不存在的函數(shù)
}

2． 向下轉(zhuǎn)型
1） 向下轉(zhuǎn)型時只能調(diào)用base　class中被覆寫過的函數(shù)
2） 只有本來就為derived　class對象時才能正確向下轉(zhuǎn)弄。
class First{
     public void f(){}
     public void g(){}
}
class Second extends First{
     public void f(){}
     public void g(){}
     public void u(){}
     public void v(){}
}
public class ExplicitStatic{
    public static void main(String[] args){
        First[] x = {new First(), new Second()};
        x[0].f();
        x[1].g();
        //！x[1].u();class　First中不存在函數(shù)u()
        //((Second)x[0]).f();（a）
        ((Second)x[1]).u();
}
}