JAVA SE 雜論

概念:
    1.構造函數    //方法與類名相同，無返回值
        class Demo{
            public Demo(){
            }
        }
        在 new 此類對象時，執行構造函數
    2.構造函數塊    //無方法名，返回值，先於構造函數運行
        又稱代碼塊，每次new 運行一次
        class Demo{
            public{
            }
        }
        class Demo{
            {}
        }
    3.重載    //方法與類名相同，無返回值，參數不一樣的方法
        class Demo{
            public Demo(){
            }
            public Demo(int i){
            }
            public Demo(String str){
            }
        }
    4.遞歸        //函數本身調用本身
    5.外部類名.內部類名 名字 = new 外部類名().new 內部類名);        //其餘類引用內部類名時
    6.哈希值        //內存地址
    7.哈希表
        //存放內存地址的表，以地址的值爲順序，當存放地相同但對象不一樣時，在此地址下開一空間存放相同地的對象
    8.靜態     //會在上一級運行時直接在物理內存中使用一個位置
        8.1.靜態代碼塊，在虛擬機運行時就會加載，並且只會加一次
            class Demo{
                static{
                }
            }
        8.2.靜態方法
            在外部調用靜態方法時，可使用"類名.方法名"的方式，也可使用"對象名.方法名"的方式。
            而實例方法只有"對象名.方法名"。也就是說，調用靜態方法能夠無需建立對象。
            靜態方法在訪問本類的成員時，只容許訪問靜態成員（即靜態成員變量和靜態方法），
            而不容許訪問實例成員變量和實例方法；實例方法則無此限制。
            public static void demo{}
    9.沒有提供構造方法
        9.1.說明不能 new 對象，能想到該類中方法都是靜態的
        9.2.發現該類中還有非靜態方法
        9.3.說明該類確定會提供方法獲取本類對象，並且該方法是靜態的，並返回類型是本類型
    10字段
        類名.方法         //字段的使用
        字段內的方法都爲靜態
    11.文件
        沒法訪問隱藏文件
        刪除時直接刪除，不通過回收站
    12.反射
        經過一個類名來探察這個類裏面的信息，
            好比說類的屬性名，屬性名的修飾符，方法名，方法返回值，方法修飾符等等，
            反正除了方法體得不到，其餘均可以用反射獲得；
            反射還能夠生成類的實例，經過這個實例定義屬性，調用方法，
            特別是能調用私有的屬性和私有的方法。

符號
    1.(a==b)?a:b; 等同於 if(a==b){a}else{b}
    2.&&    //與
    3.||    //或
    4.!    //非
    5.>>    //將數字轉爲二進制右移？位
            不帶符號
            int的寬度爲32位
            8：
            0000 0000 0000 0000 0000 0000 0000 1000
            8>>1
            0000 0000 0000 0000 0000 0000 0000 0100 十進制爲4
            i >> n :     i / (2^n)
        >>>    //將數字轉爲二進制右移？位
            帶符號右移
            -7：
            1111 1111 1111 1111 1111 1111 1111 1001
            -7>>>1：
            0111 1111 1111 1111 1111 1111 1111 1100 十進制爲214748364
    6.<<    //將數字轉爲二進制左移
            i<<n:   i * (2^n)
        <<<    //帶符號左移

描述
    abstract      //抽象   //無具體描述
    static         //靜態   //函數一運行就存在於內存中
    instanceof     //判斷類型      if(i instanceof int) //i類型是否爲int
    implements      //實現，鏈接接口，(某函數實現接口)
    interface    //接口，描述類，裏面方法全是抽象，開放。變量全是開放，靜態，常量
    protected    //訪問範圍是子類
    private        //只能是本類
    public        //能夠是子類，同一個包中均可以訪問。

泛型
        //JDK1.5版本之後出現新特性，用於解決安全問題，是一個安全機制
        在集合中比較常見
        ArryList<String> al = new ArrayList<String>();
    1.<類型>    //指定輸入元素類型
        <String>    //指定輸入元素String類型
        <?>    //不明確具體類型,佔位符與<T>效果相似
    2.好處
        將運行時期出現的問題ClassCastException,轉移到編譯時期，方便與程序員解決問題
        避免強制轉換麻煩
    3.泛型類
        何時定義泛型類？
        當類中要操做的引用數據類型不肯定的時候,由引用方來定義類型
        早期定義的Object來完成擴展
        如今定義泛型類來完成擴展
        class Utiles<QQ>{        //QQ爲自定義泛型
            private QQ q;        
            public void setObject(QQ q){
                this.q = q;
            }
            public QQ getObject(){
                return q;
            }
        }
        Utils<Student> stu = new Utils<Student>();    //自定義學生類型
            但明確類型後下面方法只能是這個類型，不然只能在新建一個類
    4.泛型方法
            自由度比泛型方法高
            class Demo{
                public <T> void show(T t){
                }
                public <Q> void print(Q q){
                }
            }
            Demo d = new Demo();
            d.show("haha");
            d.show(new Integer(4));
            d.print("Heihei");
        靜態方法泛型
            靜態方法泛型不能夠訪問類上定義的泛型
            若是靜態方法操做的應用數據類型不肯定，能夠將泛型定義在方法上
            class Demo<T>{
                public static <w> void show(T t){
                }
            }
    5.泛型的限定
        ? 通配符，也能夠理解爲佔位符
        ? extends E： 能夠接收E類型或者E的子類型，上限
        ? super E： 能夠接收E類型或者E的父類型，下限
        
        public static void printColl(ArrayList<? extends E> all){}
        public static void printColl(ArrayList<? super E> all){}

 

異常
    java.lang.Throwable
            java.lang.Object
              java.lang.Throwable
            異常所在類，包
        Exception    //異常
            RuntimeException    //執行異常
                ClassCastExcepion    //類型轉換異常
            CheckedException    //檢查異常
                除了runtimeException之外的異常，
            IOException         //I/O 異常
                FileNotFoundException
            方法
                printStackTrace        //輸出異常信息
                    try{}
                    catch( Exception e ){
                        e.printStackTrace(System.out)}       //在控制檯輸出錯誤信息
                        e.printStackTrace(new printStream("demo.txt"));} //將錯誤信息傳入demo.txt文件內  
    將編譯時異常轉爲運行時異常
        throw new RuntimeException(e)
    處理異常
        try{}
            catch( Exception e ){}
    拋出異常
        throw new RuntimeException("***")        //拋異常

 

特殊
    ...      //可變參數
        public void demo(int... arr){       //使用方式，int 能夠爲任意類型
            System.out.println(arr.length);        //返回數組長度
        }        
        例如：
        demo(1,2,3,4);     demo();
        demo(12345,123,42,13);  //能夠傳入任意長度的 int 類型值
        不能夠:      public void demo(int... arr, String str){}   //error
        能夠:        public void demo(String str, int... arr){}

測試
    junit
        @Before 在方法上添加，每次運行@Test 先運行@Before
        @BeforeClass 在方法上添加，每次運行Junit 先運行@BeforeClass
        @Test 在方法上添加，成爲測試方法
        @After 在方法上添加，每次運行@Test 後運行@After
        @AfterClass 在方法上添加，每次運行 junit 後運行@AfterClass