JAVASE进阶day05（API，异常）

L。.。

已于 2024-08-03 21:00:09 修改

阅读量750

点赞数 29

文章标签： java 算法数据结构

于 2024-07-06 12:25:31 首次发布

本文链接：https://blog.csdn.net/qq_65095414/article/details/140223291

版权

数组高级操作

1.冒泡排序

 /**
     * 冒泡排序
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        int a = 0;
        for (int i = 0; i < arr.length-1; i++) {
            for (int i1 = 0; i1 < arr.length-1-i; i1++) {
                if (arr[i1] > arr[i1+1]){
                    a = arr[i1];
                    arr[i1] = arr[i1+1];
                    arr[i1+1] = a;
                }
            }
        }
    }

2.二分数查找

Arrays（重要）

package com.lu.day05.test;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] arr = {1,23,4,54,665,34,123};
        //ArrayUtil.normalSort(arr);
        Arrays.sort(arr);//数组排序
        System.out.println(Arrays.binarySearch(arr, 4));//二分数查找
        System.out.println(Arrays.toString(arr));//打印数组

    }
}

小端的大端排序

a >> 2 //这是一种编程中的位运算表达式，表示将变量 a 的二进制值右移 2 位。>>>表示正数

递归（不重要在java中尽量不要用）

1.含义

方法中调用方法本身

2.思路

把复杂问题转化拆解为同类问题中的一个子问题，递归中要有出口要不然会爆栈内存溢出错误

异常（重要）

1.为什么引入异常

使代码更加健壮,提高用户体验2

2.概述

识别错误并响应错误的机制

3.异常体系

1.Throwable

1.Error

VirtualMachineError JVM虚拟机运行错误

stackOverFlowError 栈内存溢出错误

outOfMemoryError（OOM）内存溢出错误

2.Exception

1.RuntimeException运行时异常

ArithmeticException算数运算异常

NullPointerException空对象异常（判断是否为null）

IllegalArgumentException（方法参数不合法）

2.ClassNotFoundException（类找不到异常）编译之后字节码文件找不到

3.IOException

FileNotFoundException(找不到指定文件)

2.异常分类

4. 异常处理流程

1.虚拟机自动流程

Step1.虚拟机首先判断有没有手动处理异常

Step2.发生异常创建异常对象

Step3.打印异常信息到控制台

Step4.中断程序运行

2.手动处理流程

throws声明异常

package com.lu.day05.test;

import java.io.FileNotFoundException;
import java.nio.file.FileAlreadyExistsException;

public class ThrowsDome {
    public static void main(String[] args) throws FileNotFoundException {
        show("fsjkl12");
        show2("jflkd");
    }

    /**
     * 声明了一个运行时异常
     * @param s
     * @throws NumberFormatException
     */
    public static void show(String s) throws NumberFormatException{
        Integer fj231 = Integer.valueOf(s);
        System.out.println(fj231);
    }

    /**
     * 声明一个编译时异常
     * @param file
     * @throws FileNotFoundException
     */
    public static void show2(String file) throws FileNotFoundException {
        System.out.println("读取"+file);
    }
}

throw和throws对比

throw手动抛出异常

package com.lu.day05.test;

import java.io.FileNotFoundException;
import java.util.Objects;


/**
 * 手动处理异常 -- throw抛出异常
 * 优点：1.具备return的作用可以终止程序运行
 *      2.可以自定义异常信息
 * 缺点：抛出编译时异常，需要向上一直声明
 */
public class TrowDome {
    public static void main(String[] args) {
//        parseStringToInteger("123");
//        double[] arr = null;
//        avgArr(arr);
//        test();
        file(null);
    }

    /**
     * 当字符串里面有字母时手动抛出一个异常
     * @param s
     */
    public static void parseStringToInteger(String s){
        char[] chars = s.toCharArray();
        for (char aChar : chars) {
            if (!Character.isDigit(aChar)) {
                throw new RuntimeException("字符串中存在非数字字母" + aChar);//抛出一个异常
            }
        }
        Integer integer = Integer.valueOf(s);
        System.out.println(integer);
    }

    /**
     * 当一个方法具有返回值的时候，如果return哪个值都不合适，那就应该抛出异常
     * @param arr
     * @return
     */
    public static double avgArr(double[] arr){
        if (Objects.isNull(arr) || arr.length == 0){
            throw new RuntimeException("数组不能为零");
        }
        double a = 0;
        for (double j : arr) {
            a += j;
        }
        return a/arr.length;
    }
    public static void test(){
        int i = 1;
        try {
            i = i/0;
        }catch (ArithmeticException e){
            System.out.println("被除数不能为零");
        }

    }
    public static void file(String filePath){
        try {
            if (Objects.isNull(filePath)) {
                throw new RuntimeException("文件名不能为空");
            }
            throw new FileNotFoundException("文件没找到");
        } catch (FileNotFoundException | RuntimeException e) {
            throw new RuntimeException(e);
        }
    }
}

try...catch捕获异常

public static void test(){
        int i = 1;
        try {
            i = i/0;
        }catch (ArithmeticException e){
            System.out.println("被除数不能为零");
        }
}

5.throwable的成员方法

package com.lu.day05.test;

public class ThrowAbleDemo {
    public static void main(String[] args) {
        method();
    }
    public static void method(){
        try {
            throw new RuntimeException("运行时异常");
        } catch (RuntimeException e) {
            System.out.println(e.toString());
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }
}

6.自定义异常

package com.lu.day05.test;

public class Test1 {
    public static void main(String[] args) {
        withdraw(200000);
    }
    public static void withdraw(double money){
        if (money > 10000){
            throw new InsufficientBalanceException("余额不足");
        }
        System.out.println("正常取钱");
    }
}

package com.lu.day05.test;

public class InsufficientBalanceException extends RuntimeException{
    public InsufficientBalanceException() {
    }

    public InsufficientBalanceException(String message) {
        super(message);
    }
}

面试题

1.请说出冒泡排序,选择排序以及二分查找的思路

冒泡排序：基本思想：重复地走访要排序的数列，一次比较两个元素，如果顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

选择排序：基本思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

二分数查找：基本思想：也称为折半查找，它是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

2.throw和throws的区别是什么?

throw：用于在方法体内主动抛出一个异常对象。它会立即终止当前方法的执行，并将异常对象抛给上层调用者。

throws：用于在方法声明处声明该方法可能会抛出的异常类型。它表示该方法不处理这些异常，而是将异常抛给上层调用者来处理。

总的来说，throw是用于主动抛出异常，而throws是用于声明方法可能抛出的异常类型。通过合理使用throw和throws，可以更好地处理程序中的异常情况，提高代码的健壮性。

一个时声明一个是抛出，一个用在方法签名上一个用在方法体内

3.catch捕获多个异常是应该注意什么?

异常类型的顺序：在捕获多个异常时，应该将子类异常放在父类异常之前捕获。

异常处理的逻辑：对于不同的异常，可能需要采取不同的处理逻辑。在 catch 块中，应该根据异常的类型来执行相应的处理代码，以确保能够正确地处理异常情况。

资源清理：如果在 try 块中使用了一些资源（如文件、数据库连接等），需要在 finally 块中进行资源的清理和释放，以确保资源不会被泄漏。

避免过于宽泛的捕获：尽量避免捕获过于宽泛的异常类型，如 Exception。这样可能会隐藏一些潜在的问题，并且不利于调试和错误排查。应该尽可能地捕获具体的异常类型，以便能够更准确地处理异常情况。

记录异常信息：在处理异常时，应该记录异常的相关信息，如异常消息、堆栈跟踪等，以便于后续的故障排查和分析。

4.手动处理异常的三种方式?

throws声明异常，throw抛出异常，try...catch捕获异常

5.请问输出什么

class Annoyance extends Exception {
}
class Sneeze extends Annoyance {
}
public class Human {
    public static void main(String[] args) throws Exception {
        try {
            try {
                throw new Sneeze();
            } catch ( Annoyance a ) {
                System.out.println("Caught Annoyance");
                throw a;
            }
        } catch ( Sneeze s ) {
            System.out.println("Caught Sneeze");
        } 
    }
}
请问输出什么? 改写这个题目,使他符合捕获多个异常的规则