day11【双列集合、异常】

迈不过友情╰ 2022-09-02 12:53 194阅读 0赞

# 一、Map双列集合 #

## 1.1 Map集合概述 ##

Map 用于保存具有映射关系的数据，如一个学生的ID对应一个学生，一个商品的ID对应一个商品，一个部门ID对应多个员工；这种具有对应关系的数据成为映射；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]

因此 Map 集合里保存着两组值，一组值用于保存 Map 里的 Key，另外一组用于保存 Map 里的 Value，Map 中的 key 和 value 都可以是任何引用类型的数据；**Map 中的 Key 不允许重复**，HashMap对key的存取和 HashSet 一样，仍然采用的是哈希算法，所以如果使用 自定类作为 Map 的键对象，必须复写 equals 和 hashCode 方法。

我们之前说到过，HashSet底层实质就是一个HashMap；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]

查看HashSet的add方法源码：

HashSet的存储的元素都是HashMap的Key，此HashMap的value总是一个固定的Object；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]

**所以，HashSet的去重原理实质上指的就是HashMap的Key的去重原理；**

> tips：Collection接口是单列集合的顶层接口，Map则是双列集合的顶层接口；

## 1.2 Map接口的共有方法 ##

Map是所有双列集合的顶层父类，因此Map中具备的是所有双列集合的共性方法；常用的方法如下：

*  `public V put(K key, V value)`: 把指定的键与指定的值添加到Map集合中。
 *  `public V remove(Object key)`: 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
 *  `public V get(Object key)` 根据指定的键，在Map集合中获取对应的值。
 *  `boolean containsKey(Object key)` 判断集合中是否包含指定的键。
 *  `public Set<K> keySet()`: 获取Map集合中所有的键，存储到Set集合中。
 *  `public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。

### 1.2.1 数据的存取 ###

示例代码：

package com.dfbz.demo01;
    
    import java.util.HashMap;
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
            //创建 map对象
            HashMap<String, String> map = new HashMap();
    
            //添加元素到集合
            map.put("江西", "南昌");
            map.put("湖南", "长沙");
            map.put("湖北", "武汉");
            
            // 存取是无序的
            System.out.println(map);        // {湖南=长沙, 湖北=武汉, 江西=南昌}
    
            // String remove(String key): 根据key来删除记录,并将key对应的value返回
            System.out.println(map.remove("江西"));       // 南昌
    
            System.out.println(map);            // {湖南=长沙, 湖北=武汉}
    
            // 查看 湖北的省会 是哪座城市
            System.out.println(map.get("湖北"));  // 武汉
            System.out.println(map.get("湖南"));  // 长沙
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]

### 1.2.2 数据的遍历 ###

方法：

*  `public V get(Object key)` 根据指定的键，在Map集合中获取对应的值。
 *  `public Set<K> keySet()`: 获取Map集合中所有的键，存储到Set集合中。

步骤：

*  1）根据`keySet()`方法获取所有key的集合
 *  2）通过foreach方法遍历key集合，拿到每一个key
 *  3）通过`get()`方法，传递key获取key对应的value；

示例代码：

package com.dfbz.demo01;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo02 { 
        public static void main(String[] args) { 
    
            Map<String, String> cities = new HashMap<>();
    
            //添加元素到集合
            cities.put("广西", "南宁");
            cities.put("云南", "昆明");
            cities.put("贵州", "贵阳");
    
            // 1.获取key的集合
            Set<String> provinces = cities.keySet();       // [贵州, 广西, 云南]
            System.out.println(provinces);
    
            // 2.遍历key的集合
            for (String province : provinces) { 
    
                // 3.根据key(省份)拿到value(省会城市)
                String city = cities.get(province);
                System.out.println(province + "省的省会是：" + city);
            }
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]

### 1.2.3 Entry对象 ###

Map集合中几条记录存储的是两个对象，一个是key，一个是value，这两个对象加起来是map集合中的一条记录，也叫一个记录项；这个记录项在Java中被Entry对象所描述；一个Entry对象中包含有两个值，一个是key，另一个则是key对应的value，因此一个Map对象我们可以看做是多个Entry对象的集合，即一个`Set<Entry>`对象；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]

Entry是一个接口，是Map接口中的一个内部接口，源码如下：

interface Entry<K,V> { 
            
            K getKey();
    
            V getValue();
    
            V setValue(V value);
        ....
    }

HashMap中则提供了Node类对Entry提供了实现，可以看到一个Entry对象（Node对象）中包含有key、value等值：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]

Map接口中提供有方法获取该Map集合的Entry集合对象：

*  `public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。

使用Entry对象来遍历Map集合：

package com.dfbz.demo01;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo03 { 
        public static void main(String[] args) { 
            Map<String, String> cities = new HashMap<>();
    
            //添加元素到集合
            cities.put("山东", "济南");
            cities.put("山西", "太原");
            cities.put("河南", "郑州");
            cities.put("河北", "石家庄");
    
            // 1.获取该Map的Entry集合
            Set<Map.Entry<String, String>> entrySet = cities.entrySet();
    
            // 2.遍历该Entry集合,获取每一个entry,也就是Map中的每一条记录
            for (Map.Entry<String, String> entry : entrySet) { 
    
                // 获取当前entry对象的key(省份)
                String province = entry.getKey();
    
                // 获取当前entry对象的value(城市)
                String city = entry.getValue();
    
                System.out.println(province + "省的省会是：" + city);
            }
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]

### 1.2.4 Map接口的去重 ###

我们知道HashSet底层就是依靠HashMap的key去重原理来是实现的，因此Map接口的HashMap、LinkedHashMap等接口的去重都是和HashSet、LinkedHashSet一致；

定义一个City对象：

package com.dfbz.demo01;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class City { 
        private String name;            // 城市名称
        private String shortName;       // 简称
        private String location;            // 所属地区
    
        public void intro() { 
            System.out.println("名称: " + name + ",简称: " + shortName + ",所属地区: " + location);
        }
    
        public City() { 
        }
    
        public City(String name, String shortName, String location) { 
            this.name = name;
            this.shortName = shortName;
            this.location = location;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public String getShortName() { 
            return shortName;
        }
    
        public void setShortName(String shortName) { 
            this.shortName = shortName;
        }
    
        public String getLocation() { 
            return location;
        }
    
        public void setLocation(String location) { 
            this.location = location;
        }
    }

> 注意：上面没有重写equals和hashCode方法；

存储两个属性一样的City对象：

package com.dfbz.demo01;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Deom04 { 
        public static void main(String[] args) { 
            Map<City,String> map=new HashMap<>();
    
            map.put(new City("内蒙古","蒙","华北"),"1");
            map.put(new City("内蒙古","蒙","华北"),"1");
    
            // 没有重写equals方法底层比较的是地址值,两个City对象肯定不一致,因此存储了2个
            System.out.println(map.size());     // 2
        }
    }

回顾学习HashSet时的去重原理：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]

存储的两个条件：

*  1）hashCode不同时存储
 *  2）当hashCode冲突时，equals为false时存储

> 没有重写hashCode时两个对象的hashCode一般情况下是不一致的，如果hashCode一致了（hash冲突），equals方法也不可能为true；

重写City的hashCode和equals方法：

按住`alt+insert`

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]

@Override
    public boolean equals(Object o) { 
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        City city = (City) o;
        return Objects.equals(name, city.name) &&
                Objects.equals(shortName, city.shortName) &&
                Objects.equals(location, city.location);
    }
    
    @Override
    public int hashCode() { 
        return Objects.hash(name, shortName, location);
    }

> 再次运行测试代码Demo04，输出1；

## 1.2 HashMap ##

HashMap是Map集合中比较常用的实现类，其特点依旧是我们之前学习的HashSet特点；即存储数据采用的哈希表结构（JDK8改为hash表+红黑树），元素的存取顺序不一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

> HashMap集合我们之前做测试的时候一直在用，这里不再演示；

## 1.3 LinkedHashMap ##

### 1.3.1 LinkedHashMap 特点 ###

我们之前在学习LinkedHashSet时说过，LinkedHashSet是继承与HashSet的，**在HashSet底层的基础上增加了一个循环链表**，因此LinkedHashSet除了具备HashSet的特点外（唯一），存储的元素还是有序的；

LinkedHashMap继承与HashMap，并且LinkedHashSet底层就是借助于LinkedHashMap来实现的；

LinkedHashSet源码如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]

查看HashSet对应的构造：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]

查看LinkedHashSet的add方法源码：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]

HashSet的add方法源码我们之前看过了，实质上是添加到内置的HashMap中去了；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]

> 注意：此时的map是LinkedHashMap；

### 1.3.2 LinkedHashMap 使用 ###

示例代码：

package com.dfbz.demo02;
    
    import java.util.LinkedHashMap;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
            LinkedHashMap<String,String> map=new LinkedHashMap<>();
    
            map.put("安徽","合肥");
            map.put("江苏","南京");
            map.put("浙江","杭州");
    
            // LinkedHashMap存取是有序的
            System.out.println(map);        // {安徽=合肥, 江苏=南京, 浙江=杭州}
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]

## 1.4 TreeMap ##

TreeMap也是TreeSet的底层实现，创建TreeSet的同时也创建了一个TreeMap，在往TreeSet集合中做添加操作是，实质也是往TreeMap中添加操作，TreeSet要添加元素成为了TreeMap的key；

我们来回顾一下TreeSet的特点（也是TreeMap的key的特点）：

1.  必须实现Compareable接口；
2.  存储的数据是无序的，但提供排序功能（Comparable接口）；
3.  存储的元素不再是唯一，具体结果根据Compare方法来决定；

使用示例1：

package com.dfbz.demo03;
    
    import java.util.Map;
    import java.util.TreeMap;
    
    /** * @author lscl * @version 1.0 * @intro: */
    public class Demo01 { 
        public static void main(String[] args) { 
            Map<Integer,String> map=new TreeMap<>();
    
            map.put(10,"abc");
            map.put(5,"abc");
            map.put(6,"abc");
            map.put(3,"abc");
            map.put(1,"abc");
    
            // 根据key排序
            System.out.println(map);        // {1=abc, 3=abc, 5=abc, 6=abc, 10=abc}
        }
    }

存储示例2：存储自定义对象，自定义排序规则

定义一个Book类，并重写Compareable方法，按住价格升序排序：

package com.dfbz.demo03;
    
    
    public class Book implements Comparable<Book> { 
    
        private String name;
        private Double price;
    
        @Override
        public int compareTo(Book book) { 
            // 根据价格降序排序
            return (int) Math.ceil(this.price - book.getPrice());
        }
    
        @Override
        public String toString() { 
            return "Book{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public Double getPrice() { 
            return price;
        }
    
        public void setPrice(Double price) { 
            this.price = price;
        }
    
        public Book() { 
        }
    
        public Book(String name, Double price) { 
            this.name = name;
            this.price = price;
        }
    }

测试代码：

package com.dfbz.demo03;
    
    import java.util.Map;
    import java.util.TreeMap;
    
    public class Demo02 { 
        public static void main(String[] args) { 
            Map<Book,String> map=new TreeMap<>();
    
            map.put(new Book("《计算机网络原理》",48.9),"abc");
            map.put(new Book("《高性能MySQL》",68.8),"abc");
            map.put(new Book("《深入理解Java虚拟机》",68.9),"abc");
    
            // 根据key排序 
            // {Book{name='《计算机网络原理》', price=48.9}=abc, Book{name='《高性能MySQL》', price=68.8}=abc, Book{name='《深入理解Java虚拟机》', price=68.9}=abc}
            System.out.println(map);
        }
    }

# 二、异常 #

## 2.1 异常概述 ##

### 2.1.1 什么是异常 ###

程序运行过程中出现的问题在Java中被称为异常，异常本身也是一个Java类，封装着异常信息；我们可以通过异常信息来快速定位问题所在；我们也可以针对性的定制异常，如用户找不到异常、密码错误异常、页面找不到异常、支付失败异常、文件找不到异常等等…

当程序出现异常时，我们可以提取异常信息，然后进行封装优化等操作，提示用户；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 15]

> 注意：语法错误并不是异常，语法错了编译都不能通过（但Java有提供编译时异常），不会生成字节码文件，根本不能运行；

默认情况下，出现异常时JVM默认的处理方式是中断程序执行，因此我们需要控制异常，当出现异常后进行相应修改，提供其他方案等操作，不要让程序中断执行；

我们之前有见到过很多的异常：

*  空指针异常：`java.lang.NullPointerException`

String str=null;
    str.toString();

*  数字下标越界异常：`java.lang.ArrayIndexOutOfBoundsException`

int[] arr = { 1, 3, 4};
    System.out.println(arr[3]);

*  类型转换异常：`java.lang.ClassCastException`

class A { 
    }
    
    class B extends A { 
    }
    
    class C extends A { 
    }
    public static void main(String[] args) { 
        A a = new B();
        C c = (C) a;
    }

*  算数异常：`java.lang.ArithmeticException`

int i=1/0;

*  日期格式化异常：`java.text.ParseException`

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date parse = sdf.parse("2000a10-24");

### 2.1.2 异常体系 ###

Java程序运行过程中所发生的异常事件可分为两类：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 16]

*  **Error**：表示严重错误，一般是JVM系统内部错误、资源耗尽等严重情况，无法通过代码来处理；
 *  **Exception**：表示异常，一般是由于编程不当导致的问题，可以通过Java代码来处理，使得程序依旧正常运行；

> tips：我们平常说的异常指的就是Exception；因为Exception可以通过代码来控制，而Error一般是系统内部问题，代码处理不了；

### 2.1.3 异常分类 ###

异常的分类是根据是在编译器检查异常还是在运行时检查异常；

*  编译时期异常：在编译时期就会检查该异常，如果没有处理异常，则编译失败；
 *  运行时期异常：在运行时才出发异常，编译时不检测异常；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 17]

*  编译时异常举例：

public class Demo { 
        public static void main(String[] args) { 
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    
            Date date = sdf.parse("2000-10-24");
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 18]

*  运行时异常：

public class Demo { 
        public static void main(String[] args) { 
            int i = 1 / 0;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 19]

## 2.2 异常的处理 ##

Java程序的执行过程中如出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统（JVM），这个过程称为抛出(throw)异常。

如果一个方法内抛出异常，该异常会被抛到调用方法中。如果异常没有在调用方法中处理，它继续被抛给这个调用方法的调用者。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。

流程如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 20]

### 2.2.1 异常的捕获 ###

异常的捕获和处理需要采用 try 和 catch 来处理，具体格式如下：

1）`try...catch(){}`：

try { 
    	// 可能会出现异常的代码
    } catch (Exception1 e) { 
    	// 处理异常1
    } catch (Exception2 e) { 
    	// 处理异常2
    } catch (ExceptionN e) { 
    	// 处理异常N
    }

2：`try...catch(){}...finally{}`：

try { 
    	// 可能会出现异常的代码
    } catch (Exception1 e) { 
    	// 处理异常1
    } catch (Exception2 e) { 
    	// 处理异常2
    } catch (ExceptionN e) { 
    	// 处理异常N
    } finally { 
    	// 不管是否出现异常都会执行的代码
    }

3：`try...finally{}`：

try { 
    	// 可能会出现异常的代码
    }  finally { 
    	// 不管是否出现异常都会执行的代码
    }

示例代码：

package com.dfbz.demo01;
    
    
    public class Demo01 { 
        public static void main(String[] args) { 
            method();
            System.out.println("程序终止我就不能执行了~");
        }
    
        public static void method() { 
            try { 
                String str = null;
                System.out.println(str.toString());
            } catch (Exception e) { 
                System.out.println("执行代码出现异常了！");
            } finally { 
                System.out.println("释放一些资源...");
            }
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 21]

> tips：try…catch语句是可以单独使用的；即：不要finally代码块；

### 2.2.2 异常的常用方法 ###

在Throwable类中具备如下几个常用异常信息提示方法：

*  `public void printStackTrace()`：获取异常的追踪信息；
    
    包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
 *  `public String getMessage()`：异常的错误信息；

异常触发被抓捕时，异常的错误信息都被封装到了catch代码块中的Exception类中了，我可以通过该对象获取异常错误信息；

示例代码：

package com.dfbz.demo01;
    
    public class Demo02 { 
        public static void main(String[] args) { 
            method();
    
            System.out.println("我继续执行~");
        }
    
        public static void method() { 
            try { 
                int i=1/0;
            } catch (Exception e) { 
                System.out.println("异常的错误信息: " + e.getMessage());
                // 打印异常的追踪信息
                e.printStackTrace();
            }
        }
    }

运行结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 22]

> 异常的追踪信息可以帮助我们追踪异常的调用链路，一步一步找出异常所涉及到的方法，在实际开发非常常用；

### 2.2.3 异常的抛出 ###

我们已经学习过出现异常该怎么抓捕了，有时候异常就当做提示信息一样，在调用者调用某个方法出现异常后及时针对性的进行处理，目前为止异常都是由JVM自行抛出，当然我们可以选择性的自己手动抛出某个异常；

Java提供了一个**throw**关键字，它用来抛出一个指定的异常对象；抛给上一级；

> 自己抛出的异常和JVM抛出的异常是一样的效果，都要进行处理，如果是自身抛出的异常一直未处理，最终抛给JVM时程序一样会终止执行；

语法格式：

throw new 异常类名(参数);

示例：

throw new NullPointerException("调用方法的对象是空的！");
    
    throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

示例代码：

package com.dfbz.demo01;
    
    public class Demo03 { 
        public static void main(String[] args) { 
            method(null);
            System.out.println("我还会执行吗？");
        }
    
        public static void method(Object object) { 
            if (object == null) { 
                // 手动抛出异常(抛出异常后,后面的代码将不会被执行)
                throw new NullPointerException("这个对象是空的！不能调用方法！");
            }
            System.out.println(object.toString());
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 23]

手动抛出的异常和JVM抛出的异常是一个效果，也需要我来处理抛出的异常；

修改代码：

package com.dfbz.demo01;
    
    public class Demo03 { 
        public static void main(String[] args) { 
            try { 
                method(null);
            } catch (Exception e) { 
                System.out.println("调用method方法出现异常了");
            }
            System.out.println("我还会执行吗？");
        }
    
        public static void method(Object object) { 
            if (object == null) { 
                // 手动抛出异常(抛出异常后,后面的代码将不会被执行)
                throw new NullPointerException("这个对象是空的！不能调用方法！");
            }
            System.out.println("如果出现了异常我是不会执行了，你能执行到这里说明没有异常");
            System.out.println(object.toString());
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 24]

### 2.2.4 声明异常 ###

在定义方法时，可以在方法上声明异常，用于提示调用者；

Java提供throws关键字来声明异常；关键字**throws**运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)；

语法格式：

... 方法名(参数) throws 异常类名1,异常类名2…{    }

代码示例：

package com.dfbz.demo01;
    
    
    import java.text.ParseException;
    
    public class Demo04 { 
        public static void main(String[] args) { 
    
            // 可以处理,也可以不处理
            method("你好~");
    
            // 编译时异常必须处理
            try { 
                method2("hello~");
            } catch (ParseException e) { 
                System.out.println("出现异常啦！");
            }
        }
    
        // 调用此方法可能会出现空指针异常,提示调用者处理异常
        public static void method(Object obj) throws NullPointerException { 
            System.out.println(obj.toString());
        }
    
        // 抛出的不是运行时异常,调用者调用该方法时必须处理
        public static void method2(Object obj) throws ParseException { 
            System.out.println(obj.toString());
        }
    
        // 也可以同时抛出多个异常
        public static void method3(Object obj) throws ClassCastException,ArithmeticException { 
            System.out.println(obj.toString());
        }
    }

## 2.3 异常的注意事项 ##

*  1）多个异常使用捕获又该如何处理呢？
    
    1.  多个异常分别处理。
    2.  多个异常一次捕获，多次处理。
    3.  多个异常一次捕获一次处理。
    
    一般我们是使用一次捕获多次处理方式，格式如下：
    
        package com.dfbz.demo02;
        
        public class Demo01 { 
            public static void main(String[] args) { 
                try { 
                    int i = 1 / 0;
                } catch (ArithmeticException e) { 
                    e.printStackTrace();
                } catch (Exception e) {          // 如果有多层catch父类异常一定要放在子类异常的下面
                    e.printStackTrace();
                }
            }
        }
    
    > 注意：这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。
 *  2）如果finally有return语句，则永远返回finally中的结果。我们在开发过程中应该避免该情况；

package com.dfbz.demo02;
    
    public class Demo02 { 
        public static void main(String[] args) { 
            int result = method();
    
            System.out.println("method方法的返回值: " + result);
        }
    
        public static int method() { 
            try { 
                int i = 10;
                return 1;
            } catch (Exception e) { 
                e.printStackTrace();
                return 2;
            } finally { 
                return 3;           // 不管是否出现异常都是返回3
            }
        }
    }

如果父类抛出了多个异常，那么子类重写父类方法时，不能抛出比父类大的异常（异常类的父类）或者不抛出异常；

*  3）子类在重写方法时，不可以抛出比父类还大的异常，可以抛出同级异常或者不抛异常；

package com.dfbz.demo02;
    
    public class Demo03 { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
        }
    }
    
    class Fu { 
    
        public void method() throws Exception { 
            System.out.println("fu ... method");
        }
    
        public void method2() throws ClassCastException { 
            System.out.println("fu ... method2");
        }
    
        public void method3() throws NullPointerException { 
            System.out.println("fu ... method3");
        }
    
        public void method4() throws ArithmeticException { 
            System.out.println("fu ... method3");
        }
    }
    
    class Zi extends Fu { 
    
        // 正常运行,子类可以抛比父类大或者同级的异常
        public void method() throws Exception { 
            System.out.println("zi ... method");
        }
    
        // 正常运行
        public void method2() throws ClassCastException { 
            System.out.println("zi ... method2");
        }
    
    // public void method3() throws Exception { // 报错,子类不能抛比父类大的异常
    // System.out.println("zi ... method2");
    // }
    
        // 正常运行,可以选择不抛出异常
        public void method4() {        
            System.out.println("zi ... method2");
        }
    }

*  子类在重写方法时，父类方法没有抛出异常，则子类方法也不能抛出异常；

class Fu { 
        public void method() { 
        }
    }
    
    class Zi extends Fu { 
        // 报错,父类方法没有抛出异常,则子类方法也不能抛出异常
    // public void method() throws Exception { 
    // }
    }

## 2.4 自定义异常 ##

我们说了Java中不同的异常类，分别表示着某一种具体的异常情况，那么在开发中总是有些异常情况是Java中没有定义好的，此时我们根据自己业务的异常情况来定义异常类。

我们前面提到过异常分类编译时异常和运行时异常：

1）继承于`java.lang.Exception`的类为编译时异常，编译时必须处理；

2）继承于`java.lang.RuntimeException`的类为运行时异常，编译时可不处理；

*  自定义用户名不存在异常：

package com.dfbz.demo04;
    
    public class UsernameNotFoundException extends RuntimeException { 
    
        /** * 空参构造 */
        public UsernameNotFoundException() { 
        }
    
        /** * @param message 表示异常提示 */
        public UsernameNotFoundException(String message) { 
            // 调用父类的构造方法
            super(message);
        }
    }

*  测试类：

package com.dfbz.demo04;
    
    public class Demo01 { 
        // 定义内置账户
        public static String[] users = { "xiaohui", "xiaolan", "xiaoliu"};
    
        public static void main(String[] args) { 
            findByUsername("abc");
        }
    
        public static void findByUsername(String username) throws UsernameNotFoundException { 
    
            for (String user : users) { 
                if (username.equals(user)) { 
                    System.out.println("找到了: " + user);
                }
            }
            // 用户名没找到
            throw new UsernameNotFoundException("没有用户: " + username);
        }
    }

运行结果：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 25]

--------------------

**上一篇**：[day10【双列集合、异常】][day10]

**下一篇**：[day12【多线程、锁机制、lock锁】][day12_lock]

**目录**：【JavaSE零基础系列教程目录】

--------------------

# 记得点赞~！！！ #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/69cc80a0e2ff43678da9dde96c4cb70e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20220829/2ab56f985b104383a58b1f94dacce807.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20220829/10126349302849b994961b70772324f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20220829/71368570996e4f97a1ed815ea9e326bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20220829/b35d5ccc92d6463c8d0fb022623ca989.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20220829/c2b1ffefef9c45e6a809ba0ddb3662ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20220829/3f966dec44f94902b2e4e84ccb64852b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20220829/a6109afc029443e5aed90a9464b03937.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20220829/05c23d063ec644f69f342f1a33db02a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20220829/ba831b52373b4f6480490ba7ea81a054.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20220829/a95a8bda6dde4d01ae437621f1f2fa68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20220829/da168be182dd45eabb5c29dd19a173bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20220829/f6e438a73f2144d682e7f844e7a90073.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20220829/47ae3754b2fe404eb4f731bcebf318b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20220829/0860b47212314eb78ec0bb0e974146c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20220829/ae6dedac5a8745bca7dec4fd4cf28b5a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20220829/5c8cb158dd324716bdcd48097f813d32.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20220829/7dcd6a4aefc84e739483e30b549c0071.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20220829/ab48dfda21c042f4a31ec9de6daaa9bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20220829/eed136fe1dcf4aa0b465fff37b5ab082.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 20]: /images/20220829/19a80079b9d844b0a48936f86225a887.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 21]: /images/20220829/138503670dd7454a9c472c5d17c3d9c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 22]: /images/20220829/5d62bfce48a64a0599c787bec626fda5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 23]: /images/20220829/2240e4a0259348968d4e8dd36b75abe5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 24]: /images/20220829/2f8b874c62604580832fbdc2d9c97a74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0JiMTUwNzAwNDc3NDg_size_16_color_FFFFFF_t_70_pic_center 25]: /images/20220829/1e7cd92c9b524616b697bdd2228ef53e.png
[day10]: https://blog.csdn.net/Bb15070047748/article/details/119349613?spm=1001.2014.3001.5501
[day12_lock]: https://blog.csdn.net/Bb15070047748/article/details/119381337?spm=1001.2014.3001.5501