十四、常用类和异常

1.1常用类

Date

类 Date 表示特定的瞬间，精确到毫秒。 Calendar 类实现日期和时间字段之间转换。

DateFormat 类格式化和解析日期字符串。

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。

构造方法

Date() ：创建Date对象并初始化此对象，以表示当前的时间（精确到毫秒）。

Date(long date)：创建Date对象并使用给定参数初始化此对象，

注意：时间在Java中使用自从格林威治标准时间，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数来存储。

成员方法

Date date1 = new Date();//获取当前系统时间 -------->前提条件

\1. 判断两个日期对象的前后

Date date2 = new Date(10000);//获取从标准基准时间起10000毫秒的时间点

boolean boo1 = date1.after(date2);//若date1在date2之后，则返回true，否则返回false

\2. 比较两个日期对象

Date date2 = new Date(10000);

int i = date1.compareTo(date2);

\3. 获取毫秒时间

long l = date.getTime();

\4. 修改时间

date.setTime(1000);

Calendar**类**

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR

等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方

法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。

注意：Calendar是抽象类不能直接new，可以通过Calendar类中的静态getInstance方法获取一个子类对象

成员方法

\1. 获取一个Calendar对象：---->大前提

Calendar c = Calendar.getInstance();//getInstance方法是一个静态的方法，直接通过类名调 用

System.out.println(c);

使用默认时区和语言环境获得一个日历。返回的 Calendar 基于当前时间。

2.//获取一年由多少个周 int w = c.getWeeksInWeekYear();

3.//获取本周的年 int w1 = c.getWeekYear();

*//获取Calendar对象中从ERA属性开始的之后每一个属性的值，数字下标从0开始，

• //包含有：ERA=1,YEAR=2021,MONTH=7,WEEK_OF_YEAR=32,WEEK_OF_MONTH=1,DAY_OF_MONTH=5,DAY_OF_YEAR=217,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=1,AM_PM=0,HOUR=11,HOUR_OF_DAY=11,MINUTE=5,SECOND=30,MILLISECOND=488,ZONE_OFFSET=28800000,DST_OFFSET=0 int filed = c.get(16);

4.//关联静态常量，值为：当前属性再Calenderr对象中的获取位置，即：c.get(c.DAY_OF_MONTH) int y = c.YEAR;

5.//获取毫秒 Date date = c.getTime(); long l = date.getTime(); long l2=c.getTimeInMillis();

6.//获取每周第一日 int fdw = c.getFirstDayOfWeek();

7.//获取某个日历对象的指定属性的值： System.out.println(c.get(Calendar.DATE));

8.// 修改某个日历对象的指定属性值： c.set(Calendar.YEAR, 2017); System.out.println(c);

9.//获取时区 TimeZone tz = c.getTimeZone();

SimpleDateFormat

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的工具类。它允许进行格式化（日期 -文本）、解析（文本 -> 日期）和规范化。

字母 日期或时间元素 示例

y 年 1996;96

M 年中的月份 July;Jul;07

w 年中的周数 27

D 年中的天数 189

d 月份中的天数 10

a Am/pm 标记 PM

H 一天中的小时数（0-23） 0

h am/pm 中的小时数（1-12） 12

m 小时中的分钟数 30

s 分钟中的秒数 55

S 毫秒数 1秒=1000毫秒 =1000000微秒=1000000000毫微秒(纳秒) 978

/** * 格式化时间时，其格式写法为：yyyy-MM-dd hh:mm:ss * yyyy:表示完整的年，yy表是省略纪元的年 * MM：表示月份，不能小写，M表示月份为个位数时不加前缀0 * dd：表示本月的第几天，d表示日期为个位数时不加前缀0 * DD：表示本年的第几天 * hh：表示12小时制的小时 * HH：表示24小时制的小时 * mm：表示分钟 * ss：表示秒 * SS：表示毫秒 */

常用成员方法

\1. 格式化日期：

/**

*format(Date date) 将date对象格式化成指定格式的日期字符串

*/

String format = "yyyy-MM-dd a hh:mm:ss";

SimpleDateFormat sdf = new SimpleDateFormat(format);

Date date = new Date();

String dateStr = sdf.format(date);

\2. 解析日期：

/**

*parse(String str) 将str对象解析成一个日期对象

*/

String dateStr = "2017-12-01 上午 10:10:10";

String format = "yyyy-MM-dd a hh:mm:ss";

SimpleDateFormat sdf = new SimpleDateFormat(format);

Date date = sdf.parse(dateStr);

Math**类**

Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

常用静态属性

public static final E 比任何其他值都更接近 e（即自然对数的底数）的double值。

public static final PI 比任何其他值都更接近 pi（即圆的周长与直径之比）的double值。

常用成员方法

\1. 绝对值

Math.abs(a)

\2.最大、最小值

最大值：Math.max(a,b))

最小值：Math.min(a,b)

\3. 幂运算（int a = 3; int b = 4; (Math.pow(a,b) =333*3；

(Math.pow(a,b)

\4. 平方根、立方根

平方根：Math.sqrt(a)

立方根：Math.cbrt(a)

\5.四舍五入

Math.round(a)

\6. 随机数

Math.random();

\7.ceil(大于等于这个数的最小正数) floor(小于等于这个书的最大正数)

System.out.

println(Math.ceil(3.2)); //大于或等于这个数字的最小正数

System.out.println(Math.floor(2.5));//小于或等于这个数字的最大正数

Random**类**

此类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式 (linear congruentialform) 对其进行了修改所得。

如果用相同的种子创建两个Random实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

构造方法

Random() 创建一个新的随机数生成器。此构造方法将随机数生成器的种子设置为某个值，该值与此构造方法的所有其他调用所用的值完全不同。Random(long seed) 使用单个 long 种子创建一个新的随机数生成器。该种子是伪随机数生成器的内部状态的初始值

注意：若long种子确定，则在不同程序中，相同次数产生的随机数是相同的。

常用方法

\1. 生随机数

Random random = new Random(10);//以10为种子，使用线性同余公式产生伪随机数

int i1 = random.nextInt();//产生一个随机整数

\2. 修改种子

Random random = new Random(10);

random.setSeed(20);//将随机数种子设置为20

System**类**

System类包含一些有用的类字段和方法。它不能被实例化。

常用静态属性

public static fianl PrintStream err 标准错误输出流

public static final InputStream in 标准输入流

public static final PrintStream out 标准输出流

常用成员方法

\1. 获取系统时间

long time1 = System.currentTimeMillis();//获取当前时间，毫秒数

long time2 = System.nanoTime();//获取当前时间，微秒

\2. 强制退出虚拟机

System.exit();//强制退出当前正在执行的虚拟机0 非0

\3. 设置、获取属性

System.

getProperty(String key); //获取指定键指示的系统属性。

System.setProperty(String key, String value); // 设置指定键指示的系统属性。

\4. 垃圾回收：

System.gc();//运行垃圾回收器。 可以通过JVM参数禁用。等效于：Runtime.getRuntime().gc()

Runtime**类**

每个 Java 应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。可以通过getRuntime方法获取当前运行时。

\1. exec（command）

*在单独的进程中执行指定的字符串命令。

*//1.创建Runtime对象

*Runtime runtime=Runtime.getRuntime();

*//2.exec 启动一个进程

*Process process=runtime.exec("qq");

*//3.程序休眠

*Thread.sleep(5000);

*//4.关闭进程

*process.destroy();

\2. exit(int status) ，退出jvm 。 System.exit()内部调用runtime.exit()

Runtime runtime=Runtime.getRuntime();

runtime.exit(0);

\3. 获取jvm的内存

long totalMemory() 返回 Java 虚拟机中的内存总量。

long freeMemory() 返回 Java 虚拟机中的空闲内存量

long maxMemory() 返回 Java 虚拟机试图使用的最大内存量。

server模式和client模式下内存设置略有不同，JDK8默认运行在Server模式下，以下描述64位操作系统下server模式下的内存设置参数:-

*Xms:初始堆大小，GC后动态调整，最多等于Xmx:。

** 默认根据物理内存计算：至少8mb，否则是物理内存的1/64

*Xmx:**最大堆大小，JVM运行过程中，如果初始堆空间不足的时候，最大可以扩展到多少。

默认根据物理内存计算：

client模式：

Xmx：物理内存<192m,mx为1/2m；>192m,1/4,不超过32G

Xms：至少8m，否则是1/64

server模式:

计算规则和client一样，32位上限为1G，64位32G

EG:java -XX:+PrintFlagsFinal -version | grep MaxHeapSize #linux查看该默认值

java -XX:+PrintFlagsFinal -version | findstr HeapSize #windows查看该默认 值

-

Xss**：** 设置每个线程的Java栈大小。JDK5.0以后每个线程Java栈大小为1M，以前每个线程堆栈大小为256K。根据应用的线程所需内存大小进行调整。在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在3000~5000左右。

注意：

\1. 如果整个运行时间垃圾回收占了98%，但是回收的内存低于2%，则抛出OutOfMemoryError

\2. 设置的时候，如果不跟单位表示字节，可以是k、m、g单位

\3. 堆大小设置规则：

mx多多益善，当然要给操作系统（1G）和其它应用留（看情况）。

mx和ms最好一致，以免jvm动态调整

 

 

1.2异常机制

异常的概念

异常机制是一套方法非正常返回的机制，包括异常消息的包装、异常消息的传递根据上下文语境，异常可能也表示包装异常消息的异常对象

异常消息的包装

异常继承体系

当方法不具备正常往下执行的条件时，当前方法需要异常终止，导致方法异常终止的消息可以包装后传递给方法的调用方，包装异常消息的对象的类型必须是Throwable或者其子类型。

JDK中已经包含了很多继承自Throwable的子类型，当方法无法继续执行时，可以通过这些子类的实例包装异常消息通知方法调用方，也可以继承这些子类然后抛出实例。

 

\1. Throwable：所有的异常都是由Throwable继承而来，Error和Exception是最常见的。

Throwable不能明确表示异常类型，所以一般不直接抛出该类异常。

\2. Error：表示比较严重的问题，代表Java运行时系统的内部错误和资源耗尽错误。应用程序不应该使用这种类型的对象表示异常消息。

\3. Exception：表示比较一般的问题，推荐由程序使用。

\4. RuntimeException：表示由程序员疏忽导致的问题，如：通过空引用调用方法。一般由jvm抛出，如果自己的代码要使用RuntimeException，也是可以的

分类：运行时异常/非运行时异常、运行时异常/编译时异常、非受检异常/受检异常

异常包装了什么消息

异常对象包装了异常相关情况，继承自Throwable 的异常类实例可以传递以下信息：

\1. 异常对象创建时线程执行堆栈的快照。

\2. 一个字符串格式的异常描述信息

\3. 异常链，底层实现的异常可能需要包装为高层的异常抽象，通过异常链可以保存异常的链接

注意：异常类型本身也表示一定的信息。如：NullPointerException

异常传递机制

当方法无法继续执行时，可以通过异常相关的类对象来包装异常消息，但是异常消息是需要交给调用方的，以便调用方对异常情况进行对应的处理。Java的异常传递机制如下：

throw：抛出异常，方法会终止，或者跳入finally块

throws：如果方法会抛出非运行时异常，则需要声明，以便于调用方进行特殊的调用

try：表示块中的代码可能会出现异常

catch：捕获try块中的代码中抛出的异常，按类型捕获，多个异常的父类型应该放在最后，而且异常只匹配一次

finally：无论try块中是否抛出异常，finally都会运行

throw**、throws**

throw抛出一个异常消息给调用方，类似于return。throws表明当前方法可能会抛出异常，以备使用方法进行特殊处理。

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。

\1. Error：表示比较严重的问题，一般是通过程序无法恢复的，大多的Error由jvm抛出，不建议程序抛出或者捕获Error。如果出现了这样的内部错误，除了通知给用户，并尽力使程序安全地终止之外，再也无能为力了。

\2. Exception：表示比较一般的问题，正常由程序通过throw抛出，需要在抛出异常的方法中声明，调用该方法的时候必须捕获该异常，或者声明抛出

\3. RuntimeException：表示由程序员疏忽导致的问题，一般由jvm抛出，如果自己的代码要抛出RuntimeException，也是可以的，不要声明、在调用方法中也不是必须try的

注意：异常抛出的触发

执行遇到了throw关键字

JVM无法继续执行方法，如：通过空引用调用方法、堆内存耗尽

try-catch

如果调用的方法中可能抛出非运行时异常，则方法调用必须包括在try块中通过catch块捕获，或者声明抛出同系列异常。

try：表示块中的代码可能会出现异常

catch：捕获try块中的代码中抛出的异常，按类型捕获

注意：在Java7以前，try块不能单独出现，必须与catche或者finally组合出现

注意：\1. cath**可以出现多个**，以捕获try块中的代码声明可能抛出的各种异常，多个异常的父类型应该放在最后，而且异常只匹配一次

\2. 如果方法声明可能抛出非运行时异常，则该方法调用必须放到try块中，或者调用该方法的异常也声明抛出同类型的异常

\3. 如果方法可能抛出运行时异常，则方法可以不声明要抛出的异常，而且也不要求该方法的调用必须在try块中，如：setAge可以不放在try块中

\4. 如果在调用链条中，对抛出的异常没有进行捕获，则一**直抛出到虚拟机**，虚拟机在控制台打印异常信息后，退出程序

finally

在try-catch块后加入finally块,finally块的主要作用释放资源。

finally块是否发生异常都执行

finally块不执行的唯一情况,退出java虚拟机，System.exit(); 0正常退出，非0非正常退出

异常处理

在catch块中可以对捕获的异常进行处理，常见的处理方式如下：

必须的处理：记录异常对象中的相关信息 log4j

根据场景可进行的处理：

要求用户或应用程序输入信息

使用默认值或替换数据

将控制转移到应用程序的其他部分，如：调用其他方法或者将异常转化为其他形式抛出

忽略问题，只有正常的异常才这样去处理

重试操作，如：1秒后重连

使系统做好停止准备

方法执行结果

方法的调用结果：

\1. 正常结束：

return

代码执行完成

\2. 非正常结束：

throw

jvm 抛出异常

注意：如果一个方法的代码执行途径上，有多个导致方法结束的因素，那么方法的结果会是最后一个导致方法结束的因素

自定义异常类

如果JDK中的异常类型不能更好的表示我们的异常消息，则可以自定义异常，通常继承自Exception或其子类，习惯上包装一下父类的构造方法。

\1. 定义一个类，继承Exception类或RuntimeException

\2. 在此类中定义构造方法，调用父类中对应的构造方法，可按照需要提供以下参数。

message：异常描述信息；

cause：原始异常；

enableSuppression：是否启用异常抑制，如果启用，则addSuppressed无效，

getSuppressed返回空数组

writableStackTrace：是否填充异常堆栈跟踪消息到异常对象中

注意：正常情况提供一个带message参数、一个带message和cause参数的构造方法即可

\3. 使用异常，throws、throw

Java7**新语法**

\1. try-with-resources**语句**

Java7之前需要在finally中关闭socket、文件、数据库连接等资源； Java7中在try语句中申请资源，实现资源的自动释放（资源类必须实现java.lang.AutoCloseable接口**，一般的文件、数据库连接等均已实现该接口，close方法将被自动调用）。

\1. try的括号中可以创建多个资源对象，如果只有一个，可以不加分号

\2. try可以单独使用，不加catche、finally，也可以组合使用。如果close方法中声明抛出异常，则必须加catch块，或者在方法声明中加异常声明

\2. catch**子句可以同时捕获多个异常**

try {

}catch(NullPointerException | ArrayIndexOutOfBoundsException ex){

}

注意：catch中的异常不能存在继承关系

\3. 异常抑制

异常抑制：在try和finally中同时抛出异常时，finally中抛出的异常会在异常栈中向上传递，而try中产生的原始异常会消失。 不同于异常链，异常链是一个异常的不断包装转换，异常抑制是异常的丢失

Throwable类增加addSuppressed方法和getSuppressed方法，支持原始异常中加入被抑制的异常。

\4. 声明异常可以是抛出异常的子类

只限于try块中不可能抛出Exception的情况下

关键知识点默写

\1. Date 表示一个瞬间时间

Date date=new Date();

\2. Calendar类日历

Calendar calendar=Calender.getInstance();

calendar.get(Calendar.YEAR);

calendar.get(Calender.MONTH);

calender.set();

\3. SimpleDateFormat:实现时间和字符串之间的转换。

把日期格式的字符串转成 时间对象

String s="2020-10-10";

SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd");

Date date=df.parse(s);

把时间转成某种格式的字符串

SimpleDateFormat df=new SimpleDateFormat("yyyy/MM/dd");

String s=df.format(new Date());

\4. Math数学类

\5. Random 随机数类

\6. System 类

System.exit(); 退出jvm

System.gc(); 回收垃圾

System.currentTimeMills();

\7. Runtime 运行时

Runtime runtime=Runtime.getRuntime();

exec(); 执行命令

freeMemory(); //空闲内存

totalMemory();//总内存

maxMemory();//最大内存

exit();//退出jvm

\8. 异常：是对非正常情况的消息包装、以及消息传递的一套机制。

异常传递:

try：有可能出现异常的代码

catch：捕获异常

finally：最终的代码，有没有异常都会执行

throw：抛出异常

throws：声明异常

自定义异常： 继承Exception或RuntimeException，调用父类构造方法

常见面试题

\1. 使用Math类产生一个随机数的方法

Math.random()

\2. 什么是异常？常见的异常有哪些？

是对非正常情况的消息包装、以及消息传递的一套机制。

*数组下标越界---java.lang.ArrayIndexOutOfBoundsException

• 除数为零---java.lang.ArithmeticExecption

• 空指针异常--java.lang.NullPointerException

• 类型转换异常：---java.lang.ClassCastException

• 数字格式化异常：---java.lang.NumberFormatException

• 类未找到异常：---java.lang.classNotFoundException

• 转换异常：---java.text.ParseExpection

\3. 异常有哪些处理方式，分别需要注意什么问题？

try：有可能出现异常的代码

catch：捕获异常

finally：最终的代码，有没有异常都会执行

throw：抛出异常

throws：声明异常

自定义异常： 继承Exception或RuntimeException，调用父类构造方法

\4. try-catch块中存在return语句，是否还执行finally块，如果执行，说出执行顺序

不管有没有异常，finally块中代码都会执行； 当try.catch中有return时，finally仍然会执行； finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。 在执行时，是return语句先把返回值写入内存中，然后停下来等待finally语句块执行完，return再执行后面的一段。 至于返回值到底变不变，当finally调用任何可变的API，会修改返回值；当finally调用任何的不可变的API，对返回值没有影响。