day14 常用API、异常
Calendar 日历类
Number 格式化数字类
BigInteger和BigDecimal 告警地数字
Random 随机数
Math 数学类
异常机制 Exception
Calendar
日历类
// 当前系统日历
Calendar calendar = Calendar.getInstance();
// 获取今天是本周第几天,周日是第一天
System.out.println(calendar.get(Calendar.DAY_OF_WEEK));
// 本月第几天(多少号)
System.out.println(calendar.get(Calendar.DAY_OF_MONTH));
// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月 , 0开始,所以+1
int month = calendar.get(Calendar.MONTH) + 1;
// 获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);
// 获取时
int hour = calendar.get(Calendar.HOUR);
// 获取分
int minute = calendar.get(Calendar.MINUTE);
// 获取秒
int second = calendar.get(Calendar.SECOND);
// 获取星期
int weekday = calendar.get(Calendar.DAY_OF_WEEK);
System.out.println(year + "年" + month + "月" + day + "日" + hour + "时"
+ minute + "分" + second + "秒" + weekday);
Number
数字格式化
数字格式化 : # 任意数字(0-9任意单个数字) , 千分位 . 小数点 0 补位
// 1 创建数字格式化对象
// 需求 加入千分位
DecimalFormat df = new DecimalFormat(",###");
System.out.println(df.format(12345678));
// 需求 加入千分位 保留两位小数
df = new DecimalFormat(",###.##");
// 会四舍五入
System.out.println(df.format(12345678.12953));
System.out.println(df.format(12345678.1));
// 需求 加入千分位,保留4位小数,不够补0
df = new DecimalFormat(",###.0000");
// 会四舍五入
System.out.println(df.format(12345678.12957));
System.out.println(df.format(12345678.1));
BigInteger和BigDecimal
更高精度的数据存储
BigInteger 一般用于存储更高精度的整数
BigDecimal 一般用于存储更高精度的小数
// 传字符串/字节数组等
BigInteger bi = new BigInteger("200");
// 可以直接传整数和小数
BigDecimal v1 = new BigDecimal(10);
BigDecimal v2 = new BigDecimal(20);
// 加 v1 + v2
BigDecimal v3 = v1.add(v2);
// v1 - v2
v3 = v1.subtract(v2);
// v1 * v2
v3 = v1.multiply(v2);
// v1 / v2
v3 = v1.divide(v2);
// v1 % v2
v3 = v1.remainder(v2);
System.out.println(sum1(100));
System.out.println(sum2(100));
阶乘案例
public static long sum1(long i){
if(i <= 1){
return 1;
}
return i*sum1(i-1);
}
public static BigDecimal sum2(int i){
if(i <= 1){
return new BigDecimal(1);
}
return new BigDecimal(i).multiply(sum2(i-1));
}
Random
随机数生成器,从0开始
// 创建一个随机数生成器
Random random = new Random();
// [0-100] 是 101个数字,所以写101
System.out.println(random.nextInt(101));
// [1-100] : 因为从0开始 想要最小为1 那就对结果+1
System.out.println(random.nextInt(100) +1 );
// 生成范围 10~20
// 规则 : nextInt(最大 - 最小 + 1) 随机结果 + 最小
System.out.println(random.nextInt(20-10+1)+10);
// 生成 a-z
int i1 = random.nextInt(26);
// 生成 是大写还是小写 1 表示大写 0表示小写
int x = random.nextInt(2);
char c = x == 1 ? (char) (i1+97) : (char) (i1+65);
System.out.println(c);
String xsx = "wqrihabcjzxnkjqruXNCKJASHIR";
int index = random.nextInt(xsx.length());
System.out.println(xsx.charAt(index));
Math
该类提供了科学计算和基本的数字操作方法
都是静态方法来,类名调用即可,并且 Math也在java.lang下,不需要导包
// abs : 绝对值
System.out.println(Math.abs(-1.5));
// ceil : 向上取整
System.out.println(Math.ceil(2.00000001));
// floor : 向下取整
System.out.println(Math.floor(2.99999999));
// 比较大小
System.out.println(Math.max(3, 2));
System.out.println(Math.min(3, 2));
// sqrt : 平方根,开平方
System.out.println(Math.sqrt(9));
// cbrt : 立方根
System.out.println(Math.cbrt(8));
// 随机生成一个 大于等于0 且 小于 1 的值
System.out.println(Math.random());
// random() * (最大 - 最小 +1) + 最小
System.out.println(Math.floor(Math.random()*(10-5+1)+5));
// rint : 四舍五入
System.out.println(Math.rint(2.4));
System.out.println(Math.rint(5.5));
// 注意 xxx.5的时候 取偶数
System.out.println(Math.rint(4.5));
// pow : 几次幂
System.out.println(Math.pow(2, 3));
System.out.println(Math.sqrt(8));
异常机制
就是错误的一种说法
是java中提供的一种识别及相应错误的一种机制,有效的使用异常,可以使我们的程序更加健壮,易于调试
导致异常的原因 :
1 用户输入非法数据
2 要找的文件不存在
3 网络中断
4 内存溢出
如果不解决,就会导致程序生命周期终止(错误代码之后的代码都不执行了)
由于异常,导致程序结束
异常的处理形式
- try…catch… : 解决异常,一般用在客户端
- throws : 抛出异常,一般用于类库端(服务端),提醒调用处,让他解决问题
- throw : 异常源,创建一个异常的
finally语句块
必须执行的语句块
继承体系 :
- Throwable 是异常类的根类
- 直接 子类 Exception 和 Error
- Error : 一般我们解决 不了,比如栈内存溢出问题
- Exception : 有一个子类是RunTimeException是运行时异常,其他子类都是编译时异常
TryCatch
/*
* try...catch... 用来处理解决异常
*
* throws 用来抛出异常 是提醒机制,如果你调用的方法中抛出了异常,要么你也抛出 要么你就解决
*
* try{ 高风险代码; }catch(异常类型 变量){ 出错后的处理措施; }
*/
// 读取文件
try {
// try中 只要有一条语句报错,则整个try结束,直接执行catch
// 如果 try中没有出现异常,则try顺序执行完后,不执行catch
FileInputStream fis = new FileInputStream("D:/1223.txt");
System.out.println("读取成功");
} catch (FileNotFoundException e) {
// 异常类型 只要是抛出的异常类的类型或者是其父类类型 都是可以的(因为多态)
// e.printStackTrace();
/**
* e.getMessage() : 获取异常信息(用户响应)
*
* e.printStackTrace() : 打印错误的追踪栈帧(程序员排错)
*
* e.getStackTrace() : 获取错误栈帧的内存地址
*/
System.out.println(e.getMessage());
System.out.println(e.getStackTrace());
e.printStackTrace();
System.out.println("地址不对");
}
/**
* try{
* 高风险代码;
* }catch(异常类型 变量){
* 解决方案;
* }catch(异常类型 变量){
* 解决方案
* }
* 1 多个catch,必须从上到下是从子类到父类,否则会因为多态的原因把子类异常对象也捕捉,导致子类异常永远执行不到
* 2 多个catch 如果异常类型没有继承关系,也就无所谓顺序
* 3 多个catch 只会有一个catch执行,最先出错的语句开始,try就终止了,所以只能报出一种错误
*/
public class Exception_04 {
public static void main(String[] args) {
try {
// 文件找不到
new FileInputStream("D://123.txt");
String s = null;
// 空指针
s.toString();
} catch (FileNotFoundException e) {
System.out.println("没找到文件");
}catch (NullPointerException e) {
System.out.println("对象不能为null");
}catch (Exception e) {
System.out.println("其他异常");
}
}
}
/**
* 1.7开始, 多个catch 如果有些处理操作相同 可以使用 | 隔开 ,统一处理相同操作
*
* 异常类型 | 异常类型 | 异常类型.... 变量 , 多个异常类型中 不能有继承关系,如果碰到有继承关系的就直接写父类
*
* @author 天亮教育-帅气多汁你泽哥
* @Date 2021年4月9日
*/
public class Exception_05 {
public static void main(String[] args) {
// 比如 有三个异常,但是呢 有两个异常处理操作是相同的
try {
// 会报出 FileNotFoundException 编译时异常,父类是IOException
new FileInputStream("xxx");
String s = null;
// 会报出 NullPointerException ,运行时异常,父类是 RuntimeException
s.toCharArray();
// 运行时异常 父类是Exception
throw new RuntimeException("异常类型1,运行时异常");
} catch (FileNotFoundException | NullPointerException e) {
System.out.println("处理1111");
} catch (RuntimeException e) {
System.out.println("处理2222");
}
}
}
// 传统写法
try {
// 打开资源
FileInputStream fis = new FileInputStream("D://123.txt");
// 操作
} catch (Exception e) {
// 错误处理
}finally{
// 关闭资源
}
// 1.7开始 有了新写法
try(
// 打开资源,自动关闭
FileInputStream fis22 = new FileInputStream("D://123.txt");
) {
// 操作
} catch (Exception e) {
// 错误处理
}
Throws
// throws : 这种方式并不会把问题解决,只是告诉调用人员,这里可能有异常,我没有解决,你注意一下
// 如果人家提醒了调用处,那么调用处要么还向上抛出(throws),要么解决(try..catch..)
public static void m1(){
try {
m2();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public static void m2() throws FileNotFoundException{
m3();
}
public static void m3() throws FileNotFoundException{
new FileInputStream("");
}
/**
* throws 多个异常也可以, 用 逗号 隔开
*/
public class Exception_06 {
// throws 多个异常也可以, 用 逗号 隔开
public static void main(String[] args) throws Exception,FileNotFoundException,IOException {
}
}
Finally
/**
* 有时候我们会碰到在程序出错的情况下,某些代码必须要执行
* 比如 关闭资源 此时可以把该代码放到finally语句中
*
* 1 finally 不能单独出现
* 2 可以和try一起使用
* 3 也可以和try..catch..一起使用
* 4 finally语句 一定会执行,唯一一种不执行情况就是 System.exit() 关闭虚拟机
*/
public class Exception_07 {
public static void main(String[] args) {
try {
// 除数不能为0 会报错
int c = 10 /0;
} finally {
// 依旧执行
System.out.println("执行");
}
// 不会执行,因为没有catch 没有捕获异常,还是会终止程序生命周期执行
System.out.println("xxxxxxxxxxxx");
}
}
int i = 10;
try {
// 会执行++ 操作 但是++完之后,要执行return命令的时候
// 发现 finally中优先级高,则放弃return操作
// 在编译阶段,由于finally中有return 所以编译的时候, 这里就会把return去掉,就等于只有 i++;
return i++;
} catch (Exception e) {
}finally{
System.out.println("---------"+i);
// 返回 11
return i;
}
子类覆写的方法,抛出的异常,只能是父类抛出的异常或者是父类抛出的异常类的子类
小于等于关系
class A {
public void m1() throws IOException {
}
}
class B extends A {
@Override
// 和父类异常一样 没问题
// public void m1() throws IOException{
// 父类异常的子类 没问题
// public void m1() throws FileNotFoundException{
// 不抛异常 没问题
// public void m1() {
// 父类异常的父类 不行
// public void m1() throws Exception{
public void m1() {
}
}
自定义异常
异常也是一个类,只不过该类一般用于描述出现了某种错误
/**
* 自定义异常类
* 1 继承一个已有的异常类
* 判断你应该是运行时异常还是编译时异常,如果是运行时异常就继承RuntimeException,否则就继承Exception即可
* 一般情况,都是编译异常
* 2 公共的无参构造
* 3 有参构造(String 错误信息) 把错误信息传递到父类
*
*/
public class UserException extends Exception{
public UserException(){
}
public UserException(String msg){
super(msg);
}
}