二〇二三·二·二十三——日报-日期类-异常-集合（Collection、List、泛型、通配符）

• 类的编译过程
  • 创建一个类的java文件
  • 编译源文件 生成字节码文件
  • 加载字节码文件，映射到JVM中
  • JVM开辟空间
  • 空间分三部分
    1. 栈：放地址
    2. 堆：放 new 对象
    3. 常量：放数据

---

• 遗留：通配符的使用尚未实现，不理解

日期类

生活中的时间

​ 世界标准时间：

​ 格林威治 /格林尼治 时间 GMT

​ 中国标准时间：

​ 世界标准时间+8小时

Date类

Date 代表了一个特定的时间，精确到毫秒

• 2020年1月1日 0:0:0

• 2030年1月1日 11:11:11

//构造方法
方法名					 说明
public Date()			//创建一个Date对象，表示默认时间
public Date(long date)	 //创建一个Date对象，表示指定时间
    
//常用方法
方法名							 说明
public long getTime()			//获取时间对象的毫秒值
public void setTime(long time)	 //设置时间，传递毫秒值
    
//使用SimpleDateFormat类 构造指定时间
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); //指定格式
	String today = "2023/02/23 11:36:00";	//使用指定格式定义字符串
    Date date = simpleDateFormat.parse(today);	//使用字符串通过SimpleDateFormat的parse方法构造Date
    System.out.println(date); // 打印date

SimpleDateFormat类

对Date对象进行格式化和解析

​ 格式化： Date对象 ——> 2020年1月1日 0:0:0

​ 解析： 2020年1月1日 0:0:0 ——> Date对象

• y 年
• M 月
• d 日
• H 时
• m 分
• s 秒
  • 2020-11-11 13:27:06 —— yyyy-MM-dd HH:mm:ss
  • 2020年11月11日 13:27:06 —— yyyy年MM月dd日 HH:mm:ss

//构造方法
方法名	说明
public SimpleDateFormat()	//构造一个SimpleDateFormat，使用默认格式
public SimpleDateFormat(String pattern)	//构造一个SimpleDateFormat，使用指定的格式
    String pattern = "yyyy-MM-dd HH:mm:ss" ----> "2022-02-23"
    String pattern = "yyyy年MM月dd日 HH:mm:ss" ----> "2022年02月23日"

格式化和解析日期

格式化(从 Date 到 String )
   public final String format(Date date)	//将日期格式化成日期/时间字符串
解析(从 String 到 Date )
   public Date parse(String source)  //从给定字符串的开始解析文本以生成日期

异常

异常体系：

Throwable：

1. Error：严重问题，通过代码无法处理。（内存溢出）

2. Exception：异常类，表示程序本身可以处理的问题

   • RuntionException及其子类：运行时异常。

     空指针异常，数组索引越界异常
     

   • 除RuntionException之外所有异常：编译期必须处理的，否则程序不能通过编译。

     日期格式化异常
     

异常处理方式

异常处理方式——throws：

throws 异常名;
//写在方法的定义处，表示声明一个异常
// - 编译时异常在编译时检查，写咋i方法后面
// - 运行时异常在运行时发生，在方法后面可以不写

抛出异常对象——throw：

throw new 异常();
//在方法内，表示当前代码手动抛出一个对象，下面的代码不用再执行了

throws 和 throw 的区别

throws：

• 用在方法声明后面，跟的是异常类名
• 表示声明异常，调用该方法有可能会出现这样的异常

throw：

• 用在方法体内，跟的是异常对象名
• 表示手动抛出异常对象，由方法体内的语句处理

抛出处理异常的意义

1. 在方法中，当传递的参数有误，没有继续运行下去的意义了，则采取抛出处理，表示让该方法结束运行。
2. 告诉调用者方法中出现了问题。

异常处理方式—— try……catch……

try {
   可能出现异常的代码;
} catch(异常类名 变量名) {
   异常的处理代码;
}
//  可以让程序继续往下执行。

Throwable的成员方法

方法名						说明
public String getMessage() //返回此 throwable 的详细消息字符串
public String toString() //返回此可抛出的简短描述
public void printStackTrace() //把异常的错误信息输出在控制台

案例：键盘录入数据
需求：键盘录入学生的姓名和年龄,其中年龄为 18 - 25岁,超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止。
   
	    do {
            flag = false;
            try {
                System.out.println("输入学生姓名：");
                name = sc.next();
                System.out.println("输入学生年龄（18~25）：");
                age = sc.nextInt();
                if (age < 18 || age > 25) {
                    throw new AgeOutofBoundsException("年龄超出限制！");
                }
            } catch (AgeOutofBoundsException e) {
                flag = true;
            }
            System.out.println("");
        } while (flag);

自定义异常

public class AgeOutOfBoundsException extends RuntimeException{
    public AgeOutOfBoundsException() {    
	}    
	public AgeOutOfBoundsException(String message) {
        super(message);    
	}
}

1. 为什么要学习异常？

   ​ 因为我们要处理代码中出现的问题

2. 异常的处理方式：抛出和捕获

   ​ 抛出的意义：让方法停止并告诉调用者这里出现了问题

   ​ 捕获的意义：让程序可以继续往下执行

3. 自定义异常的意义：让程序的提示报错更加的见名知意

集合类

集合

Collection：单列

//Collection集合概述
1. 是一个接口，表示一组对象（Collection的元素）
2. JDK不提供此接口任何直接实现，提供具体子接口（Set和List）实现 
//创建Collection集合的对象
1. 多态的方式
2. 具体的实现类ArrayList
    
//Collection集合的遍历
Iterator:迭代器，集合的专用遍历方式
	Iterator<E> iterator(): //返回集合中的迭代器对象，该迭代器对象默认指向当前集合的0索引
Iterator中的常用方法：
	boolean hasNext(): // 判断当前位置是否有元素可以被取出
	E next(): //获取当前位置的元素，将迭代器对象移向下一索引位置

List：可重复

接口，一般通过ArrayList和LinkedList实现

//List集合概述
1.有序：存储和取出的元素顺序一致
2.有索引：可以通过索引操作元素
3.可重复：存储的元素可以重复
    void add(int index,E element)	//在此集合中的指定位置插入指定的元素
	E remove(int index)	//删除指定索引处的元素，返回被删除的元素
	E set(int index,E element)	//修改指定索引处的元素，返回被修改的元素
	E get(int index)	//返回指定索引处的元素

List集合常用子类：ArrayList，LinkedList

• ArrayList：底层数据结构是数组，查询快，增删慢
• LinkedList：底层数据结构是链表，查询慢，增删快

1. ArrayList

2. LinkedList

public void addFirst​(E e)	//在该列表开头插入指定的元素
public void addLast​(E e)	//将指定的元素追加到此列表的末尾
public E getFirst​()			//返回此列表中的第一个元素
public E getLast​()			//返回此列表中的最后一个元素
public E removeFirst​()		//从此列表中删除并返回第一个元素
public E removeLast​()		//从此列表中删除并返回最后一个元素

Set：不可重复

1. HashSet
2. TreeSet

Map：双列

HashMap

TreeMap

增强for循环

增强for：简化数组和Collection集合的遍历

• 它是JDK5之后出现的，其内部原理是一个Iterator迭代器

• 实现Iterable接口的类才可以使用迭代器和增强for

  范例：
  ArrayList<String> list = new ArrayList<>();
  //添加一些元素
  for(String str : list) {
      System.out.println(str);
  }
  

泛型

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

//泛型可以使用的地方:
1.类后面 ————> 泛型类
2.方法申明上 ————> 泛型方法
3.接口后面 ————> 泛型接口
    
如果一个类的后面有<E>，表示这个类是一个泛型类。
创建泛型类的对象时，必须要给这个泛型确定具体的数据类型。

//泛型的定义格式：
    <类型>：指定一种类型的格式。
		   尖括号里面可以任意书写，按照变量的定义规则即可。一般只写一个字母。
		   比如：<E>  <T> <Q> <M>
    <类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。
		   比如：<E , T>  <Q , M> <K , V>
    
//泛型 类 的定义格式：
    格式：
    	修饰符 class 类名<类型> {  }
    范例：
        public class Generic<T> {  }
    //此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

//泛型 方法 的定义格式：
	格式：
        修饰符 <类型> 返回值类型 方法名(类型 变量名) {  }
	范例：
        public <T> void show(T t) {  }

	//练习：定义一个泛型方法，传递一个集合和四个元素，将元素添加到集合中并返回
public static <S> ArrayList add(ArrayList arr, S s1, S s2, S s3, S s4) {
        arr.add(s1);
        arr.add(s2);
        arr.add(s3);
        arr.add(s4);
        return arr;
}

//泛型 接口 的使用方式：
实现类也不给泛型
实现类确定具体的数据类型
    格式：
    	修饰符 interface 接口名<类型> {  }
	范例：
        public interface Generic<T> {  }

// 类型通配符
类型通配符：<?>
1.ArrayList<?>：表示元素类型未知的ArrayList，它的元素可以匹配任何的类型
2.但是并不能把元素添加到ArrayListList中了，获取出来的也是父类类型

//类型通配符上限：
    <? extends 类型>
	比如： ArrayList <? extends Number>：它表示的类型是Number或者其子类型
//类型通配符下限：
    <? super 类型>
	比如： ArrayList <? super Number>：它表示的类型是Number或者其父类型