亚洲视频一区二区,а√在线天堂官网,国产高清一区二区三区

http://lavasoft.blog.51cto.com/62575/18920/

Java對異常進行了分類，不同類型的異常分別用不同的Java類表示，所有異常的根類為java.lang.Throwable，Throwable下面又派生了兩個子類：Error和Exception，Error 表示應用程序本身無法克服和恢復的一種嚴重問題，程序只有死的份了，例如，說內存溢出和線程死鎖等系統問題。Exception表示程序還能夠克服和恢復的問題，其中又分為系統異常和普通異常，系統異常是軟件本身缺陷所導致的問題，也就是軟件開發人員考慮不周所導致的問題，軟件使用者無法克服和恢復這種問題，但在這種問題下還可以讓軟件系統繼續運行或者讓軟件死掉，例如，數組腳本越界（ArrayIndexOutOfBoundsException），空指針異常（NullPointerException）、類轉換異常（ClassCastException）；普通異常是運行環境的變化或異常所導致的問題，是用戶能夠克服的問題，例如，網絡斷線，硬盤空間不夠，發生這樣的異常后，程序不應該死掉。

java為系統異常和普通異常提供了不同的解決方案，編譯器強制普通異常必須try..catch處理或用throws聲明繼續拋給上層調用方法處理，所以普通異常也稱為checked異常，而系統異常可以處理也可以不處理，所以，編譯器不強制用try..catch處理或用throws聲明，所以系統異常也稱為unchecked異常。

Java異常處理通過5個關鍵字try、catch、throw、throws、finally進行管理。基本過程是用try語句塊包住要監視的語句，如果在try語句塊內出現異常，則異常會被拋出，你的代碼在catch語句塊中可以捕獲到這個異常并做處理；還有以部分系統生成的異常在Java運行時自動拋出。你也可以通過throws關鍵字在方法上聲明該方法要拋出異常，然后在方法內部通過throw拋出異常對象。finally語句塊會在方法執行return之前執行，一般結構如下：

try{
  程序代碼
}catch(異常類型1 異常的變量名1){
  程序代碼
}catch(異常類型2 異常的變量名2){
  程序代碼
}finally{
  程序代碼
}

catch語句可以有多個，用來匹配多個異常，匹配上多個中一個后，執行catch語句塊時候僅僅執行匹配上的異常。catch的類型是Java語言中定義的或者程序員自己定義的，表示代碼拋出異常的類型，異常的變量名表示拋出異常的對象的引用，如果catch捕獲并匹配上了該異常，那么就可以直接用這個異常變量名，此時該異常變量名指向所匹配的異常，并且在catch代碼塊中可以直接引用。這一點非常非常的特殊和重要！

Java異常處理的目的是提高程序的健壯性，你可以在catch和finally代碼塊中給程序一個修正機會，使得程序不因異常而終止或者流程發生以外的改變。同時，通過獲取Java異常信息，也為程序的開發維護提供了方便，一般通過異常信息就很快就能找到出現異常的問題（代碼）所在。

Java異常處理是Java語言的一大特色，也是個難點，掌握異常處理可以讓寫的代碼更健壯和易于維護。

下面是這幾個類的層次圖：
java.lang.Object
java.lang.Throwable
      java.lang.Exception
       java.lang.RuntimeException
   java.lang.Error
       java.lang.ThreadDeath

下面四個類的介紹來自java api 文檔。

1、Throwable
Throwable 類是 Java 語言中所有錯誤或異常的超類。只有當對象是此類（或其子類之一）的實例時，才能通過 Java 虛擬機或者 Java throw 語句拋出。類似地，只有此類或其子類之一才可以是 catch 子句中的參數類型。

兩個子類的實例，Error 和 Exception，通常用于指示發生了異常情況。通常，這些實例是在異常情況的上下文中新近創建的，因此包含了相關的信息（比如堆棧跟蹤數據）。

2、Exception
Exception 類及其子類是 Throwable 的一種形式，它指出了合理的應用程序想要捕獲的條件，表示程序本身可以處理的異常。

3、Error
Error 是 Throwable 的子類，表示僅靠程序本身無法恢復的嚴重錯誤，用于指示合理的應用程序不應該試圖捕獲的嚴重問題。

在執行該方法期間，無需在方法中通過throws聲明可能拋出但沒有捕獲的 Error 的任何子類，因為Java編譯器不去檢查它，也就是說，當程序中可能出現這類異常時，即使沒有用try...catch語句捕獲它，也沒有用throws字句聲明拋出它，還是會編譯通過。

4、RuntimeException
RuntimeException 是那些可能在 Java 虛擬機正常運行期間拋出的異常的超類。Java編譯器不去檢查它，也就是說，當程序中可能出現這類異常時，即使沒有用try...catch語句捕獲它，也沒有用throws字句聲明拋出它，還是會編譯通過，這種異常可以通過改進代碼實現來避免。

5、ThreadDeath
調用 Thread 類中帶有零參數的 stop 方法時，受害線程將拋出一個 ThreadDeath 實例。

僅當應用程序在被異步終止后必須清除時才應該捕獲這個類的實例。如果 ThreadDeath 被一個方法捕獲，那么將它重新拋出非常重要，因為這樣才能讓該線程真正終止。

如果沒有捕獲 ThreadDeath，則頂級錯誤處理程序不會輸出消息。

雖然 ThreadDeath 類是“正常出現”的，但它只能是 Error 的子類而不是 Exception 的子類，因為許多應用程序捕獲所有出現的 Exception，然后又將其放棄。

對于可能出現異常的代碼，有兩種處理辦法：
        第一、在方法中用try...catch語句捕獲并處理異常，catach語句可以有多個，用來匹配多個異常。例如：
public void p(int x){
try{
  ...
}catch(Exception e){
  ...
}finally{
  ...
}
}

第二、對于處理不了的異常或者要轉型的異常，在方法的聲明處通過throws語句拋出異常。例如：

public void test1() throws MyException{
...
if(....){
throw new MyException();
}
}

        如果每個方法都是簡單的拋出異常，那么在方法調用方法的多層嵌套調用中，Java虛擬機會從出現異常的方法代碼塊中往回找，直到找到處理該異常的代碼塊為止。然后將異常交給相應的catch語句處理。如果Java虛擬機追溯到方法調用棧最底部main()方法時，如果仍然沒有找到處理異常的代碼塊，將按照下面的步驟處理：
        第一、調用異常的對象的printStackTrace()方法，打印方法調用棧的異常信息。
        第二、如果出現異常的線程為主線程，則整個程序運行終止；如果非主線程，則終止該線程，其他線程繼續運行。

通過分析思考可以看出，越早處理異常消耗的資源和時間越小，產生影響的范圍也越小。因此，不要把自己能處理的異常也拋給調用者。

還有一點，不可忽視：finally語句在任何情況下都必須執行的代碼，這樣可以保證一些在任何情況下都必須執行代碼的可靠性。比如，在數據庫查詢異常的時候，應該釋放JDBC連接等等。finally語句先于return語句執行，而不論其先后位置，也不管是否try塊出現異常。finally語句唯一不被執行的情況是方法執行了System.exit()方法。System.exit()的作用是終止當前正在運行的 Java 虛擬機。finally語句塊中不能通過給變量賦新值來改變return的返回值，也建議不要在finally塊中使用return語句，沒有意義還容易導致錯誤。

最后還應該注意一下異常處理的語法規則：
第一、try語句不能單獨存在，可以和catch、finally組成 try...catch...finally、try...catch、try...finally三種結構，catch語句可以有一個或多個，finally語句最多一個，try、catch、finally這三個關鍵字均不能單獨使用。

第二、try、catch、finally三個代碼塊中變量的作用域分別獨立而不能相互訪問。如果要在三個塊中都可以訪問，則需要將變量定義到這些塊的外面。

第三、多個catch塊時候，Java虛擬機會匹配其中一個異常類或其子類，就執行這個catch塊，而不會再執行別的catch塊。

第四、throw語句后不允許有緊跟其他語句，因為這些沒有機會執行。

第五、如果一個方法調用了另外一個聲明拋出異常的方法，那么這個方法要么處理異常，要么聲明拋出。

那怎么判斷一個方法可能會出現異常呢？一般來說，方法聲明的時候用了throws語句，方法中有throw語句，方法調用的方法聲明有throws關鍵字。

        throw和throws關鍵字的區別
        throw用來拋出一個異常，在方法體內。語法格式為：throw 異常對象。
        throws用來聲明方法可能會拋出什么異常，在方法名后，語法格式為：throws 異常類型1，異常類型2...異常類型n。

posted @ 2012-08-12 07:44 leoChiang 閱讀(1070) | 評論 (0) | 編輯收藏

String ，StringBuffer與StringBuilder

JAVA平臺提供了兩個類：String和StringBuffer，它們可以儲存和操作字符串，即包含多個字符的字符數據。String類表示內容不可改變的字符串。而StringBuffer類表示內容可以被修改的字符串。當你知道字符數據要改變的時候你就可以使用StringBuffer。典型地，你可以使用StringBuffers來動態構造字符數據。另外，String實現了equals方法，new String(“abc”).equals(new String(“abc”)的結果為true,而StringBuffer沒有實現equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的結果為false。

String覆蓋了equals方法和hashCode方法，而StringBuffer沒有覆蓋equals方法和hashCode方法，所以，將StringBuffer對象存儲進Java集合類中時會出現問題。

StringBuffer和StringBuilder類都表示內容可以被修改的字符串，StringBuilder是線程不安全的，運行效率高，如果一個字符串變量是在方法里面定義，這種情況只可能有一個線程訪問它，不存在不安全的因素了，則用StringBuilder。如果要在類里面定義成員變量，并且這個類的實例對象會在多線程環境下使用，那么最好用StringBuffer。

另：逗號分隔字符串轉換成數組、

如果不查jdk api，我很難寫出來！我可以說說我的思路：

1. 用正則表達式，代碼大概為：String [] result = orgStr.split(“,”);

2. 用 StingTokenizer ,代碼為：StringTokenizer tokener = StringTokenizer(orgStr,”,”);

String [] result = new String[tokener .countTokens()];

Int i=0;

while(tokener.hasNext(){result[i++]=toker.nextToken();}

posted @ 2012-08-10 08:21 leoChiang 閱讀(258) | 評論 (0) | 編輯收藏

java內部類2 ---總結

另有： http://blog.csdn.net/ilibaba/article/details/3866537

1.首先，把內部類作為外部類的一個特殊的成員來看待，因此它有類成員的封閉等級：private ,protected,默認(friendly),public 它有類成員的修飾符:   static,final,abstract

2.非靜態內部類nested inner class,內部類隱含有一個外部類的指針this,因此，它可以訪問外部類的一切資源（當然包括private）
外部類訪問內部類的成員，先要取得內部類的對象,并且取決于內部類成員的封裝等級。
非靜態內部類不能包含任何static成員.

3.靜態內部類：static inner class,不再包含外部類的this指針，并且在外部類裝載時初始化.
靜態內部類能包含static或非static成員.
靜態內部類只能訪問外部類static成員.
外部類訪問靜態內部類的成員，循一般類法規。對于static成員，用類名.成員即可訪問，對于非static成員，只能
    用對象.成員進行訪問

4.對于方法中的內部類或塊中內部類只能訪問塊中或方法中的final變量。
類成員有兩種static , non-static，同樣內部類也有這兩種
non-static 內部類的實例，必須在外部類的方法中創建或通過外部類的實例來創建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接訪問外部類的信息,外部類對象可通過OuterClassName.this來引用
static 內部類的實例, 直接創建即可，沒有對外部類實例的引用。
內部類不管static還是non-static都有對外部類的引用
non-static 內部類不允許有static成員
方法中的內部類只允許訪問方法中的final局部變量和方法的final參數列表，所以說方法中的內部類和內部類沒什麼區別。但方法中的內部類不能在方法以外訪問，方法中不可以有static內部類
匿名內部類如果繼承自接口,必須實現指定接口的方法,且無參數
匿名內部類如果繼承自類,參數必須按父類的構造函數的參數傳遞

內部類的作用

java 中的內部類和接口加在一起，可以的解決常被 C++ 程序員抱怨 java 中存在的一個問題??沒有多繼承。實際上，C++ 的多繼承設計起來很復雜，而 java 通過內部類加上接口，可以很好的實現多繼承的效果。

內部類：一個內部類的定義是定義在另一個內部的類。
原因是：
1.一個內部類的對象能夠訪問創建它的對象的實現，包括私有數據。
2.對于同一個包中的其他類來說，內部類能夠隱藏起來。
3.匿名內部類可以很方便的定義回調。
4.使用內部類可以非常方便的編寫事件驅動程序。

posted @ 2012-08-10 08:02 leoChiang 閱讀(210) | 評論 (0) | 編輯收藏

java內部類

java內部類分為：成員內部類，局部內部類，靜態內部類，匿名內部類。
1）成員內部類：
什么是成員內部類：作為外部類的成員存在，與外部類的屬性和方法并列。注意：成員內部類中不能定義靜態變量，但是可以訪問外部類的所有成員。
成員內部類的用處：見最后的內部類作用。
成員內部類的優點： 1.內部類作為外部類的成員可以訪問外部類的所有成員包括私有成員或屬性。2.用內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的訪問權限。
成員內部類注意：內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩類。對于一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成后出現outer.class和outer$inner.class兩類。
public class Outer{

private static int i = 1;
private int j=10;
private int k=20;
public static void outer_f1(){
    //do more something
    System.out.println("outer's outer_f1");
}
public void out_f2(){
    //do more something


}

//成員內部類
class Inner{
//static int inner_i =100; //內部類中不允許定義靜態變量
int j=100;//內部類中外部類的實例變量可以共存
int inner_i=1;
void inner_f1(){
    System.out.println(i);//外部類的變量如果和內部類的變量沒有同名的，則可以直接用變量名訪問外部類的變量
    System.out.println(j);//在內部類中訪問內部類自己的變量直接用變量名
    System.out.println(this.j);//也可以在內部類中用"this.變量名"來訪問內部類變量
    //訪問外部類中與內部類同名的實例變量可用"外部類名.this.變量名"。
    System.out.println(k);//外部類的變量如果和內部類的變量沒有同名的，則可以直接用變量名訪問外部類的變量

    outer_f1(); //可以直接訪問外部類的靜態方法
//    outer_f2(); //compile error，訪問外部類非靜態方法，必須使用外部類的實例,如下一句
    Outer.this.out_f2();
}

}
//外部類的非靜態方法訪問成員內部類
public void outer_f3(){
    Inner inner = new Inner();
    inner.inner_f1();
}

//外部類的靜態方法訪問成員內部類，與在外部類外部訪問成員內部類一樣
public static void outer_f4(){
    //step1 建立外部類對象
    Outer out = new Outer();
    //***step2 根據外部類對象建立內部類對象***
    Inner inner=out.new Inner();
    //step3 訪問內部類的方法
    inner.inner_f1();
}

public static void main(String[] args){
    outer_f4();
}
}

2）局部內部類：
  什么是局部內部類：即在方法中定義的內部類，與局部變量類似，在局部內部類前不加修飾符public或private，其范圍為定義它的代碼塊。
局部內部類的用處：見最后的內部類作用。
局部內部類的優點：在類外不可直接生成局部內部類（保證局部內部類對外是不可見的）。要想使用局部內部類時需要生成對象，對象調用方法，在方法中才能調用其局部內部類。通過內部類和接口達到一個強制的弱耦合，用局部內部類來實現接口，并在方法中返回接口類型，使局部內部類不可見，屏蔽實現類的可見性。
局部內部類注意：局部內部類中不可定義靜態變量，可以訪問外部類的局部變量(即方法內的變量)，但是變量必須是final的。

public class Outer {
    private int s = 100;
    private int out_i = 1;

    public void f(final int k) {
        final int s = 200;
        int i = 1;
        final int j = 10;
        class Inner { // 定義在方法內部
            int s = 300;// 可以定義與外部類同名的變量

            // static int m = 20;//不可以定義靜態變量
            Inner(int k) {
                inner_f(k);
            }

            int inner_i = 100;

            void inner_f(int k) {
                System.out.println(out_i);// 如果內部類沒有與外部類同名的變量，在內部類中可以直接訪問外部類的實例變量
                System.out.println(k);// *****可以訪問外部類的局部變量(即方法內的變量)，但是變量必須是final的*****
//                 System.out.println(i);  //compile error，i必須是final的
                System.out.println(s);// 如果內部類中有與外部類同名的變量，直接用變量名訪問的是內部類的變量
                System.out.println(this.s);// 用"this.變量名" 訪問的也是內部類變量
                System.out.println(Outer.this.s);// 用外部"外部類類名.this.變量名"
                                                    // 訪問的是外部類變量
            }
        } //inner
        new Inner(k);
    }

    public static void main(String[] args) {
        // 訪問局部內部類必須先有外部類對象
        Outer out = new Outer();
        out.f(3);
    }

}

3）靜態內部類：
  什么是靜態內部類：  靜態內部類定義在類中，任何方法外，用static定義。
靜態內部類的用處：見最后的內部類作用。
靜態內部類的優點：
靜態內部類注意：靜態內部類中可以定義靜態或者非靜態的成員，*******生成（new）一個靜態內部類不需要外部類成員：這是靜態內部類和成員內部類的區別。靜態內部類的對象可以直接生成：
  Outer.Inner in=new Outer.Inner()；
而不需要通過生成外部類對象來生成。這樣實際上使靜態內部類成為了一個頂級類。靜態內部類可用private，protected，public，abstract等來修飾*******

public class Outer {
    private static int i = 1;
    private int j = 10;

    public static void outer_f1() {

    }

    public void outer_f2() {

    }

    // 靜態內部類可以用public,protected,private修飾
    // 靜態內部類中可以定義靜態或者非靜態的成員
    static class Inner {
        static int inner_i = 100;
        int inner_j = 200;

        static void inner_f1() {
            System.out.println("Outer.i " + i);// 靜態內部類只能訪問外部類的靜態成員
            outer_f1();// 包括靜態變量和靜態方法
        }

        void inner_f2() {
//             System.out.println("Outer.i"+j);// error 靜態內部類不能訪問外部類的非靜態成員
//             outer_f2();//error 包括非靜態變量和非靜態方法
        }

    }

    public void outer_f3() {
        // 外部類訪問內部類的靜態成員：內部類.靜態成員
        System.out.println(Inner.inner_i);   //100
        Inner.inner_f1();   //Outer.i 1
        // 外部類訪問內部類的非靜態成員:實例化內部類即可
        Inner inner = new Inner();
        inner.inner_f2();

    }

    public static void main(String[] args) {
        new Outer().outer_f3();
    }
}

4）匿名內部類：
  什么是匿名內部類：   匿名內部類是一種特殊的局部內部類，它是通過匿名類實現接口。
                                  IA被定義為接口。
  IA I=new IA(){};
匿名內部類的用處：見最后的內部類作用。
匿名內部類的優點： 1，一個類用于繼承其他類或是實現接口，并不需要增加額外的方法，只是對繼承方法的實現或是覆蓋。
                              2，只是為了獲得一個對象實例，不需要知道其實際類型。
                              3，類名沒有意義，也就是不需要使用到。
匿名內部類注意：一個匿名內部類一定是在new的后面，用其隱含實現一個接口或實現一個類，沒有類名，根據多態，我們使用其父類名。因他是局部內部類，那么局部內部類的所有限制都對其生效。匿名內部類是唯一一種無構造                         方法類。大部分匿名內部類是用于接口回調用的。匿名內部類在編譯的時候由系統自動起名Out$1.class。如果一個對象編譯時的類型是接口，那么其運行的類型為實現這個接口的類。因匿名內部類無構造方法，所以其                         使用范圍非常的有限。當需要多個對象時使用局部內部類，因此局部內部類的應用相對比較多。匿名內部類中不能定義構造方法。如果一個對象編譯時的類型是接口，那么其運行的類型為實現這個接口的類。
在java的事件處理的匿名適配器中，匿名內部類被大量的使用。例如在想關閉窗口時加上這樣一句代碼：

frame.addWindowListener(new WindowAdapter(){
    public void windowClosing(WindowEvent e){
       System.exit(0);
    }
});

轉載自：http://hnzhoujunmei.iteye.com/blog/1067335

posted @ 2012-08-09 10:12 leoChiang 閱讀(203) | 評論 (0) | 編輯收藏

java作用域以及多態2

面向對象的特征有：封裝、繼承、抽象、多態。
      封裝是保證軟件部件具有優良的模塊性的基礎，封裝的目標就是要實現軟件部件的“高內聚、低耦合”，防止程序相互依賴性而帶來的變動影響。在面向對象的編程語言中，對象是封裝的最基本單位，面向對象的封裝比傳統語言的封裝更為清晰、更為有力。面向對象的封裝就是把描述一個對象的屬性和行為的代碼封裝在一個“模塊”中，也就是一個類中，屬性用變量定義，行為用方法進行定義，方法可以直接訪問同一個對象中的屬性。通常情況下，只要記住讓變量和訪問這個變量的方法放在一起，將一個類中的成員變量全部定義成私有的，只有這個類自己的方法才可以訪問到這些成員變量，這就基本上實現對象的封裝，就很容易找出要分配到這個類上的方法了，就基本上算是會面向對象的編程了。把握一個原則：把對同一事物進行操作的方法和相關的方法放在同一個類中，把方法和它操作的數據放在同一個類中。
抽象就是找出一些事物的相似和共性之處，然后將這些事物歸為一個類，這個類只考慮這些事物的相似和共性之處，并且會忽略與當前主題和目標無關的那些方面，將注意力集中在與當前目標有關的方面。例如，看到一只螞蟻和大象，你能夠想象出它們的相同之處，那就是抽象。
在定義和實現一個類的時候，可以在一個已經存在的類的基礎之上來進行，把這個已經存在的類所定義的內容作為自己的內容，并可以加入若干新的內容，或修改原來的方法使之更適合特殊的需要，這就是繼承。繼承是子類自動共享父類數據和方法的機制，這是類之間的一種關系，提高了軟件的可重用性和可擴展性。
  多態是指程序中定義的引用變量所指向的具體類型和通過該引用變量發出的方法調用在編程時并不確定，而是在程序運行期間才確定，即一個引用變量倒底會指向哪個類的實例對象，該引用變量發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。因為在程序運行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變量綁定到各種不同的類實現上，從而導致該引用調用的具體方法隨之改變，即不修改程序代碼就可以改變程序運行時所綁定的具體代碼，讓程序可以選擇多個運行狀態，這就是多態性。
java實現多態的機制：靠的是父類或接口定義的引用變量可以指向子類或具體實現類的實例對象，而程序調用的方法在運行期才動態綁定，就是引用變量所指向的具體實例對象的方法，也就是內存里正在運行的那個對象的方法，而不是引用變量的類型中定義的方法。

另： javaEE中的session的理解--
session機制是一種服務器端的機制，服務器使用一種類似于散列表的結構（也可能就是使用散列表）來保存信息。在服務器上，通過Session來區分每一個上網用戶用戶只要一連接到服務器，則立刻分配一個Session給用戶
Session主要方法：

1 服務器上通過Session來分別不同的用戶-->Session ID

任何連接到服務器上的用戶，服務器都會位之分配唯一的一個不會重復的Session ID
Session ID是由服務器統一管理的，人為不能控制
方法：session.getID();
長度：32

2 判斷是否是新的Session
public boolean isNew();
判斷當前的Session是否是新建立的Session

3 Session的屬性設置
設置屬性:public void setAttribute(String name,Object value)
取得屬性:public Object getAttribute(String name)
刪除屬性:pbulic void removeAttribute(String name)
4 登陸驗證
通過Session能夠對用戶是否登陸做出驗證
public void putValue(String name,Object)-->setAttribute
public Object getValue(String name)-->getAttribute
public removeValue(String name)-->removeAttribute
此三個方法已經過時，不建議再使用

注銷用戶：讓用戶的Session失效
如果Session失效，則在Session所保留的全部操作也會消失
public void invalidate()使Session失效（手工）
如果Session長時間不被使用，則也會自動失效
5 得到Session的創建時間
public long getCreationTime()
此方法返回long類型，通過new Date()可以取得一個完成時間
取得用戶最后操作的時間：public long getLastAccessedTime();

6 總結
Session將信息保存在服務器上，而Cookie保存在客戶端上
Session比Cookie更安全，Session比Cookie更占資源
開發原則：Session要盡量少用--盡量少向Session中保存信息
session使用了Cookie的機制，如果Cookie被禁用，則Session也無法使用,因為客戶端的session ID以cookie形式,保存在了客戶端的內存當中,這個時候我們可以通過url重寫,來保證session的有效性.

重寫url的方法如下

resp.encodeURL(request.getRequestURL().toString()); http://phl.iteye.com/blog/699574

轉載：
感覺網站最好不要依賴session

session 在做多服務器負載的時候

會有點麻煩

直接用 cookie + 第三方緩存比較的好...

自己在兩個公司呆過后得出的結論,純屬個人體會 ...

posted @ 2012-08-07 21:19 leoChiang 閱讀(184) | 評論 (0) | 編輯收藏

java作用域以及多態

作用域	當前類	同一package	子孫類	其他package
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

關于overload與override的區別：
overload是重載，意思是我們可以定義一些名稱相同的方法，通過定義不同的輸入參數來區分這些方法，然后再調用時，VM就會根據不同的參數樣式，來選擇合適的方法執行。方法重載支持多態性，因為它是Java 實現“一個接口，多個方法”范型的一種方式。要理解這一點，考慮下面這段話：在不支持方法重載的語言中，每個方法必須有一個惟一的名字。但是，你經常希望實現數據類型不同但本質上相同的方法。
1）使用重載時必須使用不同的參數樣式
2）對于繼承來說，如果某一方法在父類中是訪問權限是private，那么就不能在子類對其進行重載，如果定義的話，也只是定義了一個新方法，而不會達到重載的效果。
override是重寫（比如說對接口的重寫，繼承中子類重寫父類的方法）。
1）覆蓋的方法的標志必須要和被覆蓋的方法的標志完全匹配，才能達到覆蓋的效果；

2）覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；

3）覆蓋的方法所拋出的異常必須和被覆蓋方法的所拋出的異常一致，或者是其子類；

4）被覆蓋的方法不能為private，否則在其子類中只是新定義了一個方法，并沒有對其進行覆蓋。

關于抽象類（abstract）
所有的對象都是通過類來描述的，然而，所有的類不一定是通過對象來描述清楚，因此不能描述的這些類定義為抽象類。
抽象類與接口緊密相關。然接口又比抽象類更抽象，這主要體現在它們的差別上：1）類可以實現無限個接口，但僅能從一個抽象（或任何其他類型）類繼承，從抽象類派生的類仍可實現接口，從而得出接口是用來解決多重繼承問題的。2）抽象類當中可以存在非抽象的方法，可接口不能且它里面的方法只是一個聲名必須用public來修飾沒有具體實現的方法。3）抽象類中的成員變量可以被不同的修飾符來修飾，可接口中的成員變量默認的都是靜態常量（static final）。4）這一點也是最重要的一點本質的一點"抽象類是對象的抽象，然接口是一種行為規范"。
package core_java;

abstract class Ch{
    public abstract void doSome();
}

class A extends Ch{
    public void doSome(){
        System.out.println("a");
    }
}

class B extends Ch{
    public void doSome(){
        System.out.println("b");
    }
}

public class TestAbstract {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Ch aa = new A();
        Ch bb = new B();

        A aaa = new A();
        B bbb = new B();
        aa.doSome();
        bb.doSome();
        aaa.doSome();
        bbb.doSome();

        doSomething(aa);
        doSomething(bb);
        doSomething(aaa);
        doSomething(bbb);
    }

    public static void doSomething(Ch a){
        a.doSome();
    }

}

posted @ 2012-08-06 09:27 leoChiang 閱讀(276) | 評論 (0) | 編輯收藏

冒泡排序與選擇排序與倒序排序

package core_java;
import java.util.Scanner;

public class ExchangeArray {

    /**
     * @param args
     */
    public static int[] split2array(String str){
        String[] m = null;
        m = str.split(",");
        int[] a = new int[m.length];
        for(int i=0;i<m.length;i++){
            a[i] =  Integer.parseInt(m[i]);
        }
        return a;
    }

    public static int[] exchange(int[] a){
        int[] b = new int[a.length];
        for(int j=0;j<a.length;j++){
            b[j]=a[a.length-1-j];
        }
        return b;
    }
    public static int[] bubsort(int[] a){//冒泡排序
        int[] b = a;
        for (int i = 0; i < b.length; i++) {
            for(int j=i;j<b.length;j++){
                int temp;
                if(b[i]<b[j]){
                    temp = b[i];
                    b[i] = b[j];
                    b[j] = temp;
                }
            }

        }
        return b;
    }

    public static int[] selsort(int[] a){//選擇排序
        int[] b = a;
        for (int i = 0; i < b.length; i++) {
            int minIndex = i;//以最小值為基準
            for(int j=i;j<b.length;j++){
                int temp1 = b[minIndex];
                int temp2 = b[j];
                if(temp1>temp2){
                    minIndex = j;
                }
            }
            if(minIndex!=i){
                int temp;
                temp = b[minIndex];
                b[minIndex] = b[i];
                b[i] = temp;
            }
        }
        return b;
    }

    public static void print(int[] a){
        for(int m=0;m<a.length-1;m++){
            System.out.print(a[m]+",");
        }
        System.out.print(a[a.length-1]);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("請輸入序列（以逗號隔開回車結束）：");
        Scanner sc = new Scanner(System.in);
        String ss = sc.nextLine();
        String[] o = ss.split(",");
        System.out.println("原序列：");
        for (int i = 0; i < o.length-1; i++) {
            System.out.print(o[i]+",");
        }
        System.out.println(o[o.length-1]);
        int[] r = exchange(split2array(ss));
        System.out.println("處理后的序列：");
        for(int m=0;m<r.length-1;m++){
            System.out.print(r[m]+",");
        }
        System.out.println(r[r.length-1]);
        System.out.println("選擇排序后的結果：");
        print(selsort(r));
        /*System.out.println();
        System.out.println("冒泡排序后的結果：");
        print(bubsort(r));*/
    }

}

注意其中的異常：
數組越界異常 ArrayIndexOutOfBoundsException
空指針異常 NullPointerException

posted @ 2012-08-02 17:57 leoChiang 閱讀(237) | 評論 (0) | 編輯收藏

java中的hashcode與內存地址與“==”

首先，hashCode就是一種查找的索引值。就好比一個數組，你用數組下標來查找你的數組元素，同樣，hashCode來查找hashTable中的存儲元素。當然，作為散列方式的查找和存儲，要比數組這種線性數據結構復雜的多。這涉及到hash函數的構造， hash Collision等問題，數據結構中。

而每個對象在內存當中的存儲組織方式就是利用這種散列方式存儲，當然也就有它的 hashCode了，如果想獲取這個對象在Hash表中的位置，就可以調用 Object.hashCode() 結果返回int型。還有一點需要注意的是：hashcode 相等，則對象一定一樣；hashcode 不相等，對象也可能相等（不是相同），如果對于不等的對象構造不同的hashCode那么將會提高 hash表的性能。（具體原因可以查看數據結構中hash表的構造方式）
下面的兩個程序是hashcode的理解：
student.java

package core_java;

public class Student {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public int hashCode(){
        return 7*name.hashCode()+13*age;
    }

}

在同一個包下 Testhashcode.java

package core_java;

public class Testhashcode {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student stu1 = new Student("aa",17);
        Student stu2 = new Student("aa",17);

        System.out.println(stu1);
        System.out.println(stu2);

        System.out.println(stu1 == stu2);

    }

}

得出的結果：

core_java.Student@55bd

false
說明：1.system.out.println(Object)輸出的是Object.toString(),Student類重寫了hashcode方法，如果不重寫則結果不一樣
2.== 比較的不僅僅是對象在虛擬機中的內存地址
深入了解hashcode與內存分配：

HashCodeMeaning.java

package com.leo.test.action;

import java.util.ArrayList;

/**
* @author      MK
*
* 此方法的作用是證明 java.lang.Object的hashcode 不是代表對象所在內存地址。
* 我產生了10000個對象，這10000個對象在內存中是不同的地址，但是實際上這10000個對象
* 的hashcode的是完全可能相同的
*/
public class HashCodeMeaning {
    public static void main(String[] args) {
        ArrayList list =  new ArrayList();
        int numberExist=0;

        //證明hashcode的值不是內存地址
        for (int i = 0; i < 10000; i++) {
            Object obj=new Object();
            if (list.contains(obj.toString())) {
                System.out.println(obj.toString() +"  exists in the list. "+ i);
                numberExist++;
            }
            else {
                list.add(obj.toString());
            }
        }

        System.out.println("repetition number:"+numberExist);
        System.out.println("list size:"+list.size());

        //證明內存地址是不同的。
        numberExist=0;
        list.clear();
        for (int i = 0; i < 10000; i++) {
            Object obj=new Object();
            if (list.contains(obj)) {
                System.out.println(obj +"  exists in the list. "+ i);
                numberExist++;
            }
            else {
                list.add(obj);
            }
        }

        System.out.println("repetition number:"+numberExist);
        System.out.println("list size:"+list.size());
    }
}

運行輸出結果：

java.lang.Object@922804 exists in the list. 1778

java.lang.Object@e29820 exists in the list. 2077

repetition number:2

list size:9998

repetition number:0

list size:10000

說明：
存入hashcode到list中時不同對象的hashcode有可能相等，而不同對象的內存地址是不相等的

現在腦子里還有點混亂需要深刻理解下。
哪位可以給我點詳細的資料啊？

補充：

如果一個類沒有自己定義equals方法，它默認的equals方法（從Object 類繼承的）就是使用==操作符，也是在比較兩個變量指向的對象是否是同一對象，這時候使用equals和使用==會得到同樣的結果，如果比較的是兩個獨立的對象則總返回false。如果你編寫的類希望能夠比較該類創建的兩個實例對象的內容是否相同，那么你必須覆蓋equals方法，由你自己寫代碼來決定在什么情況即可認為兩個對象的內容是相同的。

posted @ 2012-08-01 18:37 leoChiang 閱讀(4357) | 評論 (1) | 編輯收藏

基于昨天的問題，思考java String中漢字的問題或者說是雙字節字符的問題

首先，判斷一個字符串中是否含有雙字節字符：

1 String str = "test中文漢字";
2 String regEx = "[//u4e00-//u9fa5]";
3
4 /**
5 * 判斷有沒有中文
6 */
7 if (str.getBytes().length == str.length()) {
8     System.out.println("無漢字");
9 } else {
10     System.out.println("有漢字");
11 }
12
13 /**
14 * 如果有則打印出來
15 */
16 Pattern p = Pattern.compile(regEx);
17 Matcher m = p.matcher(str);
18 while (m.find()) {
19     System.out.print(m.group(0) + "");
20 }

其次，是關于昨天的面試題街區字符串的問題：

package core_java;

public class StringInter {
    public static boolean vd(char c){

        boolean isGB2312=false;
        byte[] bytes=(""+c).getBytes();
        if(bytes.length==2){
                    int[] ints=new int[2];
                    ints[0]=bytes[0]& 0xff;
                    ints[1]=bytes[1]& 0xff;
                    if(ints[0]>=0x81 && ints[0]<=0xFE && ints[1]>=0x40 && ints[1]<=0xFE){
                        isGB2312=true;
                    }
        }

        return isGB2312;
    }
    static String Interception(String ss, int nn) {
        if( nn > (ss.length())) nn = (ss.length());
        for(int i=0; i <= ss.length(); i++){
            //System.out.print("now nn is " +nn + "\n");
            if( nn <= 0 ) return ss;
            char t = ss.charAt(i);
            if(vd(t)) {    //說明是漢字 nn減二
                if(nn == 1) return ss;
                System.out.print(t);
                nn-=2;
            }
            else {                // 非漢字，nn減一
                System.out.print(t);
                nn--;
            }
        }
        return ss;
    }
    public static void main( String args[] ) {
        String a = "aま哈abcdefg";
        // length() =    charAt(0..)
        //asd我是System.out.print(a.length());
        //Scanner in = new Scanner(System.in);
        //String s = in.nextLine();
        //int n = in.nextInt();
        Interception(a, 2);
    }
}

posted @ 2012-07-31 16:10 leoChiang 閱讀(627) | 評論 (0) | 編輯收藏

java基本數據類型的理解

在Java中有8種基本數據類型，其中6種是數值類型，另外兩種分別是字符類型和布爾類型。而6種數值類型中有4種是整數類型，另外兩種是浮點類型
基本數據類型
......................數值型
................整數類型（byte 1字節 short 2字節 int 4字節 long 8字節）
................浮點類型（float 4字節 double 8字節）

......................字符型（char 2字節存儲unicode編碼的字符）

......................布爾型（boolean。。。true or false）

試題一

1 switch(expr)

expr只能為整數或枚舉類型類型轉換由低級到高級。。。（byte short char int）
試題二

編寫一個截取字符串的函數，輸入為一個字符串和字節數，輸出為按字節截取的字符串。但是要保證漢字不被截半個，如"我ABC"4，應該截為"我AB"，輸入"我ABC漢DEF"6，應該輸出"我ABC"，而不是"我ABC+漢的半個"。

1 package core_java;

2 import java.util.Scanner;
3
4 public class InterceptionStr {
5
6     /**
7      * @param args
8      */
9     static String ss;
10     static int n;
11     public static void Interception(String[] string){
12         int count = 0;
13         String m = "[\u4e00-\u9fa5]";
14         //漢字的正則表達式
15         System.out.println("以每"+ n +"字節劃分的字符串如下所示：");
16         for (int i = 0; i < string.length; i++) {
17             if(string[i].matches(m)){
18                 count = count + 2;
19             }else{
20                 count = count + 1;
21             }
22             if(count<n){
23                 System.out.print(string[i]);
24             }else if(count==n){
25                 System.out.print(string[i]);
26                 count = 0;
27                 System.out.println();
28             }else{
29                 count = 0;
30                 System.out.println();
31             }
32         }
33
34     }
35     public static String[] setValue(){
36         //此方法將字符串轉化為字符串數組
37         String[] str = new String[ss.length()];
38         //創建字符數組
39         for (int i = 0; i < str.length; i++) {
40             str[i] = ss.substring(i, i+1);
41         }
42         return str;
43     }
44     public static void main(String[] args) {
45         // TODO Auto-generated method stub
46         System.out.println("請輸入字符串：");
47         Scanner scStr = new Scanner(System.in);
48         ss = scStr.next();
49         System.out.println("請輸入字節數：");
50         Scanner scByte = new Scanner(System.in);
51         n = scByte.nextInt();
52         Interception(setValue());
53
54     }
55
56 }
57

得出的結果是截取的一段一段的，比題目給出的豐富了點

posted @ 2012-07-30 14:06 leoChiang 閱讀(224) | 評論 (0) | 編輯收藏

leochiang

常用鏈接

留言簿

隨筆分類

隨筆檔案

java筆試題

搜索

最新評論

閱讀排行榜

評論排行榜