蓝旭工作室后端第二周预习

异常类

什么是异常

        计算机运行过程中，会出现异常，有些是用户造成的，如系统想要输入一个‘int'类型变量，而用户却输入了’double‘类型。有些则是系统造成的，如网络断了，连接不到服务器。这些异常会导致程序终止，为了解决这些异常，java中提供了异常处理的相关流程。

        处理异常的步骤包括，定义异常类，抛出异常，捕获异常，处理异常。

捕获异常

try{...}catch{....}语句

其中把可能产生异常的语句放在try{...}中，然后使用catch捕获对应的异常。

public static void main(String[] args) {
    try {
        process1();
        process2();
        process3();
    } catch (IOException e) {
        System.out.println(e);
    } catch (NumberFormatException e) {
        System.out.println(e);
    }
}

一个try可以对应多个catch语句，每个catch语句捕获不同的异常。

finally语句

无论是否产生了异常，如果想要都执行一些语句，那么就可以把这些语句卸载finally里。

public static void main(String[] args) {
    try {
        process1();
        process2();
        process3();
    } catch (UnsupportedEncodingException e) {
        System.out.println("Bad encoding");
    } catch (IOException e) {
        System.out.println("IO error");
    } finally {
        System.out.println("END");
    }
}

如上代码，无论是否会产生异常，最后都会执行System.out.println("END")。

抛出异常

当发生错误时，我们就可以抛出异常，抛出异常的步骤：

1.创建异常类实例

2.用throw语句抛出

void process2(String s) {
    if (s==null) {
        NullPointerException e = new NullPointerException();
        throw e;
    }
}
//可简写
void process2(String s) {
    if (s==null) {
        throw new NullPointerException();
    }
}

可将异常转换：

void process1(String s) {
    try {
        process2();
    } catch (NullPointerException e) {
        throw new IllegalArgumentException();
    }
}

void process2(String s) {
    if (s==null) {
        throw new NullPointerException();
    }
}

process2语句抛出的NullPointerException被捕获转换成IllegalArgumentException。

自定义异常类

java中的异常类继承图

我们可以从这些定义异常类来继承这些异常类:

public class MyException extends RuntimeException{

}

包装类

我们已经知道，Java的数据类型分两种：

基本类型：byte，short，int，long，boolean，float，double，char

引用类型：对象，字符串，数组等

通过包装类，我们可以把基本数据类型可以视为引用类型。

基本类型	包装类
boolean	java.lang.Boolean
byte	java.lang.Byte
short	java.lang.Short
int	java.lang.Integer
long	java.lang.Long
float	java.lang.Float
double	java.lang.Double
char	java.lang.Character

这些包装的类是java自身提供的，不需要自己去定义。

自动装箱/自动拆箱

以int型为例，int类型与Integer类型可以互相转换

int i = 100;
Integer n = Integer.valueOf(i);
int x = n.intValue();

int转换成integer类型称为自动装箱，反过来称为自动拆箱。

不变类

类似于String，包装类是不变类型，一旦被创建实例，那么赋值将不会改变。同时，包装类对象储存的是引用，不能用==比较，需要用.equals()比较

String(Builder/Buffer)类

java编译器对String做了特殊处理，使得我们可以直接用+拼接字符串。但是每次拼接都会产生新的字符串，这样极为浪费内存。因此java提供了StringBuilder，与String不同，StringBuilder是一个可变类，意味着添加字符并不会创建新的字符串。StingBuffer与StringBuilder类似。

BigDecimal类

BigDecimal是java提供的一个高精度计算浮点数的类。类内提供了许多数学运算，如加法，乘法等。BIgDecimal类是不可变的,

泛型

什么是泛型

为了代码的复用性，我们在编写类时，为了能够一次编写，任何类型都可以用。例如：

public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

通过这种模板来实现泛型，我们在使用过程中就可以不用为每一种类型都写一种类。

List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");

编写泛型

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

<T>代表我们所需的数据类型。

列表

java中列表储存一个有序的序列，这个序列中存在相同元素。java中的列表包括ArrayList、LinkedList和Vector等。

List<String> list = new ArrayList<>();  
          
        // 添加元素  
        list.add("Apple");  
        list.add("Banana");  
        list.add("Cherry");  
          
        // 获取并打印元素  
        System.out.println("Element at index 1: " + list.get(1)); // 输出: Element at index 1: Banana  
          
        // 修改元素  
        list.set(1, "Blueberry");  
        System.out.println("Updated element at index 1: " + list.get(1)); // 输出: Updated element at index 1: Blueberry  
          
        // 删除元素  
        list.remove(0);  
        System.out.println("List after removing element at index 0: " + list); // 输出: List after removing element at index 0: [Blueberry, Cherry]  
          
        // 打印列表大小  
        System.out.println("Size of list: " + list.size()); // 输出: Size of list: 2  

Set

与列表相反，set是一个无序的序列，其中的元素不能重复。

Set<String> set = new HashSet<>();  
          
        // 添加元素  
        set.add("Apple");  
        set.add("Banana");  
        set.add("Cherry");  
        set.add("Apple"); // 这个添加操作不会有效果，因为Set不允许重复元素  
          
        // 检查元素是否存在  
        System.out.println("Does set contain 'Apple'? " + set.contains("Apple")); // 输出: true  
          
        // 删除元素  
        set.remove("Banana");  
        System.out.println("Set after removing 'Banana': " + set); // 输出: [Cherry, Apple]  
          
        // 打印集合大小  
        System.out.println("Size of set: " + set.size()); // 输出: 2  
          
        // 打印集合内容（不保证顺序）  
        System.out.println("Set contents: " + set); // 输出可能是: [Cherry, Apple] 或 [Apple, Cherry] 等 

Map

map中储存的是健值对，一个键对应一个值。

 Map<String, Integer> map = new HashMap<>();  
          
        // 添加键值对  
        map.put("Apple", 1);  
        map.put("Banana", 2);  
        map.put("Cherry", 3);  
          
        // 通过键获取值  
        Integer value = map.get("Banana");  
        System.out.println("Value for 'Banana': " + value); // 输出: 2  
          
        // 检查键是否存在  
        System.out.println("Does map contain key 'Apple'? " + map.containsKey("Apple")); // 输出: true  
          
        // 删除键值对  
        map.remove("Cherry");  
        System.out.println("Map after removing 'Cherry': " + map); // 输出: {Apple=1, Banana=2}  
          
        // 打印映射大小  
        System.out.println("Size of map: " + map.size()); // 输出: 2  
          
        // 打印映射内容  
        System.out.println("Map contents: " + map); // 输出可能是: {Apple=1, Banana=2} 或其他顺序，因为HashMap不保证顺序