常用API和异常

常用API

date

获取当前系统时间

下面展示一些 内联代码片。

// A code block
var foo = 'bar';

public class date_01 {
	public static void main(String[] args) {
		Date now = new Date();
		//  Thu Jan 21 09:40:19 CST 2021  Date 重写了toString  但是是欧美风格
		System.out.println(now);
		
		// 格式化类  
		// y 是 年 M 是 月  d 是 日    H 是 时  m 是 分 s 是 秒  最后一个大写的S 是 毫秒
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
		String strTime = sdf.format(now);
		// 2021年01月21日 09:45:44 212  最后212 代表 缺
		System.out.println(strTime);
	}
}

字符串转date

下面展示一些 内联代码片。

*  SimpleDateFormat
 *  Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat
 *  类是一个不与语言环境有关的方式来格式化和解析日期的具体类。
 *  它允许进行格式化：日期à文本、解析：文本à日期
 *
 *  SimpleDateFormat() ：默认的模式和语言环境创建对象
 *  public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern
 *  指定的格式创建一个对象，该对象调用：
 *  public String format(Date date)：方法格式化时间对象date
 *
 *  public Date parse(String source)：从给定字符串的开始解析文本，以生成
 *  一个日期。
 * @杜智慧
 *
 * @Date 2021年1月21日
 */

public class date_02 {
	public static void main(String[] args) throws ParseException {
		// 首先创建一个String类型的字符串 , 其内存储具有一定格式的时间字符串 , 这里用了date_01里的格式
		String stringDate = "2021年01月21日 18:20:31 416";
		// 将这个字符串的格式以yyyy年MM月dd日 HH:mm:ss SSS的方式创建一个 SimpleDateFormat对象
		SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
		// 再将这个对象的.parse赋值给Date类型的对象
		Date date = sd.parse(stringDate); // 这里会报错 , 需要抛出异常 异常机制在Exception项目中讲解
		// 这样输出的date就回归了默认的格式  
		System.out.println(date);
		
	}
}

有参构造创建的对象

下面展示一些 内联代码片。

 * Date d1 = new Date();  这种以无参构造创建的对象 , 是获取当前系统时间 
 * Date d2 = new Date(long millisecond);  这种以有参构造创建的对象 , 是获取从时间原点到指定毫秒数的时间

public class date_03 {
	public static void main(String[] args) {
		// 这样获取的是当前系统时间
		Date d1 = new Date();
		System.out.println(d1);
		
		// 这样获取的是从时间原点到指定毫秒数的时间
		Date d2 = new Date(1000);
		// Thu Jan 01 08:00:01 CST 1970  从时间原点1970年1月1日 08:00:00  开始 往后一毫秒
		System.out.println(d2);
		
		// 问 : 如何获取当前 系统时间的前10分钟的时间 
		// 结题思路 : 首先我们可以获取当前系统时间的毫秒数 , 然后可以算出来十分钟有多少毫秒
		// 那么十分钟前的毫秒数就可以通过计算得出 , 再利用有参构造就可以输出十分钟前的时间了
		// 获取当前时间的毫秒数
		long millisecond = System.currentTimeMillis();
		millisecond = millisecond - 1000*60*10; // 1000代表一毫秒
		Date d3 = new Date(millisecond);
		// 这样就可以输出十分钟前的时间了
		System.out.println(d3);
		// 如果想输出date_01里格式的时间 , 就再创建一个SimpleDateFormat对象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
		// 并输出sdf.format  这样输出的就是我们能接受的格式了
		System.out.println(sdf.format(d3));
	}
}

日历

下面展示一些 内联代码片。

* 1、Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。
 * 2、获取Calendar实例的方法
 * 使用Calendar.getInstance()方法
 * 调用它的子类GregorianCalendar的构造器。
 * 3、一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想 要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、 MINUTE、SECOND
 * public void set(int field,int value)
 * public void add(int field,int amount)
 * public final Date getTime()
 * public final void setTime(Date date)
 * 4、注意:
 * 获取月份时：一月是0，二月是1，以此类推，12月是11
 * 获取星期时：周日是1，周二是2 ， 。。。。周六是7

public class date_04 {
	public static void main(String[] args) {
		// 创建日历对象  创建之前导包 
		Calendar c1 = Calendar.getInstance();
		// 获取现在是一周的第几天 (以周日为第一天)
		System.out.println(c1.get(Calendar.DAY_OF_WEEK));
		// 获取现在是一个月里的第几天 (今天是几号)
		System.out.println(c1.get(Calendar.DAY_OF_MONTH));
		// 获取今年是几几年
		int year = c1.get(Calendar.YEAR);
		// 获取月 从0开始,所以结果+1
		int month = c1.get(Calendar.MONTH) + 1;
		// 获取日
		int day = c1.get(Calendar.DAY_OF_MONTH);

		// 获取时
		int hour = c1.get(Calendar.HOUR);
		// 获取分
		int minute = c1.get(Calendar.MINUTE);
		// 获取秒
		int second = c1.get(Calendar.SECOND);
		// 获取本周第几天
		int weekday = c1.get(Calendar.DAY_OF_WEEK);
		
		
		// 把本周的第几天转换为星期几
		String weekDaystr = "星期";
		// 利用switch case语句 做一个类似枚举的操作
		switch (weekday) {
		case 1:
			weekDaystr += "日";
			break;
		case 2:
			weekDaystr += "一";
			break;
		case 3:
			weekDaystr += "二";
			break;
		case 4:
			weekDaystr += "三";
			break;
		case 5:
			weekDaystr += "四";
			break;
		case 6:
			weekDaystr += "五";
			break;
		case 7:
			weekDaystr += "六";
			break;

		default:
			break;
		}
		System.out.println(year+"年"+month+"月"+day+"日  "+hour+":"+minute+":"+second+"  "+ weekDaystr);
	}
}

枚举

第一种

下面展示一些 内联代码片。

* 枚举类型是Java 5中新增特性的一部分，它是一种特殊的数据类型
 * 之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束
 * 但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性。
 * 
 *          -------------- https://www.cnblogs.com/zhanqing/p/11076646.html
 *          
 * 比如_01_DATE包 date_04类里的将其转换为星期几的方法 就是枚举
 * 写枚举 更容易发现错误,因为在编译阶段对类型进行检查,从而减少错误
 * 当我们需要一系列的有限的值的时候 ,并且用的较多 , 而且不更改的情况下(使用常量的时候 )
 * 写枚举更容易发现错误 , 因为在编译阶段对类型进行检查 , 从而减少错误
 *  (单独搞一个类写枚举  这样可以避免拼写错误 , 但是 从Java1.5之后 , 这种写法就显得比较繁琐了 , 因为1.5引入了枚举)
 *  Enum将枚举变得更为简洁方便
 *  
 *  简单来讲 , 枚举就是一个常量集

public class Enum_01 {
	public static void main(String[] args) {
		String  userName = "admin";
		String password = "root";
		String  result = login(userName, password);
		// 始终是报错 , 原因在于SUCCESSS 多写了一个S 这很显然是一个粗心大意的错 
		// 但是如果找的话是很难找到的 , ,如果使用枚举就可以避免这种错误
		if ("SUCCESSS".equals(result)) {
			System.out.println("登陆成功");
		}else {
			System.out.println("登陆失败");
		}
	}
	public static String login (String  userName ,String password){
		if ("admin".equals(userName) && "root".equals(password)) {
			return "SUCCESS";
		}else{
			return "FAIL";
		}
		
	}
}

对第一种的优化

下面展示一些 内联代码片。

// A code block
var foo = 'bar';

public class Enum_02 {
	public static void main(String[] args) {
		String  userName = "admin";
		String password = "root";
		String  result = login(userName, password);
		// 始终是报错 , 原因在于SUCCESSS 多写了一个S 这很显然是一个粗心大意的错 
		// 但是如果找的话是很难找到的 , ,如果使用枚举就可以避免这种错误
		// 在需要使用这个常量的地方 都用这个类的静态变量来代替
		if (Result.SUCCESS.equals(result)) {
			System.out.println("登陆成功");
		}else {
			System.out.println("登陆失败");
		}
	}
	public static String login (String  userName ,String password){
		if ("admin".equals(userName) && "root".equals(password)) {
			return Result.SUCCESS;
		}else{
			return Result.FAIL;
		}
	}
}
// 首先我们在这里写一个常量类 这样在需要的时候 , 编译器会直接提示 , 只需要将提示的词搞上去就行
// 这样可以避免拼写错误
final class Result {
	public static final String SUCCESS = "SUCCESS";
	public static final String FAIL = "FAIL";
}

对第二种的优化(从java1.5开始)

下面展示一些 内联代码片。

// A code block
var foo = 'bar';

public class Enum_03 {
	public static void main(String[] args) {
		String  userName = "admin";
		String password = "root";
		ResultEnum  result = login(userName, password);
		// 始终是报错 , 原因在于SUCCESSS 多写了一个S 这很显然是一个粗心大意的错 
		// 但是如果找的话是很难找到的 , ,如果使用枚举就可以避免这种错误
		// 在需要使用这个常量的地方 都用这个类的静态变量来代替
		if (ResultEnum.SUCCESS==result) {
			System.out.println("登陆成功");
		}else {
			System.out.println("登陆失败");
		}
	}
	// 要注意 , 返回的应该是ResultEnum  这个枚举类类型的值
	public static ResultEnum login (String  userName ,String password){
		if ("admin".equals(userName) && "root".equals(password)) {
			return ResultEnum.SUCCESS;
		}else{
			return ResultEnum.FAIL;
		}
	}
		
}
// 枚举  他也是一个类
enum ResultEnum {
	SUCCESS,FAIL
}

Integer

下面展示一些 内联代码片。

* 包装类 : 封装了基本类型的操作,更方便我们使用  一共八种
 *      byte -- java.lang.Byte
 * 		short -- java.lang.Short
 * 		int  -- java.lang.Integer
 * 		long -- java.lang.Long
 * 		float -- java.lang.Float
 * 		double  -- java.lang.Double
 * 		char  -- java.lang.Character
 * 		boolean -- java.lang.Boolean
 * 
 * 使用包装类一是为了 方便 二是 为了理论上的完整(面向对象)
 *  
 * 想要创建一个方法,该方法可以接收任何类型
 * 		使用Object类 ,因为Object是所有类的祖类,由于多态的原因,可以接收任何对象
 * 			但是基本类型并不是Object的子类 , 所以就有了包装类的概念
 * 			包装类 ,  可以把基本类型转换为对应的包装类类型,而包装类也是个类,也是Object的子类
 * @杜智慧
 *
 * @Date 2021年1月20日
 */

public class integer_01 {
	public static void main(String[] args) {
		// 基本类型
		byte b1 = 2;
		// 引用类型
		Byte b2 = null;
		// 把 b1 基本类型封装到b2引用类型中
		b2 = new Byte(b1);
		
		// 可以把b2 传入 接收Object的方法中,因为多态
		m1(b2);
	}
	public static void m1(Object obj){
		// 由于 覆写了toString方法,所以可以直接打印 2 ,而不是内存地址
		System.out.println(obj);
	}
}

以integer为例 讲解八种包装类

下面展示一些 内联代码片。

// A code block
var foo = 'bar';

public class integer_02 {
	public static void main(String[] args) {
		// 1 获取最大值和最小值
		System.out.println("int最大值 : " + Integer.MAX_VALUE);
		System.out.println("int最小值 : " + Integer.MIN_VALUE);
		System.out.println("long最大值 : " + Long.MAX_VALUE);
		System.out.println("long最小值 : " + Long.MIN_VALUE);
		System.out.println(Short.MAX_VALUE);
		System.out.println(Short.MIN_VALUE);
		System.out.println((int) (Character.MAX_VALUE));
		System.out.println((int) (Character.MIN_VALUE));
		
		// 2 创建对象
		Integer i1 = new Integer(12); // int -- Integer
		// 可以传入纯数字的字符串
		Integer i2 = new Integer("19776"); // String -- Integer
		
		System.out.println(i1);
		System.out.println(i2);
		// 编译可以通过,但是运行出错
		// java.lang.NumberFormatException: For input string: "19776a"
		Integer ie = new Integer("19776a");
	}
}

常用方法

下面展示一些 内联代码片。

// A code block
var foo = 'bar';

public class integer_03 {
	public static void main(String[] args) {
		// 1 int --> Integer
		Integer i1 = new Integer(22);

		// 2 Integer --> int
		int i2 = i1.intValue();

		// 3 重要 : static int parseInt(String s) : 把字符串转换为int
		// String --> int
		int i3 = Integer.parseInt("123");
		System.out.println(i3);

		// 4 重要
		double d1 = Double.parseDouble("12.3");
		System.out.println(d1);

		// 5 static String toBinaryString(int value) : 把指定int值转换为二进制的字符串形式展示
		String s1 = Integer.toBinaryString(10);
		System.out.println(s1);

		// 6 十六进制展示
		System.out.println(Integer.toHexString(30));
		// 7 八进制展示
		System.out.println(Integer.toOctalString(10));
		
		// 8 int --> Integer 
		Integer i31 = Integer.valueOf(28); 
		// String --> Integer
		Integer i32 = Integer.valueOf("123");
		
		// 9 Integer -- String
		String s2 = i31.toString();
		System.out.println(i31);
		System.out.println(s2);
	}
}

Integer , int , String 三者之间类型转换

下面展示一些 内联代码片。

// A code block
var foo = 'bar';

public class integer_04 {

	public static void main(String[] args) {
		// 1 int -- > Integer
		Integer i1 = new Integer(222);
		Integer i2 = Integer.valueOf(222);
		
		// 2 Integer --> int
		int i3 = i2.intValue();

		// 3 String --> Integer
		Integer i4 =  Integer.valueOf("123");
		Integer i5 = new Integer("12313");

		// 4 Integer --> String
		String s1 = i5.toString();

		// 5 String --> int
		int i6 = Integer.parseInt("12321");

		// 6 int --> String
		String s2 = 333+"";
	}
}

java1.5新特性

下面展示一些 内联代码片。

 * 		自动装箱
 * 				把 基本数据类型 自动转换为 对应的包装类
 * 		
 * 		自动拆箱
 * 				把 包装类 自动转换为 基本数据类型
 * @杜智慧
 *
 * @Date 2021年1月20日
 */

public class integer_05 {
public static void main(String[] args) {
		
		// 1.5之前
		// 自动装箱之前的转换方式
		Integer i1 = new Integer(223); // Integer.vlaueOf(2222)
		// 自动拆箱之前的转换方式
		int i3 = i1.intValue();
		
		
		// 1.5 开始
		// 自动装箱之后的转换方式  
		Integer i2 = 222;  // 编译完后 就等于是 : Integer i2  = Integer.vlaueOf(222);
		// 自动拆箱之后的转换方式
		int i4 = i1; // 拆箱
		
		// 2 是基本类型,会先自动装箱转换为Integer类型,然后再向上转型(多态) 转换为Object
		m1(2);
	}
	public static void m1(Object obj){
		// 由于 覆写了toString方法,所以可以直接打印 2 ,而不是内存地址
		System.out.println(obj);
	}
}

自动装箱和拆箱的底层原理

下面展示一些 内联代码片。

*      1 都是编译时的概念,和运行时无关
 * 		 2 装箱的时候,会在编译时 自动把赋值 操作 变成 Integer.valueOf(222)
 * 
 * String , Integer,Double 等 八种包装类 和String 都覆写了toString(),equals() , hashCode() 方法
 * 
 * valueOf : 把基本类型转换为Integer类型
 * 
 * 		但是里面初始化了一个整型常量池,值的范围是在 -128~127之间
 * 		其实  就是一个Integer[] 数组 有 256个对象,对象中的int值 分别为 -128,-127.....126,127  下标 是 0~ 255
 * 				如果 值 在 -128~127之间 就直接去这个缓存数组中找对应的对象即可,不用再重新创建Integer对象
 * @杜智慧
 *
 * @Date 2021年1月20日
 */

public class integer_06 {
public static void main(String[] args) {
		
		// 自动装箱 , 就等于 Integer i1 = Integer.valueOf(123);
		Integer i1 = 123;
		Integer i2 = 123;
		System.out.println(i1 == i2);
		// 等于 Integer i3 = Integer.valueOf(128);  不过 和 new Integer(128)  没啥区别,因为不符合常量池值的大小,所以是新new
		Integer i3 = 128;
		Integer i4 = 128;
		System.out.println(i3 == i4);
		
		// 以下  结果 和 上面结果 相同
		Integer i5 = Integer.valueOf(123);
		Integer i6 = Integer.valueOf(123);
		System.out.println(i5 == i6);
		
		Integer i7 = Integer.valueOf(128);
		Integer i8 = Integer.valueOf(128); 
		System.out.println(i7 == i8);
		
		// new 的方式  肯定是不行的,因为new了两次,对象内存地址不同,所以 == 比较内存地址,肯定是false,但是 使用equals 一定是true,因为都是1
		Integer i9 = new Integer(1);
		Integer i10 = new Integer(1);
		System.out.println(i9 == i10);
		System.out.println(i9.equals(i10));
	}
}

Math

下面展示一些 内联代码片。

 * 提供科学的计算和基本的数字操作方法
 * 常用的方法都是静态的 , 直接类名调用就可以 , Math在Java.lang.Matj 所以不需要导包

public class Math_01 {
	public static void main(String[] args) {
		// abs  绝对值
		System.out.println(Math.abs(-9.2));
		
		// ceil: 向上取整
		System.out.println(Math.ceil(12.1));
		
		// floor : 向下取整
		System.out.println(Math.floor(12.1));
		
		// max : 比较谁大
		System.out.println(Math.max(3, 2));
		
		// min : 比较谁小
		System.out.println(Math.min(3, 2));
		
		// sqrt  : 开平方  取负数的时候会有-----> NaN : Not a Number
		System.out.println(Math.sqrt(9));
		
		// cbrt  : 立方根
		System.out.println(Math.cbrt(27));
		
		// random  :  随机数  从0~1之间  *10 就是1~10之间
		System.out.println(Math.random()*10);
		
		// rint  : 四舍五入  注意 , X.5的值是取偶数 比如1.5会取2 , 2.5也取2 除了xx.5 其他的按照四舍五入来
		System.out.println(Math.rint(1.1));
		System.out.println(Math.rint(1.5));
		System.out.println(Math.rint(2.6));
		System.out.println(Math.rint(3.5));
		
		// pow : 几次幂 , 如 2的3次方
		System.out.println(Math.pow(2, 3)); // 8.0
	}
}

Nmuber

数字格式化

下面展示一些 内联代码片。

 *     #代表任意数字  , 0~9任意单个数字
 *     ,表示千分位 
 *     . 小数点
 *     0 补位

public class Nmuber_01 {
	public static void main(String[] args) {
		// 千分位分割
		DecimalFormat df = new DecimalFormat("###,###");
		System.out.println(df.format(123456));
		
		// 加入千分位 保留两位小数
		 df = new DecimalFormat("###,###.##");
		 System.out.println(df.format(123456.123)); // 进行四舍五入
	}
}

BigInteger

下面展示一些 内联代码片。

// A code block
var foo = 'bar';

public class BigInteger_01 {
	public static void main(String[] args) {
		BigInteger v1 = new BigInteger("100");
		BigInteger v2 = new BigInteger("20");
		// 加法
		System.out.println(v1.add(v2)); // 120
		// 减法
		System.out.println(v1.subtract(v2)); // 80
		// 乘法
		System.out.println(v1.multiply(v2)); // 2000
		// 除法
		System.out.println(v1.divide(v2)); // 5
		// 取余
		System.out.println(v1.remainder(v2)); // 0
		
		
		BigDecimal v3 = new BigDecimal(123);
		BigDecimal v4 = new BigDecimal(123);
		v3.add(v4);
		v3.subtract(v4);
		// .....
	}
}

Random

下面展示一些 内联代码片。

//  随机数  从0 开始

public class Random_01 {
	public static void main(String[] args){
		// 创建对象 
		Random r = new Random();
		// 在0~100之间随机输出 共101个数
		int i = r.nextInt(101);
		
		System.out.println(i);
		System.out.println(i+100);
		
		int j = r.nextInt(10);
		// 包括10 不包括20 
		System.out.println(j+10);
	}
}

异常

概念

Java提供的一种识别以及响应错误的一种机制

try…catch…

解决异常 , 一般在客户端 catch语句可以写多个 , 如果异常有继承关系 , 应该先写子类再写父类
否则因为多态 , 父类会把子类捕捉 , 多个异常只会执行一个 , 就是最开始发生错误的异常 , 剩下的就不会再执行了

throws

抛出异常 , 一般在类库端(服务端)

throw

制造异常 , 异常源点 , 创建一个异常对象

finally语句块

必须执行的语句块