Java从入门到精通18==》异常的注意事项、自定义异常、集合、迭代器、泛型

Java从入门到精通18==》异常的注意事项、自定义异常、集合、迭代器、泛型

2023.8.9

一、异常在方法重写中细节

1、子类覆盖父类方法时

如果父类的方法声明异常，子类只能声明父类异常或者该异常的子类，或者不声明。
也就是子类的异常要小于或等于父类异常且运行时异常除外。

2、当父类方法声明多个异常时

子类覆盖时只能声明多个异常的子集。

3、异常常用方法（上一章节有示例）

• public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。)
• public String toString():获取异常的类型和异常描述信息。
• public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。

二、自定义异常类

1、什么是自定义异常

根据所需自己定义异常

2、异常的特性

可抛性：即可以被throw关键字操作。
每个异常中都调用了父类的构造方法，把异常描述信息传递给了父类，让父类帮我们进行异常信息的封装。
示例代码：

package 自定义异常;

public class Demo {
    public static void main(String[] args) {
        try {
            Person person = new Person(1200, "法国德国");
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}
class Person{
    private int age;
    private String name;
    public Person(int age, String name) throws MyException {
        if(age<0||age>200){
            throw new MyException(age+"非法年龄");
        }
        this.age = age;
        this.name = name;
    }
}
class MyException extends Exception{
    public MyException(String message){
        super(message);
    }
}

三、集合

1、什么是集合

集合是java中提供的一种容器，可以用来存储多个数据。

2、集合和数组的区别

• 数组的长度是不可变的,集合的长度是可变的
• 数组可以存基本数据类型和引用数据类型
• 集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

3、集合体系结构

总结：
1、Collection：所有单根集合父类
Set：是一个无序集合，不允许放重复的数据
List：是一个有序集合，可以放重复的数据
2、Map：双根
是一个无序集合，集合中包含一个键对象，一个值对象，键对象不允许重复，值对象可以重复

4、Collection 集合概述和使用

1、 Collection集合概述
JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现；是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素

2、创建Collection集合的对象
多态的方式
代码示例：

package 定义Collection集合;
import java.util.ArrayList;
import java.util.Collection;
public class Demo {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(12);//添加元素12
        collection.add(13);//添加元素13
        collection.add(14);//添加元素14
        collection.add(15);//添加元素15
        collection.add(16);//添加元素16
        collection.add(17);//添加元素17
        System.out.println(collection.add(18));//添加元素18并打印返回值
        collection.remove(18);//移除元素18
        System.out.println(collection.remove(17));//移除元素18并打印返回值
        System.out.println(collection.contains(18));//判断是否存在元素18并打印输出
        System.out.println(collection.contains(12));//判断是否存在元素12并打印输出
        System.out.println(collection.isEmpty());//判断集合是否为空，并打印返回值
        System.out.println(collection.size());//计算集合长度并打印返回值
    }
}

四、迭代器Iterator

1、什么是迭代器

迭代器是指用于遍历一个集合（例如列表、字典等）中元素的一种对象。迭代器可以让我们遍历一个集合中的元素，同时不需要知道内部结构。
获取迭代器：迭代器其实是一个内部类。每个集合都给自己提供了一个方法，可以帮我们得到迭代器的实例

2、Iterator中的常用方法

• boolean hasNext(): 判断当前位置是否有元素可以被取出
• E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
• void remove(): 删除迭代器对象当前指向的元素

示例代码：

package 迭代器;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo {
    public static void main(String[] args) {
        //实现集合
        Collection collection = new ArrayList();
        //添加元素
        collection.add(10);
        collection.add(11);
        //获取迭代器
        Iterator it =collection.iterator();
        //迭代操作
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

注意，迭代器迭代时，不可以用集合调用删除，只能用迭代器调用删除，否则会报错

3、增强for

它的底层就是迭代器Iterator
实现Iterable接口的类才可以使用迭代器和增强for
简化数组和Collection集合的遍历

格式
​ for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
​ // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}

4、注意

1.报错NoSuchElementException
2.迭代器遍历完毕，指针不会复位
3.循环中只能用一次next方法
4.迭代器遍历时，不能用集合的方法进行增加或者删除，可以用迭代器的方法删除

五、泛型

1、什么是泛型

泛型是一种编程语言的特性，允许在编写代码时使用未知类型或通用类型。它能够把数据类型作为参数传递，这使得代码更加通用和可重用。在使用泛型时，可以在不提供实际类型的情况下编写类或方法，这样就能使代码适用于多种数据类型。泛型提高了代码的安全性和可读性，减少了代码冗余。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

2、泛型的好处

1. 把运行时期的问题提前到了编译期间
2. 避免了强制类型转换

3、泛型的定义格式

泛型类:

格式：
修饰符 class {
}

泛型方法：

格式：
修饰词 发回值 方法名（E）{
方法体
}

泛型接口：

格式：
修饰符 interface 接口名 < T>{
接口方法：修饰符 T 接口方法名（）；
}

4、java 中泛型标记符

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的 java 类型
示例：
问题代码:

package 迭代器;
import java.util.ArrayList;
import java.util.Collection;
public class Demo {
    public static void main(String[] args) {
        Collection list  = new ArrayList();
        list.add(12);
        list.add("a");
        for ( Object o :  list){
            String s =   (String)o;
            System.out.println(s.substring(0));
        }
    }
}

编译时不报错，运行时报错

加上泛型时，等于给Collection加了一个保安。
图片示例：

这样运行时异常就变为编译时异常了