第11天内容常用API-异常

于 2020-07-20 20:26:11 发布
阅读量149 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49054155/article/details/107472519
版权

常用API-异常

Calendar类

java.util.Calendar日历对象类,取代Date类的部分功能.

日历类是抽象类,不能创建对象,利用子类对象 GregorianCalendar

Calendar类静态的方法 static Calendar getInstance() 获取了子类的对象,返回值是父类类型

Calendar cal = Calendar.getInstance() : 获取子类对象

日历字段

组成一个日历,需要最基本的数据,年,月,日,小时,分钟… …

组成部分称为日历字段,日历自动的数据类型是int类型

Calendar类的方法

方法 : 是Calendar类中定义的方法,如果方法是抽象的,执行子类方法重写

方法不是抽象的, 子类继承直接来使用.

方法返回值方法名字方法解释
static CalendargetInstace()静态方法,返回子类对象
intget(int)返回指定的日历字段数据
voidset(int,int,int)设置日历,传递年,月,日
voidset(int,int)设置日历,设置指定的某个日历字段
voidadd(int,int)日历字段的偏移量
public static void main(String[] args) {
		Calendar cal = Calendar.getInstance();
		/*
		 * get方法获取日历字段
		 * 年,月,日,小时,分钟... ...
		 * 日历自动使用的是int类型表示 1 2 3 分别代表什么,不清楚
		 * 变量表示 - 见名知意
		 * Calendar的静态成员变量
		 */
		System.out.println( cal.get(Calendar.YEAR)+"年" +  (cal.get(Calendar.MONTH) + 1) + "月" + 
		                  cal.get(Calendar.DAY_OF_MONTH) + "日");
	}

	public static void main(String[] args) {
		Calendar cal = Calendar.getInstance();
		//设置日历,设置到今年的10月份
		//参数1:设置哪个字段, 参数2: 具体数据
		//cal.set(Calendar.MONTH, 9);
		
		//设置日历,设置到2030年的5月1日
		cal.set(2030, 4, 1);
		
		//打印输出日历
		System.out.println( cal.get(Calendar.YEAR)+"年" +  (cal.get(Calendar.MONTH) + 1) + "月" + 
                cal.get(Calendar.DAY_OF_MONTH) + "日");
	}

public static void main(String[] args) {
    Calendar cal = Calendar.getInstance();
    //当前日历,向后偏移180天
    //参数1: 要偏移的字段, 参数2: 具体数据
    cal.add(Calendar.DAY_OF_MONTH, 180);
    //打印输出日历
    System.out.println( cal.get(Calendar.YEAR)+"年" +  (cal.get(Calendar.MONTH) + 1) + "月" +  cal.get(Calendar.DAY_OF_MONTH) + "日");
}

日历的练习

需求 : 计算闰年

提供年份,计算出是不是闰年

实现思想 : 闰年的2月是29天,日历设置到这年的3月1日,向前偏移1天

public static void main(String[] args) {
    Calendar cal = Calendar.getInstance();
    //设置日历  3月1日
    cal.set(3024, 2, 1);
    //向前偏移1天
    cal.add(Calendar.DAY_OF_MONTH, -1);
    //取出天数
    int i = cal.get(Calendar.DAY_OF_MONTH);
    System.out.println(i);
}

Math类

java.lang.Math类,实现了数学计算的类,包括对数,底数,三角函数等运算

不能创建对象,因为构造方法被私有修饰,方法全部是静态方法,Math.调用()

返回值方法名方法解释
static intabs(int a)返回参数a的绝对值
static doubleceil(double a)对参数a向上取整,返回大于或者等于参数的最小整数
static doublefloor(double a)对参数a向下取整,返回大于或者等于参数的最大整数
static longround(double a)对参数四舍五入,取整数部分
static doublepow(double a,double b)幂运算,a的b次方
static doublerandom()返回随机数,范围0.0-1.0之间,可能是0.0不会到1.0
static doublesqrt(double a)对参数进行平方很计算
public static void main(String[] args) {
    //abs方法,绝对值
    System.out.println("绝对值 " + Math.abs(-5) );

    //ceil方法,向上取整
    System.out.println("向上取整  " + Math.ceil(12.56) );

    //floor方法,向下取整
    System.out.println("向下取整 " + Math.floor(-12.56));

    //round方法,四舍五入,取整数
    System.out.println("四舍五入 " + Math.round(5.49999999));

    //pow方法,幂运算  3个2相乘 
    System.out.println("幂运算 " + Math.pow(2, 3));

    //random方法,随机数
    System.out.println("随机数 " + Math.random());

    //sqrt方法,平方根
    System.out.println("平方根 " + Math.sqrt(3));
	}

大数据运算

当数字,超过long的取值范围,这样的数据是真实存在的.Java认为 ,超过long的取值范围不能称为数字,称为超级大数对象,对象是由类产生:

java.math.BigInteger 超级大整数

java.math.BigDecimal 超级大的浮点数 (精确的浮点运算)

BigInteger

构造方法: new BigInteger(String val) 参数是字符串类型,可以写任意的长度,但是必须是数字.

创建BigInteger对象,封装超级大数

方法: + - * /

返回值方法名方法解释
BigIntegeradd(BigInteger big)两个大数求和
BigIntegersubtract(BigInteger big)两个大数减法
BigIntegermultiply(BigInteger big)两个大数乘法
BigIntegerdivide(BigInteger big)两个大数除法
public static void main(String[] args) {
    //创建BigInteger大数对象,构造方法中,传递字符串
    BigInteger big1 = new BigInteger("1234567890987654321234567890");
    //9223372036854775807
    BigInteger big2 = new BigInteger("23245678908765432456786543");

    //求和 big1 + big2 计算结果,是BigInteger对象
    BigInteger bigAdd = big1.add(big2);
    System.out.println(bigAdd);

    //减法 big1 - big2
    BigInteger bigSub = big1.subtract(big2);
    System.out.println(bigSub);

    //乘法 big1 * big2
    BigInteger bigMul = big1.multiply(big2);
    System.out.println(bigMul);

    //除法 big1 / big2
    BigInteger bigDiv = big1.divide(big2);
    System.out.println(bigDiv);
	}

BigDecimal

精确的浮点数运算.计算财务问题

构造方法 : BigDecimal(String val) 传递字符串,保证精度,可以任意长度

四则运算和BigInteger几乎一样的

区别在除法运算, 出现无限小数

方法返回值方法名解释
BigDecimaldivide(BigDecimal big)两个大数的除法运算,高精度
BigDecimaldivide(BigDecimal big,int s ,int round)参数含义 : 自定义的精度计算,(取舍)
static intROUND_DOWN舍入模式,直接舍去
static intROUND_UP舍入模式,向上+1
static intROUND_HALF_UP舍入模式,四舍五入
public static void main(String[] args) {
		BigDecimal big1 = new BigDecimal("5.055");
		BigDecimal big2 = new BigDecimal("1.0005");
		
		BigDecimal bigMul = big1.multiply(big2);
		System.out.println(bigMul);
		
		//System.out.println(5.055*1.0005);
		
		BigDecimal big4 = new BigDecimal("3.55");
		BigDecimal big5 = new BigDecimal("1.35");
		//除法计算 big4 / big5
		
		//2.62962962962963
		/*
		 * BigDecimal divisor, int scale, int roundingMode)
		 * divisor 被除数 big5
		 * scale 要保留的位数
		 * roundingMode 舍入模式  ROUND_DOWN 直接舍去
		 * roundingMode 舍入模式  ROUND_UP 向上+1
		 * roundingMode 舍入模式  ROUND_HALF_UP 四舍五入向上+1
		 */
		BigDecimal bigDiv = big4.divide(big5,3,BigDecimal.ROUND_HALF_UP);
		System.out.println(bigDiv);
	}

基本数据类型包装类

基本数据类型,提供的功能基本都是运算为主. 实际工作中这些功能是不够的,因此提高了一套包装类,作用将基本数据类型变成对象, 对象具有的功能就会更多.

基本类型包装类 : 主要实现了一个非常关键的功能 : 基本类型和字符串之间的相互转换 “1”

包装类都在java.lang

基本数据类型对应的包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

int类型的包装类 Integer类, 其他的包装类的用法基本都一样的

Integer类的使用

内部包装了一个int数据类型,变成了对象.

  • 字符串String转成基本数据类型int
    • Integer类静态方法 : static int parseInt(String s) 字符串转成基本类型int,字符串必须是数字格式
    • Integer对象转换 : Integer构造方法(String val) 字符串必须数字格式
    • Integer对象转换 : static Integer valueOf(String val) 字符串必须数字格式
    • Integer对象的方法: int intValue() 字符串转成基本类型int
	public static void main(String[] args) {
		//传递的参数是100,返回值基本类型int
		int i = Integer.parseInt("100");
		System.out.println(i+1);
		
		//创建Integer对象
		Integer integer = new Integer("10");
		//对象的方法 intValue(),构造方法中的 字符串,转成基本类型
		int j = integer.intValue();
		System.out.println(j+1);
		
		//Integer类的静态方法 valueOf 创建出Integer的对象
		Integer integer2 = Integer.valueOf("20");
		int k = integer2.intValue();
		System.out.println(k+1);
	}

自动装箱和自动拆箱

自动的装箱和拆箱,无需程序人员参与这个过程,但是原理要学习.

是JDK1.5出现

自动装箱 : 基本数据类型,自动变成对象

自动拆箱 : 对象,自动变成基本数据类型

public static void main(String[] args) {
    //自动装箱, 基本类型自动变成对象
    /*
    * Integer是类名,引用数据类型
    * 引用数据类型变量 i  指向一个对象
    * 1 是基本类型,自动装箱成为对象
    */
    Integer i = 1;

    /*
    *  i 变量是引用类型,保存是内存地址
    *  能和1相加吗
    *  引用类型变量 i 自动拆箱,对象变成基本类型 1了
    *  1 + 1 =  2, 2 赋值变量i
    *  i = 2计算,进行自动装箱
    */
    i = i + 1;
    System.out.println(i);
}

自动装箱和自动拆箱面试

public static void main(String[] args) {
    Integer i = new Integer(100);
    Integer j = new Integer(100);

    System.out.println( i == j); // == 引用类型,比较内存地址   false
    System.out.println(i.equals(j)); // equals方法继承父类重写  true

    System.out.println("==========");

    Integer ii = 200; // valueOf() = new Integer()
    Integer jj = 200;
    System.out.println(ii == jj); // == 引用类型,比较内存地址  false
    System.out.println(ii.equals(jj));  // equals方法继承父类重写  true

    System.out.println("==========");

    Integer iii = 127;
    Integer jjj = 127;
    System.out.println(iii == jjj); //== 引用类型,比较内存地址 true
    System.out.println(iii.equals(jjj)); // true

    //装箱 , 范围是byte之间,不new对象
    //Integer a = Integer.valueOf(1); // 源码中 valueOf方法里面new Integer对象
}

正则表达式

正则表达式介绍 : 正则是专门对字符串处理的一种技术.

String,StringBuilder都是操作字符串,但是他们的功能远远不够, 正则表达式出现,填补了字符串操作的空白.

用户输入QQ号 : 验证QQ号码是否是合法的

QQ号码 : 全数字,不能0开头,位数6-10位

public static void main(String[] args) {
		boolean b = checkQQ("34567");
		System.out.println(b);
	}
	/*
	 * 定义方法,验证QQ号码
	 * 验证通过返回true,否则返回false
	 * 全数字,不能0开头,位数6-10位
	 */
	public static boolean checkQQ(String qq) {
		// 字符串的长度,验证位数
		if( qq.length() < 6 || qq.length() > 10)
			return false;
		//字符串开头方法 startsWith , 0开头,if就是true
		if(qq.startsWith("0"))
			return false;
		//全数字 QQ号码拆分成单个字符,一个个验证
		char[] ch = qq.toCharArray();
		for(int i = 0 ; i < ch.length ; i++) {
			if( ch[i] < 48 || ch[i] > 57 )
				return false;
		}
		return true;
	}

正则表达式规则

  • 字符类
    • [abc] 字符匹配abc
    • [a-z] 字符匹配所有的小写字母
    • [a-zA-Z] 字符匹配所有的字母
    • [^a-z] 匹配所有的非小写字母
    • [^abc] 字符匹配不是abc
    • [a-zA-Z0-9_] 字符匹配所有的字母,数字和下划线
    • [^a-zA-Z0-9_] 字符匹配不是字母,不是数字,不是下划线
  • 预定义字符类
    • . 匹配任意字符
    • [\w]匹配所有的单词字符,等同于 [a-zA-Z0-9_]
    • [\W] 匹配所有的非单词字符,等同于 [^a-zA-Z0-9_]
    • [\d] 匹配所有数组,等同于[0-9]
    • [\D] 匹配非数字 , 等同于[^0-9]
  • 次数类
    • X? 这个字符X,出现的次数,一次或者一次也没有
    • X* 这个字符X,出现零次或者多次
    • X+ 这个字符X,出现一次或者多次
    • X{m} 这个字符X,出现正好m次
    • X{m,} 这个字符X,出现至少m次
    • X{m,n} 这个字符X,出现至少m次,但是不超过n次

正则表达式匹配方法

String类的方法 matches

  • boolean matches(String reg)
    • 正则表达式验证的方法
    • 参数传递正则的规则
    • 字符串和规则匹配,返回true
public static void main(String[] args) {
		boolean b = checkQQ("1245");
		System.out.println(b);
		
		b = checkNumber("13800138000");
		System.out.println(b);
	}
	/*
	 * 验证手机号
	 * 全数字, 1开头,必须11位 第二位不能是012
	 * 13800138000 
	 */
	public static boolean checkNumber(String number) {
		//定义手机号规则
		String reg = "1[3745689][0-9]{9}";
		return number.matches(reg);
	}
	
	/*
	 * 定义方法,验证QQ号码
	 * 验证通过返回true,否则返回false
	 * 全数字,不能0开头,位数6-10位
	 */
	public static boolean checkQQ(String qq) {
		//正则表达式,定义QQ号码规则
		//QQ号码第一位是数字,不能0开头
		//QQ号码第二位,必须数字
		//QQ号码第三位,数字
		String reg = "[1-9][0-9]{5,9}";
		return qq.matches(reg);
	}

正则表达式切割方法

String类的方法split

  • String[] split(String reg)
    • 按照指定的正则表达式进行切割
    • 参数reg传递正则表达式
public static void main(String[] args) {
    //正则表达式对字符串切割
    //String str = "ab123cd45ef999909gh";
    //按照数字,对字符串切割
    //String[] array = str.split("[\\d]+");

    String ip = "10....10...........18.28";
    String[] array = ip.split("\\.+");
    System.out.println(array.length);
    for(int i = 0 ; i < array.length ; i++) {
    	System.out.println(array[i]);
    }
}

正则表达式替换方法

String类的方法 replaceAll()

  • String replaceAll("正则规则","要替换内容")
public static void main(String[] args) {
    String str = "assdfg23432ewge098765rewg3232ewflkjjf12321lw";
    //字符串的所有数组,替换为一个 #
    String rep = str.replaceAll("\\d+", "#");
    System.out.println(rep);
}

异常

异常概念 : 程序在运行过程中,出现的不正常现象,就是异常

异常也是对象 : 都是由异常类产生的

Java语言的异常的继承体系

  • java.lang.Throwable 所有异常和错误的父类
    • java.lang.Error 所有错误的父类
    • java.lang.Exception 所有异常的父类
      • java.lang.RuntimeException 运行时异常
  • Error错误和Exception异常的区别
    • Error错误 : 理解人病了,非典,艾滋,癌症, 等死
      • 程序一旦反生错误,根本运行不了,修改源码
    • Exception异常 : 阑尾炎,感冒,划伤, 治好以后和以前一样
      • 程序一旦发生异常,处理完,继续执行

Throwable类的方法

所有的异常和错误,都是子类, Throwable类的方法,都会被继承使用

  • String toString() 返回异常信息的简短描述
  • String getMessage() 返回异常信息的详细描述
  • void printStackTrace() 将异常信息,追踪到标准错误流 (目前,方法可以异常信息输出在控制台)

异常引发过程和JVM默认处理机制

异常信息输出打印,停止程序的允许

public static void main(String[] args) {
    int[] arr = {1,2,3};
    int i = getArray(arr);
    System.out.println(i);
    System.out.println("程序结束");
}

public static int getArray(int[] arr) {
	return arr[5];
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eOsWTYg7-1595247932650)(images/异常产生过程和JVM处理方式.jpg)]

异常的处理方式 try catch

  • try{} catch(){}异常的处理

    语法格式:

try{
  //被检测的代码,或者是可能出现异常代码
}catch(异常类的名字 变量){
  //异常的处理方式
  //变量,循环,判断,new对象,调用方法
}


public static void main(String[] args) {
    int[] arr = {1,2,3};
    try {
        int i = getArray(arr);
        System.out.println(i);
    }catch(Exception e) {
    	System.out.println("异常被处理了");
    }

    System.out.println("程序结束");
    }

    public static int getArray(int[] arr) {
    	return arr[0];
	}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vmvq6dUY-1595247932655)(images/try…catch异常处理.jpg)]

  • try{} catch(){}异常的处理 , 多catch并行处理

    语法格式 :

    try{
  //被检测的代码,或者是可能出现异常代码
}catch(异常类的名字 变量){
  //异常的处理方式
  //变量,循环,判断,new对象,调用方法
}catch(异常类的名字 变量){
  //异常的处理方式
}
    • 多catch并行处理 catch中的异常类名,写法很关键
      • 两个类之间,没有继承关系,顺序随意
      • 两个类之间,存在继承关系,父类写在最后面
    public static void main(String[] args) {
		//多catch并行处理,抓异常
		try {
			get(10);
		}catch(NullPointerException ex) {
			System.out.println("处理了空指针异常");
		}catch(ArrayIndexOutOfBoundsException ex) {
			System.out.println("处理了数组越界异常");
		}
	}
	
	/*
	 * 定义方法,传递参数 int类型
	 * 参数变量i的值是0 ,方法出现空指针异常
	 * 参数变量i的值非0 ,方法出现数组越界异常
	 */
	public static void get(int i) {
		if( i == 0) {
			int[] arr = null;
			System.out.println(arr[0]);
		}
		
		if( i != 0) {
			int[] arr = {1,2};
			System.out.println(arr[3]);
		}
	}

  • try{} catch(){}异常的处理 , 多catch合并为一个catch

    public static void main(String[] args) {
		//多catch并行处理,抓异常
		try {
			get(10);
		}catch(NullPointerException | ArrayIndexOutOfBoundsException e) {
			System.out.println("异常被处理");
		}
	}

Throwable类的方法

public static void main(String[] args) {
		//异常信息的用法
		try {
			get();
		}catch(ArrayIndexOutOfBoundsException ex) {
			//方法 toString()异常信息的简短描述
			System.out.println(ex); //  java.lang.ArrayIndexOutOfBoundsException: 3
			
			//方法 getMessage() 异常信息的详细描述
			String message = ex.getMessage();
			System.out.println(message); //  3
			
			//printStackTrace() 
			/*
			 * java.lang.ArrayIndexOutOfBoundsException: 3
				at exception.ExceptionDemo05.get(ExceptionDemo05.java:30)
				at exception.ExceptionDemo05.main(ExceptionDemo05.java:12)
			 */
	        ex.printStackTrace();

		}

finally代码块

finally代码块,是跟随try catch出现的,凡是写在finally代码块里的程序,必须执行

作用 : 释放资源

public static void main(String[] args) {
		//异常信息的用法
		try {
			get();
		}catch(ArrayIndexOutOfBoundsException ex) {
	        ex.printStackTrace();
		}finally {
			System.out.println("无论如何都运行");
		}
	}
	public static void get() {
		int[] arr = {1,2};
		System.out.println(arr[1]);	
	}

throw和throws

  • throw 抛出的意思,只能作用在方法里面,表示方法中会出现异常
  • throws 抛出的意思,只能作用在方法的定义上,告知调用者,我有异常
/*
 *  throw和throws
 *  
 *  遇到调用异常的方法,throws继续抛出,还是try 捕获,现在阶段,都可以
 *  以后不行 : 持久层抛出,业务层捕获
 */
public class ExceptionDemo08 {
	public static void main(String[] args) {
		/*
		 * 调用 了一个抛出异常的方法
		 * 必须处理,编译失败
		 * 一种在方法上,继续throws, 异常抛到JVM
		 */
		try {
			buy(0);
		}catch (Exception e) {
			System.out.println("异常被处理");
		}
				
		System.out.println("程序结束");
	}
	/*
	 * 方法演示
	 * 定义方法,传递参数(钱),方法的作用是买饭
	 * 方法的参数有问题,功能不能实现
	 * 
	 * 将方法内部异常,表现出来,告诉调用者
	 * 关键字 throws 后面写的是异常类的类名
	 */
	public static void buy(int money)throws Exception{
		if(money <= 0) {
			//抛出异常 throw关键字  抛出的是异常对象
			throw new Exception();
		}
	}
}

异常分类

  • 编译异常
    • 当我们调用了一个抛出异常的方法,调用者必须处理,要是不处理编译失败
    • 处理方式 try catch 也可以使用throws
  • 运行异常
    • 凡是RuntimeException类,和他的所有子类,全都是运行异常
    • 方法中如果抛出的异常是运行异常,方法的声明上不需要使用throws关键字
    • 方法调用者,是看不到方法内部有异常
    • 调用者调用方法,不要处理这个异常
    • 运行时期的异常,不能处理,一旦发生,程序人员必须修改源码
    • RuntimeException子类 :
      • 数组越界
      • 空指针异常
      • 类型转换异常 (ClassCastException)
      • 无效参数异常 IllegalArgumentException

子类父类的异常处理

  • 父类方法抛出异常
    • 子类继承父类,重写方法后,异常可以不抛
    • 子类继承父类,重写方法后,如果子类要抛异常,抛出的异常不能大于父类的
  • 父类方法不抛异常
    • 子类继承父类,重写方法后,也不能抛出异常
    • 如果子类调用了一个抛出异常的方法,子类只能是try catch处理
user_sunflowerus
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值