Java SE 開篇

1、  Java SE 開篇

 

1.  Java 基本數據類型及其對應的包裝類

基本數據類型        對應的包裝類
 * byte             Byte
 * boolean          Boolean
 * char             Character
 * int              Integer
 * long             Long
 * short            Short
 * float            Float
 * double           Double

1.2  自動裝箱和自動拆箱

// 1.自動裝箱：
// 基本類型自動封裝到對應的包裝類對象中，如：
Integer i = 100;
// 本質上編譯器編譯時添加了：
Integer i = new Integer(100);
 
// 2.自動拆箱：
// 包裝類對象自動轉換成對應的基本類型數據，如：
int a = new Integer(100);
// 本質上編譯器編譯時添加了：
int a = new Integer(100).intValue();

 

2.  Java 封裝

          同一個類       同一個包       子類       全部類
 private     √
 default     √             √
 protected   √             √           √
 public      √             √           √          √ 

 封裝要點：
 * 1.屬性成員通常使用 private
 * 2.提供相應的 getter/setter 方法來訪問相關屬性，這些方法一般是 public（注意：boolean 變量的 getter 方法是用： is 開頭！）
 * 3.只用於本類的輔助性方法用 private，但願其餘類可以調用的方法使用 public

 

3.  關鍵字

1. static 用於聲明靜態方法和靜態成員
   注意：在 static 方法中可直接訪問 static 聲明的成員；不能夠直接訪問非 static 的成員，只能先實例化對象才能進行訪問！

2. final 一般用於聲明常量
   注意：不能繼承用 final 修飾的類，不能對用 final 定義的方法進行重寫！

3. this 調用本類中的屬性和方法
   注意：this 不建議用於調用本類中用 static 聲明的屬性和方法上； this();必須位於重載的構造方法中的第一句,來調用無參構造器！

4. super 是對直接父類對象的引用。能夠經過 super 來訪問父類中被子類覆蓋的方法和屬性。任何類的構造函數中，Java 默認都會調用 super(); 
   注意：super(); 必須位於子類構造方法的第一句！

5. instanceof 用於判斷一個對象是不是指定類的一個實例，用法：boolean ins = object instanceof class;
   注意：object 必須是對象的引用，不能是基本數據類型

 

4.  構造器

構造器，又稱構造方法,是一種特殊的方法
 * 格式：public + 類名(){}
 * 1.經過 new 關鍵字調用
 * 2.構造方法名必須和類名一致！
 * 3.做用：構造該類的對象，常常用來初始化對象的屬性
 * 4.不能定義返回值類型，也不能在裏面使用 return
 * 5.構造方法也能夠重載

 

5.  抽象類

抽象類 abstract，爲全部子類提供一個通用的模板
 * 要點：
 * 1.含有抽象方法的類必定是抽象類，因此在定義時必須定義成抽象類！
 * 2.抽象類不能實例化，即不能用 new 來實例化抽象類
 * 3.抽象類只能用來被繼承 extends
 * 4.抽象方法必須經過子類重寫
 * 5.抽象類中能夠包含屬性，非抽象方法，構造方法等
 * 6.聲明抽象方法不可寫出大括號

public abstract class Animal {
    public static final int MIN_VALUE = 100;
    private String name; 
    public abstract void fun();
    public Animal(){
        System.out.println("建立一個動物對象");
    }
    public void hello(){
        System.out.println("hello,abstract!");
    }
}

 

6.  接口

接口 interface
 * 接口比抽象類更加的「抽象」，意義在於規範設計和實現代碼分離
 * 接口中只有：常量，抽象方法！
 * 接口能被子類實現 implements
 * 普通類只能單繼承，可是接口支持多繼承！
 * 不能實例化，即不能用 new 來實例化

public interface MyInterface {
    // 接口中只有：常量，抽象方法
    // 定義常量：public static final ...，可省略
    String MAX_GREAD = "BOSS";
    int MAX_SPEED = 100;
    // 定義方法：public abstract ...，可省略
    void test01();
    int test02(int a, int b);
}

// 接口支持多繼承
interface Interface03 extends Interface01, Interface02 ...{
}

 

7.  多態性

1. 多態性是 OOP 中的一個重要特性，主要是用來實現動態聯編的。換句話說，就是程序最終狀態只有在執行過程當中才能被決定，而不是在編譯期間就決定，這對於大型系統來講能提升系統的靈活性和擴展性
2. 多態的存在要有 3 個必要條件：
  a.要有繼承   b.要有方法重寫    c.父類引用指向子類對象

public class Fruit {
    private String color;
    public void name(){
        System.out.println("fruit");
    }
}
public class Apple extends Fruit{ // 繼承
    @Override
    public void name(){ // 重寫父類方法
        System.out.println("apple");
    } 
}
public class Test{
    public static void main(String[] args) {
        Fruit f = new Apple(); // 父類引用指向子類對象
        f.name();
    }
}  
// 運行結果：apple

 

8.  內部類

內部類分爲靜態內部類和動態內部類
 * 1.內部類使用的場合：因爲內部類提供了更好的封裝性，而且能夠很方便的訪問外部類的屬性。因此，一般在只爲所在外部類提供服務的狀況下優先使用內部類
 * 2.內部類被當成其所在外部類的內部屬性
 * 3.動態內部類能夠直接訪問外部類的私有屬性和方法；靜態內部類只能直接訪問外部類的靜態屬性和靜態方法，訪問非靜態成員須要實例化外部類對象
 * 4.內部類不容許除了其所在的外部類之外的其餘類直接訪問

public class TestInnerclass {
    public static void main(String[] args) {
        // 其餘類訪問動態內部類，先實例化外部類對象，再實例化動態內部類
        World w = new World();
        Human human = w.new Human();
        human.hello();
        
        // 其餘類訪問靜態內部類，直接實例化靜態內部類對象
        Animal animal = new World.Animal();
        animal.hello();
    }
}

public class World{
    private String hi = "hello";
    public void say(String name){
        System.out.println("hello,"+name);
    }
    // 動態內部類
    class Human{
        String name = "man";
        void hello(){
            //動態內部類直接訪問所在外部類的私有屬性和方法
            System.out.println(hi);
            say(name);
        }
    }
    // 靜態內部類
    static class Animal{
        String name = "animal";
        void hello(){
            //靜態內部類訪問所在外部類的非靜態屬性和非靜態方法必須先實例化外部類對象            
            World w = new World();
            System.out.println(w.hi);
            w.say(name)；
        }
    }
}

 

9.  匿名內部類

匿名內部類，一種特殊的內部類，是一個沒有顯式的名字的內部類
 * 1.匿名內部類會隱式的繼承一個類或者實現一個接口
 * 2.經常使用於在多線程的實現上，由於要實現多線程必須繼承 Thread 類或是實現 Runnable 接口
 * 3.匿名內部類只能訪問 final 修飾的所在外部類變量及方法參數
 * 4.接口自己是不能夠經過 new 來實例化的,其實匿名內部類是對接口的實現類的實例化

// Thread 類的匿名內部類
public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 6; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}


// Runnable 接口的匿名內部類
public class Demo {
    public static void main(String[] args) {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 6; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }
}
//運行結果：1 2 3 4 5 6

 

10.  異常處理

1. JDK 中定義了不少異常類，全部的異常對象都是派生於 Throwable 類的一個實例，若是內置的異常類不能知足須要，還能夠建立本身的異常類
 *                    Throwable
 *                    /        \
 *                Error         Exception
 *                  /           /         \
 * Unchecked Exception  Checked Exception   Runtime Exception
 *                                                   |
 *                                             Unchecked Exception   

   
2. 使用異常機制建議：
 * 1.只在異常狀況下使用異常機制，避免使用異常處理代替錯誤處理，這樣會下降程序的清晰性，而且效率低
 * 2.應該將整個任務包裝在一個 try 語句中，不要進行小顆粒的異常處理，即一個 try 語句能夠伴隨多個 catch，不要一個 catch 一個 try 
 * 3.異常每每在高層處理  

3. Checked exception 異常的處理方法之一：捕獲異常處理，try{...}catch(Exception e){e.printStackTrace();}finally{...}
 * 「親自處理」
 * 
 * 1.try 語句指定代碼就是一次捕獲並處理的範圍
 * 2.每一個 try 語句能夠伴隨一個或多個 catch 語句，用於處理可能產生的不一樣類型異常
 * 3.當異常處理的代碼執行後，是不會回到 try 語句去執行還沒有執行的代碼
 * 
 * 4.catch 經常使用的方法：
 *   e.printStackTrace();// 用來跟蹤異常事件發生時堆棧的內容
 *   e.getMessage();// 只顯示產生異常的緣由，但不顯示異常的類名
 *   e.toString();// 顯示異常的緣由和異常的類名
 *   這些方法均繼承自 Throwable 類
 *   
 * 5.catch 捕獲異常的順序：若是異常類之間有繼承關係，在順序安排上需注意：
 *   越是頂層的類，越放在下面，即越是父類，越放下面
 *   如：IOException 是 FileNotFoundException 的父類，若是父類在前面是不會去 catch 子類異常
 *   再否則就直接把多餘的 catch 省掉
 *   
 * 6.finally 指定段的語句，不論是否發生異常，都必須執行！
 *   一般經過 finally 來「關閉程序塊已打開的資源」，好比：關閉IO流、釋放數據庫鏈接等  
 *   
 * 7.執行順序：try，catch，return  ——> 執行 finally * 8.由執行順序可知：不要在 finally 中使用 return 語句，由於會覆蓋掉 try 語句中的存在的 return 語句

4. Checked exception 異常的處理方法之二：聲明異常，throws
 * 「誰調我,誰處理」
 *
 * 1.當 Checked exception 產生時，不必定要馬上處理它，能夠把異常 throws 出去
 * 2.當一個方法出現多個 Checked exception，就必須在方法首部列出全部異常，之間用逗號隔開
 * 
 * 3.@Override 方法重寫時聲明異常的規則：
 *   1.父類方法沒有聲明異常，子類方法也不能聲明異常；
 *   2.子類方法不可拋出父類方法拋出異常類的父類或更上層類；
 *   3.子類方法拋出的 異常類型的數目 不能夠比父類方法拋出的還多（指不一樣異常類型個數）

5. Checked exception 異常的處理方法之三：手動拋出異常，throw
 * 對於一個已經存在的異常類，手動拋出異常對象過程以下：
 * 1.找到一個合適的異常類
 * 2.建立一個該類的對象
 * 3.將異常對象拋出

File f = new File("C:/a.txt");
if(!f.exists){
   try{
      throw new FileNotFoundException("File can't be found!");
   }catch(FileNotFoundException e){
        e.printStackTrace();  
   }
}

6. 自定義異常處理
 * 1.遇到標準異常類都沒法充分描述的異常時能夠建立本身的異常類  
 * 2.從 Exception 類或者它的子類派生一個子類便可
 * 3.習慣上，定義的異常類應該包含2個構造器： 「無參構造器」 和 「帶有詳細信息的構造器」

public class MyException extends Exception{
    //無參構造器
    public MyException(){  
    }
    //帶有詳細信息的構造器
    public MyException(String message){
        super(message);    
    }
}