使用 try-catch語句通過 throws 關鍵字指明要丟擲給方法呼叫

封裝

該漏的漏，該藏的藏
- 我們程式設計要追求“高內聚，低耦合”。高內聚就是將類的內部資料操作細節自己完成，不允許外部的干涉。
- 低耦合：儘量暴露少量的方法給外部使用。
封裝（資料的隱藏）
- 通常，應禁止直接訪問一個物件中資料的實際表示，而應通過操作介面來訪問，這稱為資訊隱藏。
屬性私有，private；get/set；

public class Student {
    //類 private:屬性私有
   private String name;
   private int age;
   private char sex;

   //提供一些可以操作這個屬性的方法
    //public 的 get/set 方法

    //get 獲得這個資料
    public String getName(){
        return this.name;}
        /*
         Student s1 = new Student();
         String name = s1.getName();
         name = "小白";
         System.out.println(name);
         */
    
    //set 給這個資料設定值
    public void setName(String name){
        this.name = name;}
        /*
          Student s1 = new Student();
          s1.setName("小黑");
          System.out.println(s1.getName());
         */
    
    //快捷鍵 alt + insert

繼承

繼承的本質是對某一批類的抽象，從而實現更好地建模
extends的意思是擴充套件。子類是父類的擴充套件
java中類只有單繼承，沒有多繼承！
繼承是類和類之間的關係。除此之外，類和類之間的關係還有依賴、組合、聚合等。
繼承關係的倆個類，一個為子類（派生類），一個為父類（基類）。子類繼承父類，使用關鍵字extends來表示。
子類和父類之間，從意義上講應該具有“is a”的關係。

子類名 + extends + 父類名

Public 公共的
protected受保護的
default預設的
private私有的

public //公共的
protected //受保護的
default //預設的
private //私有的，無法被繼承
//ctrl+h 繼承樹

object類
在Java中，所有的類，都預設、直接或者間接繼承object
super - this
this呼叫當前的類，super呼叫父類。
super注意點：
1. super呼叫父類的構造方法，必須在構造方法的第一個
2. super必須只能出現在子類的方法或者構造方法中
3. super和this不能同時呼叫構造方法
異同：
super：它引用當前物件的直接父類中的成員（用來訪問直接父類中被隱藏的父類中成員資料或函式，基類與派生類中有相同成員定義時如：super.變數名 super.成員函資料名（實參））

**this：**它代表當前物件名（程式中易產生二易性之處，應使用this來指明當前物件；如果函式的形參與類中的成員資料同名，這時需要this來指明成員變數名）
**super（）和this（）**類似，區別是，super（）在子類中呼叫父類的構造方法，this()在本類內呼叫本類的其它構造方法。
super()和this()均需放在構造方法內第一行。
儘管可以用this呼叫一個構造器，但卻不能呼叫兩個。
this和super不能同時出現在一個建構函式裡面，因為this必然會呼叫其它的建構函式，其它的建構函式必然也會有super語句的存在，所以在同一個建構函式裡面有相同的語句，就失去了語句的意義，編譯器也不會通過。
this()和super()都指的是物件，所以，均不可以在static環境中使用。包括：static變數,static方法，static語句塊。
從本質上講，this是一個指向本物件的指標, 然而super是一個Java關鍵字。
方法重寫Override
重寫都是方法的重寫，和屬性無關。
重寫值和非靜態方法有關，靜態沒用，只能Public。
需要有繼承關係，子類重寫父類的方法！
1. 方法名必須相同
2. 引數列表必須相同
3. 修飾符：範圍可以擴大，但不能縮小；public>protected>Default>private
4. 丟擲的異常：範圍，可以被縮小但是不能擴大；ClassNotFoundException<-Exception(大）
  重寫，子類的方法和父類必須一致，但是方法體不同！

為什麼需要從寫

父類的功能，子類不一定需要，或者不一定滿足！
快捷鍵：
Alt + Insert : override;

靜態的方法和非靜態的方法區別很大

多型

父類的引用可以指向子類，但不能呼叫子類獨有的方法。

方法的呼叫只和左邊定義的資料型別有關，和右邊關係不大。

動態編譯：型別：可擴充套件性更強

即同一方法可以根據傳送物件的不同而採用多種不同的行為方式。
一個物件的實際型別是確定的，但可以指向物件的引用的型別有很多（父類，有關係的類）
多型存在的條件
- 有繼承關係的
- 子類重寫父類方法
- 父類引用指向子類物件
注意：
多型是方法的多型，屬於沒有多型性
父類和子類，有聯絡才能轉換，不然會異常！型別轉換異常：ClassCastException
存在條件：繼承關係，方法需要重寫，父類引用指向子類物件！Father f1 = new son();

不能重寫的方法：

static 方法，屬於類，它不屬於例項
final常量，被final修飾的無法修飾，屬於常量池
private私有方法，不能被重寫

instanceof判斷一個物件是什麼型別。（型別轉換一引用型別之間的轉換）
System.out.println（x instanceof y）; ：true or false （能不能編譯通過，看x所指向的實際型別是不是y的子型別）

注意：

父類引用指向子類的物件，不可以子類引用指向父類。
把子類轉換為父類，向上轉型；
把父類轉換為子類，向下轉型，強制轉換
方便方法的呼叫，減少重複的程式碼，簡介

//型別之間的轉化 ： 父---子
//高               低
Person s1 = new Student();
//高轉低可以直接轉；低轉高，需要強制轉
//
Student s2 = (Student) s1;
s2.go();
//或((Student) s1).go();

static關鍵字詳解

private static int age;//靜態的變數，     多執行緒
private double score;  //非靜態的變數

排序，static只執行一次

public class Demo03 {
    //第二載入；適用於賦初值
    {
        System.out.println("匿名程式碼塊");
    }
    //第一載入；只在第一次執行
    static{
        System.out.println("靜態程式碼塊");
    }
    //第三載入
    public Demo03() {
        System.out.println("構造方法");
    }
    public static void main(String[] args) {
        Demo03 s1 = new Demo03();
        System.out.println("==========");
        Demo03 s2 = new Demo03();
    }
}

靜態匯入包

//靜態匯入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Demo03 {
    public static void main(String[] args) {
        System.out.println((int)(Math.random()*50));
        //random()隨機值，整數，範圍（0-50）
        //使用靜態匯入包後可以直接System.out.println(random());
        System.out.println(PI);
    }
}

final修飾的類不能被繼承

抽象類

abstract修飾符可以用來修飾方也可以修飾類，如果修飾方法，那麼該方法就是抽象方法，如果修飾類，就是抽象類
抽象類中可以沒有抽象方法，但是有抽象方法的類一定要宣告為抽象類。
“Abstract method in non-abstract class”
抽象類，不能使用 new 關鍵字來建立物件，它是用來讓子類繼承的。
抽象方法，只有方法的宣告，沒有方法的實現，它是用來讓子類實現的。
子類繼承抽象類，那麼就必須要實現抽象類沒有實現的抽象方法；否者該子類也要宣告為抽象類，然後由子子類實現抽象方法。
報錯“Missing method body, or declare abstract”

介面

**普通類：**只有具體實現
**抽象類：**具體實現和規範（抽象方法都有）！
**介面：**只有規範！自己無法寫方法，專業的約束！約束和實現分離：面向介面程式設計~
介面就是規範，定義的是一組規則，體現了現實世界中“如果你是…則必須能…”的思想。
“如果你是天使，則必須能飛。如果你是汽車，則必須能跑。”
介面的本質是契約就像我們人間的法律一樣。制定好後大家都遵守。
OO的精髓，是對物件的抽象，最能體現這一點的就是介面，為什麼我們討論設計模式都只針對具備了抽象能力的語言（比如c++、java、c#等），就是因為設計模式所研究的，實際上就是如何合理的去抽象。
宣告類的關鍵字是class，宣告介面的關鍵字是interface

作用：

約束，規範
定義一些方法，讓不同的人實現。多人完成共同的工作。
介面中所有預設的方式public abstract
所有常量預設public static final
介面不能被例項化，介面中沒有構造方法
可以實現多個介面
必須要重寫介面中的方法。
宣告介面interface，實現介面implements，可以實現多個方法

import com.ssxxz.oop.Demo09.xiaduan;

public class Application {
    public static void main(String[] args) {
        xiaduan sxmz = new xiaduan();
        sxmz.mingzi("上下沒中");
        sxmz.nianling(31);
        sxmz.shengao(175.8);
        sxmz.zhuzhi("內蒙古");
    }
}
/*
public class xiaduan implements jiekou,jiekou2 {
    @Override//jiekou
    public void mingzi(String name) {
        System.out.println("名字："+name);
    }

    @Override//jiekou
    public void nianling(int nl) {
        System.out.println("歲數："+nl);
    }

    @Override//jiekou
    public void shengao(double sg) {
        System.out.println("身高："+sg);

    }

    @Override//jiekou2
    public void zhuzhi(String zz) {
        System.out.println("住宅："+zz);
    }
}
 */

內部類（擴充套件知識）

內部類就是在一個類的內部在定義一個類，比如A類定義了一個B類，那麼B類相對A類來說就稱為內部類，而A類相對B類來說就是外部類了。

成員內部類；類中加類

//先例項化外部類，再用外部類例項化內部類
Outer outer = new Outer();//new外部
Outer.Inner inner = outer.new Inner();//new內部
inner.in（）；

內部類可以獲得外部類的私有屬性
2.靜態內部類；不能直接訪問非靜態的屬性（static先與非靜態類生成）
3.區域性內部類；

public void method(){
    class inner{
        public void in(){
            
        }
    }
}

匿名內部類；沒有名字去初始化類，不用將例項儲存到變數中

//不起名直接使用
new Apple().eat(); 
//new介面
class Test{
    public static void main(String[] args) {
        new UserService(){
            
        };
    }
}
interface UserService{
    
}

一個java類中，可以有多個 class 類，但只能有一個 public class 類

異常機制

異常定義

實際工作中，遇到的情況不可能是非常完美的。比如：你寫的某個模組，使用者輸入不一定符合你的要求；你的程式要開啟某個檔案，這個檔案可能不存在或者檔案格式不對；你要讀取資料庫的資料，資料可能是空的等；我們的程式再跑著，記憶體或硬碟可能滿了。等等。
軟體程式在執行過程中，非常可能遇到剛剛提到的這些異常問題，我們叫異常，英文是：Exception，意思就是例外。這些，例外情況，或者叫異常，怎麼讓我們寫的程式做出合理的處理，而不至於程式崩潰。
異常值程式執行中出現不期而至的各種狀況，如：檔案找不到，網路連線失敗，非法引數等。
異常發現在程式執行期間，它影響了正常的程式執行流程。
簡單分類
要理解 Java 異常處理是如何工作的，你需要掌握以下三種類型的異常：
- 檢查性異常：最具代表的檢查性異常是使用者錯誤或問題引起的異常，這是程式設計師無法預見的。
- 例如：打卡一個不存在檔案時，一個異常就會發生了，這些異常在編譯時不能被簡單地忽略。
- 執行時異常：執行時異常是可能被程式設計師避免的異常。與檢查性異常相反，執行時異常可以在編譯時被忽略。
- 錯誤 ERROR：錯誤不是異常，而是脫離程式設計師控制的問題。錯誤在程式碼中通常被忽略。編譯時不容易被發現。

例如：當棧溢位時，一個錯誤就發生了，它們在編譯也檢查不到的。

異常體系結構

Java把異常當前物件來處理，並定義一個基礎類java.lang.Throwable 作為所有異常的超類。
在 Java API 中已經定義了許多異常類，這些異常類分為兩大類，錯誤Error和異常Exception 。

Error
Error類物件有Java虛擬機器生成並丟擲，大多數錯誤與程式碼編寫者所執行的操作無關。
Java虛擬機器執行錯誤，當JVM不在有繼續執行操作所需的記憶體資源時，將出現 OutOfMemoryError。這些異常發生時， Java 虛擬機器（JVM）一般會選擇線路終止。
還有發生在虛擬機器試圖執行應用時，如類定義錯誤（NoClassDefFoundError）、連結錯誤（LinkageError）。這些錯誤是不可查的，因為它們在應用程式的控制和處理能力之外，而且絕大多數是程式執行時不允許出現的情況。
Exception
在 Exception 分支中有一個重要的子類 RuntimeException （執行時異常）
- ArrayIndexOutOfBoundsException（陣列下標越界）
- NullPointerException（空指標異常）
- ArithmeticException（算術異常）
- MissingResourceException（丟失資源）
- ClassNotFoundException（找不到類）等異常，這些異常是不檢查異常，程式中可以選擇捕獲處理，也可以不處理。
Error 和 Exception 的區別：Error 通常是災難性的致命錯誤，是程式無法控制和處理的，當出現這些異常時，Java 虛擬機器（JVM）一般會選擇終止執行緒；Exception 通常情況下是可以被程式處理的，並且在程式中應該儘可能的去處理這類異常。

異常處理機制

丟擲異常
捕獲異常
異常處理五個關鍵字
- try、catch、finally、throw、throws
- 可以當出現異常時，捕獲它，防止程式停止。

    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //假設要捕獲多個異常：從小到大！
        try {   //try 監控區域
            System.out.println(a / b);
        } catch (Error e) {   //catch（想要捕獲的異常型別！）捕獲異常
            System.out.println("Error");
        }catch (Exception e){//“e”,代表異常訊息
            System.out.println("Exception");
        }catch (Throwable t){
            System.out.println("Throwable");
        }finally {    //處理善後工作，不管報不報異常，都會執行。
            System.out.println("finally");
        }
        //finally 可以不用，但是catch必須有。finally假設Io,資源，關閉工作
        //快捷鍵：選中需要包裹的程式碼，ctrl+alt+T
        /*
          try {
            System.out.println(a / b);
        } catch (Exception e) {
            System.exit(0);//程式結束
            e.printStackTrace();//列印錯誤的棧資訊
        } finally {
        }
         */
    }

throw

try {
    if (b==0){
        throw new ArithmeticException();//主動的丟擲異常
    }

throws

public static void main(String[] args) {
    try {
        new linshi().test(1,0);
    } catch (ArithmeticException e) {
        e.printStackTrace();
    } finally {
    }
}
//假設這個方法中，處理不了這個異常。方法上丟擲異常throws，由上一級捕獲。
public void test(int a,int b)throws ArithmeticException{
    if (b == 0) {
        throw new ArithmeticException();//throw 主動的丟擲異常,一般在方法內
    }
    System.out.println(a / b);
}

自定義異常

使用Java內建的異常類可以描述在程式設計時出現的大部分異常情況。除此之外使用者還可以自定義異常。使用者自定義異常類，只需繼承 Exception 類即可。
在程式中使用自定義異常類，大體可分為以下幾個步驟：
1. 建立自定義異常類。
2. 在方法中通過 throw 關鍵字丟擲異常物件。
3. 如果在當前丟擲異常的方法中處理異常，可以使用 try-catch 語句捕獲並處理；否則在方法的宣告處通過 throws 關鍵字指明要丟擲給方法呼叫者的異常，繼續進行下一步操作
4. 在出現異常方法的呼叫者中捕獲並處理異常。
自定義異常類

    //自定義異常類
    //假設傳遞數字>10異常
    private int tishi;//建立一個提示資訊

    public Demo01(int a) {//建立一個構造器傳遞訊息
        this.tishi = a;
    }
    //toString列印資訊：異常的列印資訊
    @Override
    public String toString() {
        return "異常{" + "tishi=" + tishi + '}';
    }

throws丟擲方法捕獲

//建立一個可能會存在異常的方法
   static void test(int a) throws Demo01 {
        System.out.println("傳遞的引數為："+a);
        if (a>10){
            throw new Demo01(a);
        }
        System.out.println("ok");
    }

    public static void main(String[] args) {
        try {   //賦值並捕獲
            test(11);
        } catch (Demo01 e) {
            System.out.println("注意："+e);
        }
    }

throw方法內捕獲

//建立一個可能會存在異常的方法
static void test(int a) {
    System.out.println("傳遞的引數為："+a);
    if (a>10){
        try {
            throw new Demo01(a);
        } catch (Demo01 e) {
            System.out.println("注意："+e);;
        }
    }
    System.out.println("ok");
}
public static void main(String[] args) {
    test(15);   //賦值
}

實際應用中的經驗總結

處理執行時異常，採用邏輯去合理規避同時輔助 try-catch 處理
在多重 catch 塊後面，可以加一個 catch（Exception）來處理可能被遺漏的異常
對於不確定的程式碼，也可以加上 try-catch ，處理潛在的異常
儘量去處理異常，切忌只是簡單地呼叫 printStackTrace()去列印輸出
具體如何處理異常，要根據不同的業務需求和異常型別去決定
儘量新增 finally 語句塊去釋放佔用的資源

使用 try-catch語句通過 throws 關鍵字指明要丟擲給方法呼叫

封裝

繼承

多型

抽象類

介面

內部類（擴充套件知識）

異常機制

異常定義

異常體系結構

異常處理機制

自定義異常

實際應用中的經驗總結

使用 try-catch語句通過 throws 關鍵字指明要丟擲給方法呼叫

【資料庫視訊】--waitfor, goto,try……catch 語句

異常體系以及try..catch,finally,throw,throws的使用

java中throws與try...catch的區別點

Java中的try...catch...finally中的return語句的執行

不使用try-catch結構，實現不管輸入是否正確，均輸出“歡迎提出建議！”語句

Java異常處理try-catch-finally以及throw&throws的區別的學習筆記（三）

javaSE 筆記異常 + try...catch... + throws/throw + 自定義異常

java try catch 與 throws 使用場景以及怎麼合理使用？

異常之（丟擲和捕獲、finally的使用、異常的處理機制2：throws、異常的處理機制一：try-catch-finally）

Java基礎19（01）總結IO流，異常try…catch，throws，File類

Java基礎19（02）總結IO流，異常try…catch，throws，File類

multi-catch和try-catch異常處理知識點詳解

Python 生成器，迭代，yield關鍵字，send()傳參給yield語句操作示例

Java異常處理機制try catch流程詳解

通過Python掃描程式碼關鍵字並進行預警的實現方法

Java try catch finally異常處理組合詳解

c語言沒有try catch的替代方案

C# try catch finally

C# try-catch異常捕獲與throw自定義異常例子

使用 try-catch語句通過 throws 關鍵字指明要丟擲給方法呼叫

封裝

繼承

多型

抽象類

介面

內部類（擴充套件知識）

異常機制

異常定義

異常體系結構

異常處理機制

自定義異常

實際應用中的經驗總結

相關推薦