例外處理
Java例外處理的五個關鍵字：try、catch、finally、throw、throws
拋出例外throw
在撰寫程式時，我們必須要考慮程式出現問題的情況
當呼叫方法使用接受到的引數時，首先需要先對引數資料進行合法的判斷，資料若不合法，就應該告訴呼叫者，傳遞合法的資料進來，這時需要使用拋出例外的方式來告訴呼叫者
// 使用格式
throw new 例外類名(引數);
public static void main(String[] args) {
int[] arr = {2,4,52,2};
//根據索引找對應的元素
int index = 4;
int element = getElement(arr, index);
System.out.println(element);
System.out.println("over");
}
/*
* 根據 索引找到陣列中對應的元素
*/
public static int getElement(int[] arr,int index){
//判斷 索引是否越界
if(index<0 || index>arr.length-1){
/*
判斷條件如果滿足，當執行完throw拋出例外物件后，方法已經無法繼續運算
這時就會結束當前方法的執行，并將例外告知給呼叫者，這時就需要通過例外來解決
*/
throw new ArrayIndexOutOfBoundsException("索引越界");
}
int element = arr[index];
return element;
}
而對于呼叫者來說有兩種方法進行處理:
- 進行捕獲處理
- 繼續講問題宣告出去，使用throws宣告處理，
宣告例外throws
宣告例外：將問題標識出來，報告給呼叫者，如果方法內通過throw拋出了編譯時例外，而沒有捕獲處理（稍后講解該方式），那么必須通過throws進行宣告，讓呼叫者去處理
關鍵字throws運用于方法宣告之上,用于表示當前方法不處理例外,而是提醒該方法的呼叫者來處理例外(拋出例外).
宣告例外格式：
修飾符 回傳值型別 方法名(引數) throws 例外類名1,例外類名2…{ }
宣告例外的代碼演示：
public static void main(String[] args) throws FileNotFoundException {
read("a.txt");
}
// 如果定義功能時有問題發生需要報告給呼叫者，可以通過在方法上使用throws關鍵字進行宣告
public static void read(String path) throws FileNotFoundException {
if (!path.equals("a.txt")) {//如果不是 a.txt這個檔案
// 我假設 如果不是 a.txt 認為 該檔案不存在 是一個錯誤 也就是例外 throw
throw new FileNotFoundException("檔案不存在");
}
}
throws用于進行例外類的宣告，若該方法可能有多種例外情況產生，那么在throws后面可以寫多個例外類，用逗號隔開，
public static void main(String[] args) throws IOException {
read("a.txt");
}
public static void read(String path)throws FileNotFoundException, IOException {
if (!path.equals("a.txt")) {//如果不是 a.txt這個檔案
// 我假設 如果不是 a.txt 認為 該檔案不存在 是一個錯誤 也就是例外 throw
throw new FileNotFoundException("檔案不存在");
}
if (!path.equals("b.txt")) {
throw new IOException();
}
}
捕獲例外try…catch
如果例外出現的話,會立刻終止程式,所以我們得處理例外:
- 該方法不處理,而是宣告拋出,由該方法的呼叫者來處理(throws)，
- 在方法中使用try-catch的陳述句塊來處理例外，
try-catch的方式就是捕獲例外，
捕獲例外：Java中對例外有針對性的陳述句進行捕獲，可以對出現的例外進行指定方式的處理，
捕獲例外語法如下：
try{
撰寫可能會出現例外的代碼
}catch(例外型別 e){
處理例外的代碼
}
演示如下：
public static void main(String[] args) {
try {// 當產生例外時，必須有處理方式，要么捕獲，要么宣告，
read("b.txt");
} catch (FileNotFoundException e) {// 括號中需要定義什么呢？
//try中拋出的是什么例外，在括號中就定義什么例外型別
System.out.println(e);
}
System.out.println("over");
}
/*
*
* 我們 當前的這個方法中 有例外 有編譯期例外
*/
public static void read(String path) throws FileNotFoundException {
if (!path.equals("a.txt")) {//如果不是 a.txt這個檔案
// 我假設 如果不是 a.txt 認為 該檔案不存在 是一個錯誤 也就是例外 throw
throw new FileNotFoundException("檔案不存在");
}
}
獲取例外資訊
Throwable類中定義了一些查看方法:
public String getMessage()
// 獲取例外的描述資訊,原因(提示給用戶的時候,就提示錯誤原因
public String toString()
// 獲取例外的型別和例外描述資訊(不用)
public void printStackTrace()
//列印例外的跟蹤堆疊資訊并輸出到控制臺
finally 代碼塊
finally：有一些特定的代碼無論例外是否發生，都需要執行，另外，因為例外會引發程式跳轉，導致有些陳述句執行不到，而finally就是解決這個問題的，在finally代碼塊中存放的代碼都是一定會被執行的，
// finally不可以單獨使用
// 多用于自身需要處理例外,最侄訓需要關閉資源時
try{
} catch{
} finally{
}
自定義例外
例外類如何定義:
- 自定義一個編譯期例外: 自定義類 并繼承于
java.lang.Exception， - 自定義一個運行時期的例外類:自定義類 并繼承于
java.lang.RuntimeException，
練習
// 自定義例外, 當輸入年齡小于0 或 大于200時 拋出例外
class AgeException extends Exception {
public AgeException() {}
public AgeException(String message) {
super(message);
}
}
class Person {
int age;
public void setAge(int age) throws AgeException {
if (age < 0 || age > 200) {
throw new AgeException("年齡非法");
}
this.age = age;
}
}
public class customException {
public static void main(String[] args) throws AgeException {
Person person = new Person();
person.setAge(100);
}
}
Collection集合
集合常用類的繼承體系
這張圖是常用的集合，并非只有這些集合
常用方法
public boolean add(E e)： 把給定的物件添加到當前集合中 ，public void clear():清空集合中所有的元素，public boolean remove(E e): 把給定的物件在當前集合中洗掉，public boolean contains(Object obj): 判斷當前集合中是否包含給定的物件，public boolean isEmpty(): 判斷當前集合是否為空，public int size(): 回傳集合中元素的個數，public Object[] toArray(): 把集合中的元素，存盤到陣列中
public class Demo {
public static void main(String[] args) {
Collection<String> col = new ArrayList<>();
col.add("張三" );
col.add("李四");
col.add("王五");
System.out.println(col);
// 洗掉指定元素, 洗掉成功回傳true, 洗掉失敗回傳false
boolean b = col.remove("劉六");
System.out.println(b);
System.out.println(col);
// 判斷集合是否包含指定元素
boolean b2 = col.contains("張三");
System.out.println(b2);
// 清空集合中的元素
// col.clear();
// System.out.println(col);
// 判斷當前集合是否為空, 長度為0回傳true, 否則回傳false
boolean empty = col.isEmpty();
System.out.println(empty);
// 回傳集合中元素的個數
System.out.println(col.size());
// 將集合轉換為陣列并遍歷
Object[] arr1 = col.toArray();
for (int i = 0; i < arr1.length; i++) {
Object obj = arr1[i];
System.out.println(obj);
}
String[] arr2 = col.toArray(new String[col.size()]);
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
}
}
Iterator
要遍歷Collection集合,除了可以將其轉換為陣列,還可以獲取該集合迭代器完成迭代操作
public Iterator iterator()
// 獲取集合對應的迭代器，用來遍歷集合中的元素的
// 迭代：即Collection集合元素的通用獲取方式
// 在取元素之前先要判斷集合中有沒有元素
// 如果有，就把這個元素取出來，繼續判斷，如果還有就再取出來
// 一直把集合中的所有元素全部取出，這種取出方式專業術語稱為迭代，
常用方法
E next()
// 回傳迭代的下一個元素，
boolean hasNext()
// 如果仍有元素可以迭代，則回傳 true
void remove()
// 洗掉當前next指向的元素
Iterator<String> it = col.iterator();
while (it.hasNext()) {
String next = it.next();
System.out.println(next);
if (next.equals("王五")) {
// 當迭代器在迭代的同時, 集合修改了自身的長度
// 就會拋出 ConcurrentModificationException 并發修改例外
// col.add("劉六");
System.out.println(col);
// 洗掉當前next指向的元素
it.remove();
}
}
泛型
/*
泛型
定義泛型
泛型可以定義在 介面/類/方法 上, 將資料型別作為引數傳遞
泛型介面:
定義實作類時, 直接確定泛型的資料型別
定義實作類時, 不確定泛型的資料型別 實作類也是泛型類 創建實作類物件時 確定資料型別
使用
創建集合 指定集合中元素的型別, 就是在使用泛型
好處
明確集合中元素的資料型別
將運行時例外提前到編譯時錯誤
避免強制型別轉換的麻煩
泛型的通配符
?
泛型的限定
? extends 類: 上限限定 只能傳這個類 及其子型別別
? extends super 類: 下限限定 只能傳這個類 及其父型別別
*/
public class Demo {
public static void main(String[] args) {
// 創建物件時 確定泛型的型別為Integer
MyClass<Integer> myClass1 = new MyClass<>(12);
System.out.println(myClass1.getName());
// 創建物件時 確定泛型的型別為String
MyClass<String> myClass2 = new MyClass<>("小明");
System.out.println(myClass2.getName());
System.out.println("======================");
// 泛型方法的呼叫, 呼叫方法時 確定arg的型別為Integer
myClass1.method(1,12);
// 呼叫方法時 確定arg的型別為String
myClass1.method(1,"");
System.out.println("========================");
new A().method("張三", 16);
new B<Character, String>().method('四', "18");
System.out.println("=========================");
ArrayList<String> stringArrayList = new ArrayList<String>();
stringArrayList.add("aaa");
stringArrayList.add("nnn");
ArrayList<Integer> intArrayList = new ArrayList<Integer>();
intArrayList.add(1);
intArrayList.add(2);
// 定義方法 使兩個集合都可以作為引數傳入并遍歷
show(stringArrayList);
show(intArrayList);
System.out.println("=========================");
ArrayList<Animal> animals = new ArrayList<>();
ArrayList<Cat> cats = new ArrayList<>();
ArrayList<Dog> dogs = new ArrayList<>();
animals.add(new Animal());
animals.add(new Animal());
cats.add(new Cat());
cats.add(new Cat());
dogs.add(new Dog());
dogs.add(new Dog());
show(dogs);
show(cats);
show(animals);
}
// 泛型的通配符
public static void show(ArrayList<?> arrayList){
// 不能使用?作為變數的資料型別, 所以使用Object
for (Object obj: arrayList) {
// 由于是Object型別, 不能呼叫對應型別的特有方法
System.out.print(obj + " ");
}
System.out.println();
}
// 泛型的限定
public static void show2(ArrayList<? extends Animal> arrayList) {
for (Object animal : arrayList) {
Animal animals = (Animal)animal;
animals.eat();
}
}
}
// 定義泛型類
class MyClass<A> {
private A name;
public MyClass(A name) {
this.name = name;
}
public A getName() {
return name;
}
// 定義泛型方法
public <arg>void method(A attribute, arg arg) {
System.out.println(attribute.getClass());
System.out.println(arg.getClass().getSimpleName());
}
}
// 定義反應介面
interface MyInterface<k,v> {
public abstract void method(k key, v value);
}
// 定義實作類并確定泛型的資料型別
class A implements MyInterface<String, Integer> {
@Override
public void method(String key, Integer value) {
System.out.println(key + ": " + value);
}
}
// 定義實作類(泛型類) 但不確定泛型的資料型別 創建物件時 確定資料型別
class B<k, v> implements MyInterface<k, v> {
@Override
public void method(k key, v value) {
System.out.println(key + ": " + value);
}
}
class Animal{
public void eat(){
System.out.println("動物吃了");
}
}
class Cat extends Animal {
public void eat(){
System.out.println("吃魚");
}
}
class Dog extends Animal {
public void eat(){
System.out.println("吃肉");
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/549500.html
標籤：其他
下一篇：【演算法資料結構專題】「延時佇列演算法」史上手把手教你針對層級時間輪（TimingWheel）實作延時佇列的開發實戰落地（下）