隨筆:93 文章:11 評論:22 引用:0
          首頁 發新隨筆
          發新文章 聯系 聚合管理

          學習知識難免會忘記,關鍵是在忘記之后,下次遇到時能夠通過快捷的方法來回憶,并盡量達到忘記之前的狀態。總結也許是日后回憶的一種有效方法,前些日子看了javascript的function,總結如下:

          學習function重要的就是明白當程序運行到函數聲明的時候,并不執行該函數,當其他函數調用所聲明的函數時,該函數才被執行,也就是英文說的function is complied,but not executed until you call it.

          再有就是函數在聲明時創建變量。例如function(){}就創建了一個變量,雖然這個變量是匿名的。

          js 代碼
          1. var a=function(){};   
          2.   
          3. var a=function(x,y){}(1,2);   

          第一條語句是定義一個匿名function,并將該函數賦給a變量。第二條語句是定義一個匿名function,并調用將該函數的返回結果賦值給a變量。

          function add(a,b){};則是定義了一個function,該function的名字是add,相當于一個名為add的變量指向該function。

          看看以下代碼,感覺挺有意思:

          js 代碼
          1. function myFunction(){alert("Old");};   
          2.   
          3. var savedFunction=myFunction;   
          4.   
          5. myFunction=function(){alert("New");};   
          6.   
          7. myFunction();   //prints"New"   
          8.   
          9. savedFunction(); //prints"Old"   

          在調用myFuction函數的時候,打印出New字符串,代碼的第二行明確指出savedFunction=myFunction,但是在調用 savedFunction的時候會出現Old字符串,這種情況應該引起java同行的注意,在javascript中,指針指向的是代碼片段,執行第二 行的時候,savedFucntion指向的是myFuction所指向的代碼片段 myFunction code(第一行),然而在第三行myFunction指針由先前的代碼片段myFunction code改變為代碼片段function(){alert("New")} code的時候,先前的代碼片段仍然未消失,被savedFunction所指向,這也就解釋了為什么最后程序打印出的字符串仍是Old。

          對于Function關鍵字來說僅在特殊情況下用到,一般就用function,這里就不再介紹了。

          prototype屬性對于初學js的人來說比較迷惑,這里大致的總結如下:

          一般的變量沒有prototype屬性,constructor function有prototype屬性,也就是聲明的function(){}變量,js中的每個對象都有一個_proto_和 constructor屬性,如果一個對象由constructor function生成,例如:

          js 代碼
          1. function Ball(message){   
          2.   
          3. alert(message);   
          4.   
          5. };   
          6.   
          7. var ball0=new Ball("executing");   

          解釋以下,最后一行代碼等同于:

          js 代碼
          1. var ball0=new Object();   
          2.   
          3. ball0.construct=Ball;//將屬性construct指向代碼片段Ball code   
          4.   
          5. ball0.construct("executing"); //執行該代碼片段   

          接著說,如果一個對象由constructor function生成,則該對象ball0的_proto_屬性指向它的構造函數的prototype屬性,也就是指向constructor function(這里是前三行代碼)所具有的prototype屬性,因此凡是用該constructor function生成的對象,都帶有該function的prototype屬性。

          posted @ 2009-05-03 08:39 redcoatjk 閱讀(179) | 評論 (0)編輯 收藏
           

          什么叫事務? 這些就是數據庫特有的術語了。懶蟲在這里口頭解釋:就是把多件事情當做一件事情來處理。也就是大家同在一條船上,要活一起活,要over一起over !

          事務(Transaction)是訪問并可能更新數據庫中各種數據項的一個程序執行單元(unit)。事務通常由高級數據庫操縱語言或編程語言(如SQL,C++或Java)書寫的用戶程序的執行所引起,并用形如begin transactionend transaction語句(或函數調用)來界定。事務由事務開始(begin transaction)和事務結束(end transaction)之間執行的全體操作組成。

          例如:在關系數據庫中,一個事務可以是一條SQL語句,一組SQL語句或整個程序。

          事務是恢復和并發控制的基本單位。

          事務應該具有4個屬性:原子性、一致性、隔離性、持續性。這四個屬性通常稱為ACID特性

          原子性(atomicity)。一個事務是一個不可分割的工作單位,事務中包括的諸操作要么都做,要么都不做。

          一致性(consistency)。事務必須是使數據庫從一個一致性狀態變到另一個一致性狀態。一致性與原子性是密切相關的。

          隔離性(isolation)。一個事務的執行不能被其他事務干擾。即一個事務內部的操作及使用的數據對并發的其他事務是隔離的,并發執行的各個事務之間不能互相干擾。

          持久性(durability)。持續性也稱永久性(permanence),指一個事務一旦提交,它對數據庫中數據的改變就應該是永久性的。接下來的其他操作或故障不應該對其有任何影響。


             我為什么要使用事務? 俺這里再舉個很俗很俗的例子:

               俺到銀行存錢,于是有這么幾個步驟:
                 1、把錢交給工作人員;2、工作人員填單;3、將單子給我簽字;4、工作人員確認并輸入電腦。

             要是,要是我把錢交給工作人員之后,進行到3我簽字了。那哥們突然心臟病發作,over掉了,那,我的錢還沒有輸入電腦,但我卻交了錢又簽字確認了,而并沒有其他任何記錄。我豈不是要虧死了???我的血汗錢啊!趕緊退給我!!

             于是,在數據庫里產生了這么一個術語:事務(Transaction),也就是要么成功,要么失敗,并恢復原狀。
            
             還是寫程序把:

             Create Proc sp我去存款(@M Money , @iOperator Int)
             As
             Begin
              Declare @i int

              Begin Tran           --激活事務
               Exec @i=sp交錢 @m,@iOperator
               if @i<>0           --這里一般用系統錯誤號 @@Error。 我這里為了舉例子沒有用到。需要根據實際情況。
               begin
                Rollback Tran                   --回滾事務
                RaisError ('銀行的窗口太少了,我懶得排隊,不交了!:( ', 16, 1) with Log --記錄日志
                Return -1                     --返回錯誤號
               end

               Exec @i=sp填單 @m,@iOperator
               if @i<>0
               begin
                Rollback Tran                   --回滾事務
                RaisError ('銀行的哥們打印機出了點毛病,打印不出單子來,把錢退回來給我吧??', 16, 1) with Log
                Return -2                     
               end

               Exec @i=sp簽字 @m
               if @i<>0
               begin
                Rollback Tran                   --回滾事務
                RaisError ('我 靠?什么爛銀行,換了3支筆都寫不出水來!!老子不存了!!不簽!', 16, 1) with Log 
                Return -3                     
               end

               Exec @i=sp輸入電腦 @m,@iOperator
               if @i<>0
               begin
                Rollback Tran                   --回滾事務
                RaisError ('什么意思?磁盤空間已滿?好了好了,把錢給我,我到旁邊的這家銀行!', 16, 1) with Log 
                Return -4                     
               end
           
              Commit Tran        --提交事務
              Return 0
            End
           

                 ----------------------------------------------------------------------
                 以上是偽代碼,模擬我去存款的過程。

          posted @ 2009-05-02 22:28 redcoatjk 閱讀(120) | 評論 (0)編輯 收藏
           

          基本原理:

          服務器端在處理到達的請求之前,會將請求中包含的令牌值與保存在當前用戶會話中的令牌值進行比較,看是否匹配。在處理完該請求后,且在答復發送給客戶端之前,將會產生一個新的令牌,該令牌除傳給客戶端以外,也會將用戶會話中保存的舊的令牌進行替換。這樣如果用戶回退到剛才的提交頁面并再次提交的話,客戶端傳過來的令牌就和服務器端的令牌不一致,從而有效地防止了重復提交的發生。

          找一般的流程中插入個中間的action

          多寫一個actionnonoaction

          nonoaction

          this.saveToken(request); //設置指令牌

          return 跳轉到執行邏輯功能的action中如doaction

          執行業務功能的action doaction

          doaction

          ......

          if(this.isTokenValid(request)) //如果指令牌相同

          {.....

          ...實現功能的代碼

          this.resetToken(request);//取消指令牌

          }else //執行else說明提交是重復提交

          {

          可以跳轉回首頁.并報錯 如寫

          ActionMessages errors= new ActionMessagers();

          errors.add(“token”,new ActionMessages(“token”)); //可以把錯誤信息寫在資源文件中 然后顯示

          this.saveErrors(return.errors); //保持錯誤信息

          跳轉….

          }

           

           

           

           

          posted @ 2009-04-14 16:06 redcoatjk 閱讀(133) | 評論 (0)編輯 收藏
           
          代碼見:mytoken
          要防止重復提交
          需要先設置指令牌
          然后具體操作功能之前,驗證指令牌.
          ------------
          舉例如下:
          ----------提交留言------------------
          在執行留言的action前,設置一個指令牌(比如跳轉到添加頁面前,先執行一個action.在action中設置指令牌.或者攔截器中做也可以):
          this.saveToken(request);
          然后
          執行添加留言的acion中,在執行功能操作前
           if(this.isTokenValid(request)); 驗證指令牌.
          為true則執行添加操作.最后 用
          this.resetToken(request);
          來取消指令牌.
          如果之前的驗證指令牌返回false,那就不用執行添加操作,直接跳轉處理.

          posted @ 2009-04-14 16:04 redcoatjk 閱讀(194) | 評論 (0)編輯 收藏
           
               摘要: 摘自 http://www.aygfsteel.com/crazycy/archive/2008/10/19/74622.html#235256 < 示例1>  1 class  Base {  2      int  x  =   2 ;  3 ...  閱讀全文
          posted @ 2009-03-30 16:56 redcoatjk 閱讀(137) | 評論 (0)編輯 收藏
           
          載自http://www.cnblogs.com/itelite/archive/2008/01/11/1035587.html
          <script language="javascript">
           //Author :東閣
           //Date:2008-1-11
           //目的: 練習數組的基本操作

           /*
           由于javascript是一種無類型語言,所以一個數組的元素可以具有任意的數據類型,同一個數組的不同元素
           可以具有不同的類型,數組的元素設置可以包含其他數組,這樣就可以創建一個復雜的數組了.
           并且在這點上說javascript作為一種腳本語言不同于那種嚴格的面向對象的c++.c#,java了.具有更高的靈活性.
           */

           /*
           *在javascript1.1和其后的版本中,數組是用構造函數Array()和運算符new來創建,
           可用以下的三種方式來創建javascript 中的數組.
           */
           var a=new Array();
           var b=new Array(5,4,3,"first","test,string");
           var c=new Array(20);

           a[1.23]="test";
           document.write("a[1.23]="+a[1.23]);
           //相信每位從強類型的編程語言學習javascript時,絕對會以為上面這種操作感到驚訝,
           //float數據也作數組的下標了,事實上                       并非如您所想       
           //javascript在您是用負數,浮點數,(或布爾型,對象,其他值時),javascript會將它轉換為一個字符串
           //用生成的字符串作為對象的屬性名字,而不是定義了一個新的數組元素
           //上面的實例事實就是為a 創建了一個名為:"1.23"的屬性.
           document.write("a.length="+a.length);
           document.write("b.length="+b.length);
           document.write("c.length="+c.length);

           a[3]="Test";
           document.write("<br />a[3]="+a[3]);
           document.write("<br/>a.length="+a.length);
           //以上測試也很明確我們用整數作為數組的下標是才會真正為數組添加一個元素,
           //這里用數組的長度來體現了javascript的數組中的奧妙。


           //通過設置數組的length屬性能過截斷數組的長度。
           a.length=3;
           if (a[3]==undefined)
           {
            document.write("<br />在a.length="+a.length+"后,a[3]="+a[3]);
           }
           else
           {
              document.write("<br />在a.length="+a.length+"后,a[3]="+a[3]);
           }

           //這里測試我們的多維數組元素
           /*
           *javascript中實際上是不支持多維數組
           *但是我們將一個一維數組的元素再賦給其一個一維數組,這樣就看起來就實現了多維數組了,但
           實際上他還是個一維數組,這和我們理解c語言的數組時的那種想法一樣,但他們的實現機制是不一樣的。
           */
           var g=new Array(3);
           g[3]=a;
           g[3][2]="Test"
           document.write("<br />g[3][2]="+g[3][2]);
           
            //數組join()方法
            for (var i=0;i<20 ;i++ )
            {
           c[i]=i;
           document.write("<br />c[i]="+c[i]);
            }
            document.write("<br/>c的元素join()方法后是:"+c.join());
            //數組的reverse()方法
            c.reverse();
            document.write("<br />c的元素在reverse()方法再join()后的結果是:"+c.join("|"));

            //concat()方法的測試
            var h=new Array(1,2,3);
            h= h.concat([4,5]);
            //但是concat函數不會遞歸地展開一個元素為數組的數組。
            h=h.concat(6,7,[9,[10,20]]);
            document.write("<br />h.length="+h.length+"<br />"+h);
            document.write("h[8]="+h[8]);


            //slice()方法
            document.write("<br>h.slice(4,5)="+h.slice(4,5));
          document.write("h.slice(5,9)="+h.slice(5,9))
          //slice()方法:返回的數組包含有第一個參數指定的元素和那個元素開始到第二個參數指定的
          //元素為止的元素但不包含第二個參數所指定的元素。


          //splice()方法
          //splice()方法是插入或刪除數組元素通用的方法。
          /*
          splice函數第一個參數指定了要插入或刪除的元素在數組中的位置。
          第二個參數指定了要從數組中刪除的元個數
          在第二參數之后可以有任意多個參數,它們指定的是從第一個參數指定的位置處插入的元素。
          第一個元素及后續元素,做出相應的移動。
          */

          document.write("<br />h.splice(8,1)后的h為::"+h.splice(8,1));
          //document.write("<br />h.splice(8,0,'a','b','Test')后的h為::"+h.splice(8,0,'a','b','Test'));
          h.splice(7,0,'a','b','Test');
          document.write("<br />h.splice(7,0,'a','b','Test')后的h為:"+h);


          //javascript中的數組作為堆棧時和php類似
          //這點有趣更有用。
          //以下是作為堆棧是使用的小實例
          /*
          push方法是將一個或多個新元素附加到數組的尾部,然后返回數組的新長度。
          pop將刪除數組的最后一個元素,堅守數組的長度,返回他刪除的值。
          */
          var stack=new Array();
          stack.push(1,2);
          document.write("<br>stack的元素是:"+stack);
          document.write("<br />stack.length="+stack.length);
          document.write("<br>stack.pop()返回的結果是:"+stack.pop());
          document.write("<br />stack.length="+stack.length);

          //以下是作為隊列使用的小實例
          /*
          unshift方法將一個或多個元素添加到數組元素的頭部,然后把已有的元素移動到下標最大的位置已騰出空間
          ,它返回的是主族的新長度。
          方法shift是刪除并返回數組的第一個元素,然后將后面的所有元素都向前移動以填補第一個元素留下的空白。
          */
          var list=[];
          list.unshift(6,2);
          document.write("<br >list的內容為:"+list);
          document.write("<br>list的shift方法是:"+list.shift());

          //此外就剩下,我們在java中熟悉的toString()方法 了
          //It's a piece of cake!
          document.write(c.toString());
          //說白了,其實數組的toString()方法和無參數的join()的效果是完全相同
          //OK,this's chapter for Array,that's all!

          </script>

          posted @ 2009-03-09 13:06 redcoatjk 閱讀(662) | 評論 (0)編輯 收藏
           

          網上搜到這個資料.

          加以修改加工一下,發布.感謝原作者的付出:http://singlewolf.javaeye.com/blog/173877

          Singleton類之所以是private型構造方法,就是為了防止其它類通過new來創建實例,即如此,那我們就必須用一個static的方法來創建一個實例(為什么要用static的方法?因為既然其它類不能通過new來創建實例,那么就無法獲取其對象,那么只用有類的方法來獲取了)

           1class Singleton {   
           2
           3     private static Singleton instance;  
           4
           5     private static String str="單例模式原版" ;
           6
           7 
           8
           9     private Singleton(){}   
          10
          11     public static Singleton getInstance(){   
          12
          13         if(instance==null){   
          14
          15             instance = new Singleton();   
          16
          17         }
             
          18
          19         return instance;   
          20
          21     }
             
          22
          23     public void say(){   
          24
          25         System.out.println(str);   
          26
          27     }
            
          28
          29     public void updatesay(String i){
          30
          31           this.str=i;
          32
          33           
          34
          35          
          36
          37     }
           
          38
          39}
             
          40
          41  
          42
          43public class danli{   
          44
          45    public static void main(String[] args) {   
          46
          47        Singleton s1 = Singleton.getInstance();   
          48
          49        //再次getInstance()的時候,instance已經被實例化了   
          50
          51        //所以不會再new,即s2指向剛初始化的實例   
          52
          53        Singleton s2 = Singleton.getInstance();   
          54
          55        System.out.println(s1==s2);   
          56
          57        s1.say();   
          58
          59        s2.say();   
          60
          61        //保證了Singleton的實例被引用的都是同一個,改變一個引用,則另外一個也會變.
          62
          63        //例如以下用s1修改一下say的內容
          64
          65        s1.updatesay("hey is me Senngr");   
          66
          67        s1.say();  
          68
          69        s2.say(); 
          70
          71        System.out.println(s1==s2); 
          72
          73    }
             
          74
          75}

          76

           打印結果:
          true

          單例模式原版

          單例模式原版

          hey is me Senngr

          hey is me Senngr

          true

          private static Singleton instance;
          public static Singleton getInstance()
          這2個是靜態的 

          1.定義變量的時候是私有,靜態的:private static Singleton instance;
          2.定義私有的構造方法,以防止其它類通過new來創建實例;
          3.定義靜態的方法public static Singleton getInstance()來獲取對象.instance = new Singleton();
          posted @ 2009-03-05 21:42 redcoatjk 閱讀(155) | 評論 (0)編輯 收藏
           
               摘要: 代碼參見dynamic-proxy-AOP2 基于配置文件的方式的好處在于所謂的分層.所以號稱應該推薦使用這個方法 隨便了.代碼重新貼一次吧. 1.UserManager接口  1package com.zyl.proxy;  2  3public interface UserManager {  4&n...  閱讀全文
          posted @ 2009-02-22 21:10 redcoatjk 閱讀(580) | 評論 (1)編輯 收藏
           
           前面一個文章里的代碼很簡單(只是讓大家了解什么是代理),實現的是靜態代理,做為電腦代理商的ComputerProxy,在電腦行業 為電腦生產商(三星,聯想)和客戶提供服務,提供各種方便。
                  郁悶的是,如果我現在增加一個行業,比如下面要講到的Cat汽車行業,那么,我們只能增加一個代理了,也就是說我們要再寫一個CatProxy代碼,我們現在假設我們有很多個行業,那么,無疑我們的工作量開始大了,有沒有什么辦法讓我們的代理商實現跨行業代理呢?
                  答案是:可以。這就是我們這里講的動態代理產生存在的意義了。

          請看代碼

          在原有代碼的基礎上我們做了這些寬展:

          /*
          *汽車批發商
          *這樣我們的代碼中就有了電腦和汽車這兩個批發商
          */

          public interface Cat {
              
          public void buyCat(String name);
          }

          /*
          *勞斯萊斯汽車公司
          */

          public class RollsRoyce implements Cat {

              
          public void buyCat(String name) {
                  
                  System.out.println(name
          +"  勞斯萊斯公司產品!");
              }


          }

          /*
          *所有行業代理商
          *有了它我們的客戶可以通過他買個各種產品
          */

          import java.lang.reflect.InvocationHandler;
          import java.lang.reflect.Method;
          import java.lang.reflect.Proxy;
          import java.util.logging.Level;
          import java.util.logging.Logger;

          public class AllthingsProxy implements InvocationHandler {

              
          private Logger logger=
                  Logger.getLogger(
          this.getClass().getName());
              
              
          private Object allthings;
              
              
          //實現對象綁定
              public Object bind(Object allthings){
                  
                  
          this.allthings = allthings;
                  
                  
          //這里傳入newProxyInstance的參數分別是 目標object
                  
          //(Lianxiang,Sanxing),interface(Computer),AllthingsProxy
                  return Proxy.newProxyInstance(allthings.getClass().getClassLoader(),
                                              allthings.getClass().getInterfaces(), 
          this);
              }

              
              
          public Object invoke(Object proxy, Method method, Object[] args)
                      
          throws Throwable {
                  
                  Object result 
          = null;
                  
                  
          try{
                  log(
          "method starts " + method);
                  
                  result
          =method.invoke(allthings, args);

                  logger.log(Level.INFO , 
          "method ends " + method);
                  
                  }
          catch(Exception e){
                      log(e.toString());
                  }

                  
                  
          return result;
              }

              
              
          private void log(String msg){
                  logger.log(Level.INFO,msg);
              }


          }


          在測試類BuyAllThings中,我們通過bing方法綁定對象(所要買的東西),讓代理商了解到,客戶想買什么?
          (這里重在了解模式,具體方法的實現如不了解請自行查詢API文檔)


          /*
          *三個客戶兩個買電腦一個買汽車
          *他們找到同個代理商
          */

          public class BuyAllThing {

              
          public static void main(String[] args) {
                  
                  AllthingsProxy allthingsproxy 
          = new AllthingsProxy();
                  
                  Computer SanxingProxy
          =(Computer)allthingsproxy.bind(new Sanxing());
                  
                  SanxingProxy.buyComputer(
          "我想買一臺三星電腦");
                  
                  Computer lianxiangProxy
          =(Computer)allthingsproxy.bind(new Lianxiang());
                  
                  lianxiangProxy.buyComputer(
          "我想買一臺聯想電腦");
                  
                  Cat RollsRoyceProxy
          =(Cat)allthingsproxy.bind(new RollsRoyce());
                  
                  RollsRoyceProxy.buyCat(
          "我想買一輛勞斯萊斯汽車");

              }


          }

          執行結果

          我想買一臺三星電腦  三星電腦公司產品!
          我想買一臺聯想電腦  聯想電腦公司產品!
          我想買一輛勞斯萊斯汽車  勞斯萊斯公司產品!
          2007-8-9 13:08:41 com.lusm.spring.AllthingsProxy log
          信息: method starts 
          public abstract void com.lusm.spring.Computer.buyComputer(java.lang.String)
          2007-8-9 13:08:42 com.lusm.spring.AllthingsProxy invoke
          信息: method ends 
          public abstract void com.lusm.spring.Computer.buyComputer(java.lang.String)
          2007-8-9 13:08:42 com.lusm.spring.AllthingsProxy log
          信息: method starts 
          public abstract void com.lusm.spring.Computer.buyComputer(java.lang.String)
          2007-8-9 13:08:42 com.lusm.spring.AllthingsProxy invoke
          信息: method ends 
          public abstract void com.lusm.spring.Computer.buyComputer(java.lang.String)
          2007-8-9 13:08:42 com.lusm.spring.AllthingsProxy log
          信息: method starts 
          public abstract void com.lusm.spring.Cat.buyCat(java.lang.String)
          2007-8-9 13:08:42 com.lusm.spring.AllthingsProxy invoke
          信息: method ends 
          public abstract void com.lusm.spring.Cat.buyCat(java.lang.String)

          我們可以任意的增加代理商的業務,比如,叫他代理電器,食物......,我們看到我們不需要更改原有的代碼。這是動態代理帶來的好處!

          那我們的AllthingsProxy是怎么作到動態代理的呢?

          AllthingsProxy寬展了InvocationHandler并實現了里面的代理方法,返回一個Object對象,

              public Object invoke(Object proxy, Method method, Object[] args)
              
          throws Throwable;

          來實現對汽車,電腦這些批發商的動態代理(代理商同過它 代理所有行業)。

          AllthingsProxy中的bind實現了客戶和代理商間的通信(通過它代理商知道客戶想要買什么)

          這和我們 BuyAllThing 測試類main中

          代理對象=(綁定對象)allthingsproxy.bind(綁定對象(客戶想買的東西))

          想對應。

                   呵呵 ,講完了!也許有的朋友看不懂這里在說什么? 不必著急,學習都需要過程,等你的學習到某個階段的時候,回頭想想,也許認識就會加深許多,本人覺得Java是比較高級的語言,自身的發展也只直遵循著軟件設計優化(代碼重用)方向發展,重視設計思想,而不是去改變語言的語法或接口api,這是許多語言所缺乏的,如一個在VC6中編寫的代碼,拿到Visual Studio2005,Visual Studio2008去運行很容易出現問題。

                 也許你并不清楚我在說什么?但是這一切會在你的Spring學習中漸漸清楚起來!

                 以后的代碼可能需要必要的IDE才能使用,本人使用的是:
                 MyEclipse6.0M1+Eclipse3.3 
                 數據庫用的是:
                Oralce10g或者Mysql6.0

                祝你好運氣!!!
          posted @ 2009-02-19 23:15 redcoatjk 閱讀(176) | 評論 (0)編輯 收藏
           
               摘要: 這幾天在看一些代理的東西.發現這個帖子寫的很不錯 冒昧轉過來收藏之. 摘自 http://www.aygfsteel.com/lusm/archive/2007/08/08/135355.html ---------------------------------------------------------------- 在以后的日子里,我會用學習剩下的時間和大家一起學習Java設計...  閱讀全文
          posted @ 2009-02-19 23:05 redcoatjk 閱讀(228) | 評論 (1)編輯 收藏
          僅列出標題
          共8頁: 上一頁 1 2 3 4 5 6 7 8 下一頁 
          CALENDER
          <2025年6月>
          25262728293031
          1234567
          891011121314
          15161718192021
          22232425262728
          293012345

          常用鏈接

          留言簿(3)

          隨筆分類(22)

          隨筆檔案(76)

          文章分類(12)

          文章檔案(17)

          搜索

          •  

          積分與排名

          • 積分 - 250888
          • 排名 - 227

          最新評論

          評論排行榜


          Powered By: 博客園
          模板提供滬江博客

          主站蜘蛛池模板: 曲阜市| 延长县| 牙克石市| 康平县| 长顺县| 阜新| 宁德市| 成安县| 烟台市| 广河县| 宣城市| 长寿区| 和林格尔县| 和硕县| 西安市| 塔河县| 金坛市| 舒兰市| 兰西县| 宁晋县| 和田县| 格尔木市| 观塘区| 泾川县| 夹江县| 冷水江市| 奉化市| 太谷县| 定西市| 明溪县| 曲阳县| 林州市| 裕民县| 新乡县| 拜城县| 香河县| 治县。| 绿春县| 聂拉木县| 太仓市| 台州市|