算法比較簡單，沒有采用遞歸，javascript實現如下，可以輕易轉為其他語言

posted @ 2012-07-18 21:34 zhanghu198901 閱讀(726) | 評論 (0) | 編輯收藏

spring的三種注入方式

spring 的三種注入方式

1. 接口注入（不推薦）

2. getter ， setter 方式注入（比較常用）

3. 構造器注入（死的應用）

關于 getter 和 setter 方式的注入

· autowire="defualt"

· autowire=“byName”

· autowire="bytype"

詳細解析注入方式

例如：有如下兩個類需要注入

第一個類：

Java代碼
package  org.jia;  
    
  public   class  Order {  
      private  String orderNum;  
      @SuppressWarnings ( "unused" )  
      private  OrderItem orderitem;  
    
      public  OrderItem getOrderitem() {  
          return  orderitem;  
     }  
   
     public   void  setOrderitem(OrderItem orderitem) {  
         this .orderitem = orderitem;  
     }  
   
     public  String getOrderNum() {  
         return  orderNum;  
     }  
   
     public   void  setOrderNum(String orderNum) {  
         this .orderNum = orderNum;  
     }       
 }  

第二個類：

Java代碼
package  org.jia;  
   
 public   class  OrderItem {  
     private  String orderdec;  
   
     public  String getOrderdec() {  
         return  orderdec;  
     }  
   
     public   void  setOrderdec(String orderdec) {  
         this .orderdec = orderdec;  
     }  
 }  

常用getter&&setter方式介紹

方式第一種注入：

Html代碼
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
  
< beans >   
    < bean   id = "orderItem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order"   >   
        <!-----注入變量 名字必須與類中的名字一樣------->   
        < property   name = "orderNum"   value = "order000007" > </ property >   
         < ！--注入對象 名字為orderitem，所屬的類的應用id為orderItem-- >   
        < property   name = "orderitem"   ref = "orderItem" > </ property >   
      
    --> </ bean >   
</ beans >   

方式第二種注入： byName

Html代碼
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
< beans >   
    <!--此時的id就必須與Order.java中所定義的OrderItem的對象名稱一樣了，不然就會找不到-->   
    < bean   id = "orderitem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order" < span   style = "color: #ff0000;" >   autowire = "byName" </ span > >   
        < property   name = "orderNum"   value = "order000007" > </ property >   
    </ bean >   
</ beans >   

方式第三種注入： byType

Html代碼
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
< beans >   
    <!--按照byType注入則就與id沒有關系，可以隨便定義id ！！！但是不能出現多個此類的id-->   
    < bean   id = "orderitdfadafaem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order"   < span   style = "color: #ff0000;" > autowire = "byType" </ span > >   
        < property   name = "orderNum"   value = "order000007" > </ property >   
    </ bean >   
</ beans >   

autowire="constructor"
需要在 Order.java 中加入一個構造器

Java代碼
public  Order(OrderItem item )  
{   
      orderitem = item;  
}  

XML配置文件

Html代碼
<? xml   version = "1.0"   encoding = "UTF-8" ?>   
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
< beans >   
    < bean   id = "orderItem"   class = "org.jia.OrderItem" >   
        < property   name = "orderdec"   value = "item00001" > </ property >   
    </ bean >   
    < bean   id = "order"   class = "org.jia.Order"   autowire = "constructor" >   
        < property   name = "orderNum"   value = "order000007" > </ property >   
    </ bean >   
</ beans >   

三種注入方式比較

接口注入：
接口注入模式因為具備侵入性，它要求組件必須與特定的接口相關聯，因此并不被看好，實際使用有限。
Setter 注入：
對于習慣了傳統 javabean 開發的程序員，通過 setter 方法設定依賴關系更加直觀。
如果依賴關系較為復雜，那么構造子注入模式的構造函數也會相當龐大，而此時設值注入模式則更為簡潔。
如果用到了第三方類庫，可能要求我們的組件提供一個默認的構造函數，此時構造子注入模式也不適用。
構造器注入：
在構造期間完成一個完整的、合法的對象。
所有依賴關系在構造函數中集中呈現。
依賴關系在構造時由容器一次性設定，組件被創建之后一直處于相對“不變”的穩定狀態。
只有組件的創建者關心其內部依賴關系，對調用者而言，該依賴關系處于“黑盒”之中。

總結

Spring使用注入方式，為什么使用注入方式，這系列問題實際歸結起來就是一句話，Spring的注入和IoC （本人關于IoC的闡述）反轉控制是一回事。

理論上：第三種注入方式（構造函數注入）在符合java使用原則上更加合理，第二種注入方式（setter注入）作為補充。

posted @ 2012-07-18 21:33 zhanghu198901 閱讀(1328) | 評論 (0) | 編輯收藏

jquery學習心得（二）：一個很好的css和js函數調用的例子

統一目錄下的資源結構圖：

<html>
<head>
<link rel="stylesheet" href="gallery.css" type="text/css" media="screen" charset="utf-8"/>
<script type="text/javascript" src="script.js"></script>
</head>

<body>
    <div id="container">
        <div id="header">
            <h1>StarTrackr!</h1>
    </div>
        <div id="content">
            <h2>Around Town Last Night</h2>

            <div id="ajaxInProgress"></div>
            <div id="photos">
                <fieldset id="photoDetails">
                    <legend>Photo Tagging</legend>
                    <form id="details">
                        <p id="status"></p>
                        <p>
                            <label for="name">Name:</label><br/>
                            <input type="text" class="textField" name="name" id="name" />
                        </p>
                        <p>
                            <label for="tags">Tags:</label><br/>
                            <input type="text" class="textField" name="tags" id="tags" />
                        </p>
                        <p>
                            <input type="hidden" name="id" id="id">
                            <input type="button" value="update" id="update" />
                        </p>
                    </form>
                    <div id="gallery"></div>
                </fieldset>
            </div>
   </div>
</div>
</body>
</html>

posted @ 2012-07-18 21:32 zhanghu198901 閱讀(876) | 評論 (0) | 編輯收藏

Java程序員不該有的6種陋習

只有在學會處理異常之后，我們才能說自己是一個合格的java程序員。只有在擺脫了以下六種異常處理的陋習之后，才能威懾一下剛畢業的小菜鳥。

　　現在就來測試一下大家對異常的掌握程度。不用擔心，事實上，這些不合理的設計很容易看出來。那么，以下六種不合理的代碼，大家能看出每一種的問題出在哪兒嗎？

　　OutputStreamWriter out = ...

　　java.sql.Connection conn = ...

　　try { // ⑸

　　Statement stat = conn.createStatement();

　　ResultSet rs = stat.executeQuery(

　　"select uid, name from user");

　　while (rs.next())

　　{

　　out.println("ID：" + rs.getString("uid") // ⑹

　　+ "，姓名：" + rs.getString("name"));

　　}

　　conn.close(); // ⑶

　　out.close();

　　}

　　catch(Exception ex) // ⑵

　　{

　　ex.printStackTrace(); //⑴，⑷

　　}

　　作為一個Java程序員，你至少應該能夠找出兩個問題。但是，如果你不能找出全部六個問題，請繼續閱讀本文。

　　本文討論的不是Java異常處理的一般性原則，因為這些原則已經被大多數人熟知。我們要做的是分析各種可稱為“反例”(anti-pattern)的違背優秀編碼規范的常見壞習慣，幫助讀者熟悉這些典型的反面例子，從而能夠在實際工作中敏銳地察覺和避免這些問題。

　　反例之一：丟棄異常

　　代碼：15行-18行。

　　這段代碼捕獲了異常卻不作任何處理，可以算得上Java編程中的殺手。從問題出現的頻繁程度和禍害程度來看，它也許可以和C/C++程序的一個惡名遠播的問題相提并論？？不檢查緩沖區是否已滿。如果你看到了這種丟棄(而不是拋出)異常的情況，可以百分之九十九地肯定代碼存在問題(在極少數情況下，這段代碼有存在的理由，但最好加上完整的注釋，以免引起別人誤解)。

　　這段代碼的錯誤在于，異常(幾乎)總是意味著某些事情不對勁了，或者說至少發生了某些不尋常的事情，我們不應該對程序發出的求救信號保持沉默和無動于衷。調用一下printStackTrace算不上“處理異常”。不錯，調用printStackTrace對調試程序有幫助，但程序調試階段結束之后，printStackTrace就不應再在異常處理模塊中擔負主要責任了。

　　丟棄異常的情形非常普遍。打開JDK的ThreadDeath類的文檔，可以看到下面這段說明：“特別地，雖然出現ThreadDeath是一種‘正常的情形’，但ThreadDeath類是Error而不是Exception的子類，因為許多應用會捕獲所有的Exception然后丟棄它不再理睬。”這段話的意思是，雖然ThreadDeath代表的是一種普通的問題，但鑒于許多應用會試圖捕獲所有異常然后不予以適當的處理，所以JDK把 ThreadDeath定義成了Error的子類，因為Error類代表的是一般的應用不應該去捕獲的嚴重問題。可見，丟棄異常這一壞習慣是如此常見，它甚至已經影響到了Java本身的設計。

　　那么，應該怎樣改正呢？主要有四個選擇：

　　1、處理異常。針對該異常采取一些行動，例如修正問題、提醒某個人或進行其他一些處理，要根據具體的情形確定應該采取的動作。再次說明，調用printStackTrace算不上已經“處理好了異常”。

　　2、重新拋出異常。處理異常的代碼在分析異常之后，認為自己不能處理它，重新拋出異常也不失為一種選擇。

　　3、把該異常轉換成另一種異常。大多數情況下，這是指把一個低級的異常轉換成應用級的異常(其含義更容易被用戶了解的異常)。

　　4、不要捕獲異常。

　　結論一：既然捕獲了異常，就要對它進行適當的處理。不要捕獲異常之后又把它丟棄，不予理睬。

　　反例之二：不指定具體的異常

　　代碼：15行。

　　許多時候人們會被這樣一種“美妙的”想法吸引：用一個catch語句捕獲所有的異常。最常見的情形就是使用catch(Exceptionex)語句。但實際上，在絕大多數情況下，這種做法不值得提倡。為什么呢？

　　要理解其原因，我們必須回顧一下catch語句的用途。catch語句表示我們預期會出現某種異常，而且希望能夠處理該異常。異常類的作用就是告訴Java編譯器我們想要處理的是哪一種異常。由于絕大多數異常都直接或間接從java.lang.Exception派生，catch(Exceptionex)就相當于說我們想要處理幾乎所有的異常。

　　再來看看前面的代碼例子。我們真正想要捕獲的異常是什么呢？最明顯的一個是SQLException，這是JDBC操作中常見的異常。另一個可能的異常是IOException，因為它要操作OutputStreamWriter.顯然，在同一個catch塊中處理這兩種截然不同的異常是不合適的。如果用兩個catch塊分別捕獲SQLException和IOException就要好多了。這就是說，catch語句應當盡量指定具體的異常類型，而不應該指定涵蓋范圍太廣的Exception類。

　　另一方面，除了這兩個特定的異常，還有其他許多異常也可能出現。例如，如果由于某種原因，executeQuery返回了null，該怎么辦？答案是讓它們繼續拋出，即不必捕獲也不必處理。實際上，我們不能也不應該去捕獲可能出現的所有異常，程序的其他地方還有捕獲異常的機會？？直至最后由 JVM處理。

　　結論二：在catch語句中盡可能指定具體的異常類型，必要時使用多個catch.不要試圖處理所有可能出現的異常。

　　反例之三：占用資源不釋放

　　代碼：3行-14行。

　　異常改變了程序正常的執行流程。這個道理雖然簡單，卻常常被人們忽視。如果程序用到了文件、Socket、JDBC連接之類的資源，即使遇到了異常，也要正確釋放占用的資源。為此，Java提供了一個簡化這類操作的關鍵詞finally.

　　finally是樣好東西：不管是否出現了異常，Finally保證在try/catch/finally塊結束之前，執行清理任務的代碼總是有機會執行。遺憾的是有些人卻不習慣使用finally.

　　當然，編寫finally塊應當多加小心，特別是要注意在finally塊之內拋出的異常？？這是執行清理任務的最后機會，盡量不要再有難以處理的錯誤。

　　結論三：保證所有資源都被正確釋放。充分運用finally關鍵詞。

　　反例之四：不說明異常的詳細信息

　　代碼：3行-18行。

　　仔細觀察這段代碼：如果循環內部出現了異常，會發生什么事情？我們可以得到足夠的信息判斷循環內部出錯的原因嗎？不能。我們只能知道當前正在處理的類發生了某種錯誤，但卻不能獲得任何信息判斷導致當前錯誤的原因。

　　printStackTrace的堆棧跟蹤功能顯示出程序運行到當前類的執行流程，但只提供了一些最基本的信息，未能說明實際導致錯誤的原因，同時也不易解讀。

　　因此，在出現異常時，最好能夠提供一些文字信息，例如當前正在執行的類、方法和其他狀態信息，包括以一種更適合閱讀的方式整理和組織printStackTrace提供的信息。

　　結論四：在異常處理模塊中提供適量的錯誤原因信息，組織錯誤信息使其易于理解和閱讀。

　　反例之五：過于龐大的try塊

　　代碼：3行-14行。

　　經常可以看到有人把大量的代碼放入單個try塊，實際上這不是好習慣。這種現象之所以常見，原因就在于有些人圖省事，不愿花時間分析一大塊代碼中哪幾行代碼會拋出異常、異常的具體類型是什么。把大量的語句裝入單個巨大的try塊就象是出門旅游時把所有日常用品塞入一個大箱子，雖然東西是帶上了，但要找出來可不容易。

　　一些新手常常把大量的代碼放入單個try塊，然后再在catch語句中聲明Exception，而不是分離各個可能出現異常的段落并分別捕獲其異常。這種做法為分析程序拋出異常的原因帶來了困難，因為一大段代碼中有太多的地方可能拋出Exception.

　　結論五：盡量減小try塊的體積。

　　反例之六：輸出數據不完整

　　代碼：7行-11行。

　　不完整的數據是Java程序的隱形殺手。仔細觀察這段代碼，考慮一下如果循環的中間拋出了異常，會發生什么事情。循環的執行當然是要被打斷的，其次，catch塊會執行？？就這些，再也沒有其他動作了。已經輸出的數據怎么辦？使用這些數據的人或設備將收到一份不完整的(因而也是錯誤的)數據，卻得不到任何有關這份數據是否完整的提示。對于有些系統來說，數據不完整可能比系統停止運行帶來更大的損失。

　　較為理想的處置辦法是向輸出設備寫一些信息，聲明數據的不完整性;另一種可能有效的辦法是，先緩沖要輸出的數據，準備好全部數據之后再一次性輸出。

　　結論六：全面考慮可能出現的異常以及這些異常對執行流程的影響。

　　改寫后的代碼

　　根據上面的討論，下面給出改寫后的代碼。也許有人會說它稍微有點？嗦，但是它有了比較完備的異常處理機制。

　　OutputStreamWriter out = ...

　　java.sql.Connection conn = ...

　　try {

　　Statement stat = conn.createStatement();

　　ResultSet rs = stat.executeQuery(

　　"select uid, name from user");

　　while (rs.next())

　　{

　　out.println("ID：" + rs.getString("uid") + "，姓名: " + rs.getString("name"));

　　}

　　catch(SQLException sqlex)

　　{

　　out.println("警告：數據不完整");

　　throw new ApplicationException("讀取數據時出現SQL錯誤", sqlex);

　　}

　　catch(IOException ioex)

　　{

　　throw new ApplicationException("寫入數據時出現IO錯誤", ioex);

　　}

　　finally

　　{

　　if (conn != null) {

　　try {

　　conn.close();

　　}

　　catch(SQLException sqlex2)

　　{

　　System.err(this.getClass().getName() + ".mymethod - 不能關閉數據庫連接: " + sqlex2.toString());

　　}

　　if (out != null) {

　　try {

　　out.close();

　　}

　　catch(IOException ioex2)

　　{

　　System.err(this.getClass().getName() + ".mymethod - 不能關閉輸出文件" + ioex2.toString());

　　}

　　本文的結論不是放之四海皆準的教條，有時常識和經驗才是最好的老師。如果你對自己的做法沒有百分之百的信心，務必加上詳細、全面的注釋。

　　另一方面，不要笑話這些錯誤，不妨問問你自己是否真地徹底擺脫了這些壞習慣。即使最有經驗的程序員偶爾也會誤入歧途，原因很簡單，因為它們確確實實帶來了“方便”。所有這些反例都可以看作Java編程世界的惡魔，它們美麗動人，無孔不入，時刻誘惑著你。也許有人會認為這些都屬于雞皮蒜毛的小事，不足掛齒，但請記住：勿以惡小而為之，勿以善小而不為。

posted @ 2012-07-16 22:20 zhanghu198901 閱讀(1771) | 評論 (1) | 編輯收藏

Hibernate對象映射關系----繼承映射

單表繼承映射

每棵類繼承樹使用一個表。

映射文件Extends.hbm.xml。

<hibernate-mapping package="com.snail.hibernate">
    <class name="Animal" table="t_animal" lazy="false">
        <id name="id">
            <generator class="native"/>
        </id>
        <discriminator column="type" type="string"/>
        <property name="name"/>
        <property name="sex"/>
        <subclass name="Pig" discriminator-value="P">
             <property name="weight"/>
        </subclass>
        <subclass name="Brid" discriminator-value="B">
            <property name="height"/>
        </subclass>
    </class>
</hibernate-mapping>

因為類繼承樹肯定是對應多個類，要把多個類的信息存放在一張表中，必須有某種機制來區分哪些記錄是屬于哪個類的。這種機制就是，在表中添加一個字段，用這個字段的值來進行區分。用hibernate實現這種策略的時候，有如下步驟：

（一）父類用普通的<class>標簽定義

（二）在父類中定義一個discriminator，即指定這個區分的字段的名稱和類型

如：<discriminator column=”XXX” type=”string”/>

（三）子類使用<subclass>標簽定義，在定義subclass的時候，需要注意如下幾點：

1.Subclass標簽的name屬性是子類的全路徑名；

2.在Subclass標簽中，用discriminator-value屬性來標明本子類的discriminator字段（用來區分不同類的字段）的值；

3.Subclass標簽，既可以被class標簽所包含（這種包含關系正是表明了類之間的繼承關系），也可以與class標簽平行。當subclass標簽的定義與class標簽平行的時候，需要在subclass標簽中，添加extends屬性，里面的值是父類的全路徑名稱。

4.子類的其它屬性，像普通類一樣，定義在subclass標簽的內部。

具體表繼承映射

每個具體類一張表。（同上例）

映射文件Extends.hbm.xml。

<hibernate-mapping package="com.snail.hibernate">
    <class name="Animal" table="t_animal" lazy="false" abstract="true">
        <id name="id">
            <generator class="assigned"/>
        </id>
        <property name="name"/>
        <property name="sex"/>
        <union-subclass name="Pig" table="t_pig">
            <property name="weight"/>
        </union-subclass>
        <union-subclass name="Brid" table="t_brid">
            <property name="height"/>
        </union-subclass>
    </class>
</hibernate-mapping>

這種策略是使用union-subclass標簽來定義子類的。每個子類對應一張表，而且這個表的信息是完備的，即包含了所有從父類繼承下來的屬性映射的字段（這就是它跟joined-subclass的不同之處，joined-subclass定義的子類的表，只包含子類特有屬性映射的字段）。實現這種策略的時候，有如下步驟：

（一）父類用普通<class>標簽定義即可；

（二）子類用<union-subclass>標簽定義，在定義union-subclass的時候，需要注意如下幾點：

1.Union-subclass標簽不再需要包含key標簽（與joined-subclass不同）。

2.Union-subclass標簽，既可以被class標簽所包含（這種包含關系正是表明了類之間的繼承關系），也可以與class標簽平行。當Union-subclass標簽的定義與class標簽平行的時候，需要在Union-subclass標簽中，添加extends屬性，里面的值是父類的全路徑名稱。

3.子類的其它屬性，像普通類一樣，定義在Union-subclass標簽的內部。這個時候，雖然在union-subclass里面定義的只有子類的屬性，但是因為它繼承了父類，所以，不需要定義其它的屬性，在映射到數據庫表的時候，依然包含了父類的所有屬性的映射字段。

注意：在保存對象的時候id不能重復（不能使用數據庫的自增方式生成主鍵）

類表繼承映射

每個類一張表。（同上例）

映射文件Extends.hbm.xml。

[html] view plain copy

<hibernate-mapping package="com.snail.hibernate">
<class name="Animal" table="t_animal" lazy="false">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="sex"/>
<joined-subclass name="Pig" table="t_pig">
<key column="pid"/>
<property name="weight"/>
</joined-subclass>
<joined-subclass name="Brid" table="t_brid">
<key column="bid"/>
<property name="height"/>
</joined-subclass>
</class>
</hibernate-mapping>

這種策略是使用joined-subclass標簽來定義子類的。父類、子類，每個類都對應一張數據庫表。在父類對應的數據庫表中，實際上會存儲所有的記錄，包括父類和子類的記錄；在子類對應的數據庫表中，這個表只定義了子類中所特有的屬性映射的字段。子類與父類，通過相同的主鍵值來關聯。實現這種策略的時候，有如下步驟：

（一）父類用普通的<class>標簽定義即可，父類不再需要定義discriminator字段；

（二）子類用<joined-subclass>標簽定義，在定義joined-subclass的時候，需要注意如下幾點：

1.Joined-subclass標簽的name屬性是子類的全路徑名

2．Joined-subclass標簽需要包含一個key標簽，這個標簽指定了子類和父類之間是通過哪個字段來關聯的。

如：<key column=”PARENT_KEY_ID”/>，這里的column，實際上就是父類的主鍵對應的映射字段名稱。

3.Joined-subclass標簽，既可以被class標簽所包含（這種包含關系正是表明了類之間的繼承關系），也可以與class標簽平行。當Joined-subclass標簽的定義與class標簽平行的時候，需要在Joined-subclass標簽中，添加extends屬性，里面的值是父類的全路徑名稱。

4.子類的其它屬性，像普通類一樣，定義在joined-subclass標簽的內部。

posted @ 2012-07-16 22:16 zhanghu198901 閱讀(998) | 評論 (0) | 編輯收藏

js把毫秒轉換為 xx小時xx分鐘xx秒的通用方法

posted @ 2012-07-12 22:30 zhanghu198901 閱讀(2746) | 評論 (1) | 編輯收藏

Eclipse字符集設置方式

1、windows->Preferences...打開"首選項"對話框，左側導航樹，導航到general->Workspace，右側Text file encoding，選擇Other，改變為 utf-8(必須小寫)，以后新建立工程其屬性對話框中的Text file encoding即為UTF-8。

2、windows->Preferences...打開"首選項"對話框，左側導航樹，導航到general->Content Types，右側Content Types樹，點開Text，選擇 Java Source File，在下面的Default encoding輸入框中輸入UTF-8，點Update，則設置Java文件編碼為UTF-8。然后設置jsp、js、css等類型的Default encoding，設置方式同Java Source File。

3.windows->Preferences...打開"首選項"對話框，左側導航樹，導航到MyEclipse->Files and Editors->JSP,把Encoding改為UTF-8

posted @ 2012-07-12 22:30 zhanghu198901 閱讀(6145) | 評論 (0) | 編輯收藏

Java的API你掌握程度去到哪呢，又需要掌握到哪呢

1、java.lang包下的80％以上的類的功能的靈活運用。

2、java.util包下的80％以上的類的靈活運用，特別是集合類體系、正規表達式、時間、屬性、和Timer.

3、java.io包下的60％以上的類的使用，理解IO體系的基于管道模型的設計思路以及常用IO類的特性和使用場合。

4、java.math包下的100％的內容。

5、java.net包下的60％以上的內容，對各個類的功能比較熟悉。

6、java.text包下的60％以上的內容，特別是各種格式化類。

7、熟練運用JDBC.

8、java.security包下40％以上的內容，如果對于安全沒有接觸的話根本就不可能掌握java.

9、AWT的基本內容，包括各種組件事件、監聽器、布局管理器、常用組件、打印。

10、Swing的基本內容，和AWT的要求類似。

11、XML處理，熟悉SAX、DOM以及JDOM的優缺點并且能夠使用其中的一種完成XML的解析及內容處理。

posted @ 2012-07-12 22:30 zhanghu198901 閱讀(1109) | 評論 (2) | 編輯收藏

淺談SQL中的where 1=1 作用

where 1=1
最近看到很多sql里用到where 1=1，原來覺得這沒用嘛，但是又想到如果沒用為什么要寫呢？于是在網上

查了查，在這里就淺談一下：
1=1 永真， 1<>1 永假。

1<>1 的用處：
用于只取結構不取數據的場合
例如：
create table table_temp tablespace tbs_temp as
select * from table_ori where 1<>1
建成一個與table_ori 結構相同的表table_temp，但是不要table_ori 里的數據。（除了表結構，其它結

構也同理)

1=1的用處
用于動態SQL
例如 lv_string := 'select tbl_name,tbl_desc from tbl_test where 1=1 '||l_condition;
當用戶選擇了查詢的名稱'abc'時l_condition :='and tbl_name = ''abc'''';但是當用戶沒有

選擇名稱查詢時l_condition就為空這樣 lv_string = 'select tbl_name,tbl_desc from tbl_test

where 1=1 ' ，運行也不會出錯，相當于沒有限制名稱條件。但是如果沒有1=1的條件，則lv_string =

'select tbl_name,tbl_desc from tbl_test where ';這樣就會報錯。

除了1=1 或1<>1之外的其它永真永假的條件同理。

posted @ 2012-07-12 22:29 zhanghu198901 閱讀(966) | 評論 (0) | 編輯收藏

淺談Java對象的強、軟、弱和虛引用

在JDK1.2以前的版本中，當一個對象不被任何變量引用，那么程序就無法再使用這個對象。也就是說，只有對象處于可觸及狀態，程序才能使用它。這就像在日常生活中，從商店購買了某樣物品后，如果有用，就一直保留它，否則就把它扔到垃圾箱，由清潔工人收走。一般說來，如果物品已經被扔到垃圾箱，想再把它撿回來使用就不可能了。

但有時候情況并不這么簡單，你可能會遇到類似雞肋一樣的物品，食之無味，棄之可惜。這種物品現在已經無用了，保留它會占空間，但是立刻扔掉它也不劃算，因為也許將來還會派用場。對于這樣的可有可無的物品，一種折衷的處理辦法是：如果家里空間足夠，就先把它保留在家里，如果家里空間不夠，即使把家里所有的垃圾清除，還是無法容納那些必不可少的生活用品，那么再扔掉這些可有可無的物品。從JDK1.2版本開始，把對象的引用分為四種級別，從而使程序能更加靈活的控制對象的生命周期。這四種級別由高到低依次為：強引用、軟引用、弱引用和虛引用。

1．強引用

　　本章前文介紹的引用實際上都是強引用，這是使用最普遍的引用。如果一個對象具有強引用，那就類似于必不可少的生活用品，垃圾回收器絕不會回收它。當內存空間不足，Java虛擬機寧愿拋出OutOfMemoryError錯誤，使程序異常終止，也不會靠隨意回收具有強引用的對象來解決內存不足問題。

2．軟引用（SoftReference）

　　如果一個對象只具有軟引用，那就類似于可有可物的生活用品。如果內存空間足夠，垃圾回收器就不會回收它，如果內存空間不足了，就會回收這些對象的內存。只要垃圾回收器沒有回收它，該對象就可以被程序使用。軟引用可用來實現內存敏感的高速緩存。軟引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果軟引用所引用的對象被垃圾回收，Java虛擬機就會把這個軟引用加入到與之關聯的引用隊列中。

3．弱引用（WeakReference）

　　如果一個對象只具有弱引用，那就類似于可有可物的生活用品。弱引用與軟引用的區別在于：只具有弱引用的對象擁有更短暫的生命周期。在垃圾回收器線程掃描它所管轄的內存區域的過程中，一旦發現了只具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存。不過，由于垃圾回收器是一個優先級很低的線程，因此不一定會很快發現那些只具有弱引用的對象。弱引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果弱引用所引用的對象被垃圾回收，Java虛擬機就會把這個弱引用加入到與之關聯的引用隊列中。

4．虛引用（PhantomReference）

　　"虛引用"顧名思義，就是形同虛設，與其他幾種引用都不同，虛引用并不會決定對象的生命周期。如果一個對象僅持有虛引用，那么它就和沒有任何引用一樣，在任何時候都可能被垃圾回收。虛引用主要用來跟蹤對象被垃圾回收的活動。虛引用與軟引用和弱引用的一個區別在于：虛引用必須和引用隊列（ReferenceQueue）聯合使用。當垃圾回收器準備回收一個對象時，如果發現它還有虛引用，就會在回收對象的內存之前，把這個虛引用加入到與之關聯的引用隊列中。程序可以通過判斷引用隊列中是否已經加入了虛引用，來了解被引用的對象是否將要被垃圾回收。

posted @ 2012-07-12 22:28 zhanghu198901 閱讀(813) | 評論 (0) | 編輯收藏

僅列出標題

spring 的三種注入方式

關于 getter 和 setter 方式的注入

詳細解析注入方式

三種注入方式比較

總結

常用鏈接

留言簿

隨筆檔案

搜索

最新評論

閱讀排行榜

評論排行榜