1.时间日期类
1.1 Date类(应用)
(1) Date类概述:
Date 代表了一个特定的时间,精确到毫秒
(2)Date类构造方法:
public Date()
分配一个 Date对象,并初始化,以便它代表它被分配的时间,精确到毫秒 public Date(long date)
分配一个 Date对象,并将其初始化为表示从标准基准时间起指定的毫秒数
(3) 示例代码:
public class DateDemo01 {
public static void main(String[] args) {
//public Date():分配一个 Date对象,并初始化,以便它代表它被分配的时间,精确到毫秒
Date d1 = new Date();
System.out.println(d1);
//public Date(long date):分配一个 Date对象,并将其初始化为表示从标准基准时间起指定的毫秒
数
long date = 1000*60*60;
Date d2 = new Date(date);
System.out.println(d2);
}
}
1.2 Date类常用方法(应用)
(1)常用方法:
public long getTime()
获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time)
设置时间,给的是毫秒值
(2)代码示例:
public class DateDemo02 {
public static void main(String[] args) {
//创建日期对象
Date d = new Date();
//public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
// System.out.println(d.getTime());
// System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");
//public void setTime(long time):设置时间,给的是毫秒值
// long time = 1000*60*60;
long time = System.currentTimeMillis();
d.setTime(time);
System.out.println(d);
}
}
1.3 SimpleDateFormat类(应用)
(1)SimpleDateFormat类概述:
SimpleDateFormat是一个具体的类,用于以区域设置敏感的方式格式化和解析日期。
(2) SimpleDateFormat类构造方法:
public SimpleDateFormat()
构造一个SimpleDateFormat,使用默认模式和日期格式 public SimpleDateFormat(String pattern)
构造一个SimpleDateFormat使用给定的模式和默认的日期 格式
(3)SimpleDateFormat类的常用方法:
格式化(从Date到String) public final String format(Date date):将日期格式化成日期/时间字符串
解析(从String到Date) public Date parse(String source):从给定字符串的开始解析文本以生成日期
(4)代码示例:
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
//格式化:从 Date 到 String Date d = new Date();
// SimpleDateFormat sdf = new SimpleDateFormat();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);
System.out.println("‐‐‐‐‐‐‐‐");
//从 String 到 Date String ss = "2048‐08‐09 11:11:11";
//ParseException SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy‐MM‐dd HH:mm:ss");
Date dd = sdf2.parse(ss);
System.out.println(dd);
}
}
1.4 时间日期类练习 (应用)
(1)需求:
秒杀开始时间是2020年11月11日 00:00:00,结束时间是2020年11月11日 00:10:00,用户小贾下单时间是2020 年11月11日 00:03:47,用户小皮下单时间是2020年11月11日 00:10:11,判断用户有没有成功参与秒杀活动
(2)实现步骤:
1>. 判断下单时间是否在开始到结束的范围内
2>. 把字符串形式的时间变成毫秒值
(3)代码实现:
public class DateDemo5 {
public static void main(String[] args) throws ParseException {
//开始时间:2020年11月11日 0:0:0 //结束时间:2020年11月11日 0:10:0
//小贾2020年11月11日 0:03:47
//小皮2020年11月11日 0:10:11
//1.判断两位同学的下单时间是否在范围之内就可以了。
//2.要把每一个时间都换算成毫秒值。
String start = "2020年11月11日 0:0:0";
String end = "2020年11月11日 0:10:0";
String jia = "2020年11月11日 0:03:47";
String pi = "2020年11月11日 0:10:11";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
long startTime = sdf.parse(start).getTime();
long endTime = sdf.parse(end).getTime();
// System.out.println(startTime);
// System.out.println(endTime);
long jiaTime = sdf.parse(jia).getTime();
long piTime = sdf.parse(pi).getTime();
if(jiaTime >= startTime && jiaTime <= endTime){
System.out.println("小贾同学参加上了秒杀活动");
}else{
System.out.println("小贾同学没有参加上秒杀活动");
}
System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
if(piTime >= startTime && piTime <= endTime){
System.out.println("小皮同学参加上了秒杀活动");
}else{
System.out.println("小皮同学没有参加上秒杀活动");
}
}
}
2.包装类
2.1 基本类型包装类(记忆)
(1) 基本类型包装类的作用:
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据 (2)常用的操作之一:
用于基本数据类型与字符串之间的转换
(3)基本类型对应的包装类:
基本数据类型 | 包装类 |
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Char |
boolean | Boolean |
2.2 Integer类(应用)
(1)Integer类概述:
包装一个对象中的原始类型 int 的值
(2)Integer类构造方法:
方法名 | 说明 |
public Integer(int value) | 根据 int 值创建 Integer 对象(过时) |
public Integer(String s) | 根据 String 值创建 Integer 对象(过时) |
public static Integer valueOf(int i) | 返回表示指定的 int 值的 Integer 实例 |
public static Integer valueOf(String s) | 返回一个保存指定值的 Integer 对象 String |
(3)代码示例:
public class IntegerDemo {
public static void main(String[] args) {
//public Integer(int value):根据 int 值创建 Integer 对象(过时)
Integer i1 = new Integer(100);
System.out.println(i1);
//public Integer(String s):根据 String 值创建 Integer 对象(过时)
Integer i2 = new Integer("100");
// Integer i2 = new Integer("abc"); //NumberFormatException
System.out.println(i2);
System.out.println("‐‐‐‐‐‐‐‐");
//public static Integer valueOf(int i):返回表示指定的 int 值的 Integer 实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);
//public static Integer valueOf(String s):返回一个保存指定值的Integer对象 String
Integer i4 = Integer.valueOf("100");
System.out.println(i4);
}
}
2.3 自动拆箱和自动装箱(理解)
(1)自动装箱 :
把基本数据类型转换为对应的包装类类型
(2)自动拆箱 :
把包装类类型转换为对应的基本数据类型
(3)示例代码:
Integer i = 100; // 自动装箱
i += 200; // i = i + 200; i + 200 自动拆箱;i = i + 200; 是自动装箱
2.4 int和String类型的相互转换(记忆)
(1)int转换为String
1>转换方式:
方式一:直接在数字后加一个空字符串
方式二:通过String类静态方法valueOf()
2>代码示例:
public class IntegerDemo {
public static void main(String[] args) {
//int ‐‐‐ String
int number = 100;
//方式1
String s1 = number + "";
System.out.println(s1);
//方式2
//public static String valueOf(int i)
String s2 = String.valueOf(number);
System.out.println(s2);
System.out.println("‐‐‐‐‐‐‐‐");
}
}
(2) String转换为int
1>转换方式 :
方式一:先将字符串数字转成Integer,再调用valueOf()方法
方式二:通过Integer静态方法parseInt()进行转换
2>代码示例:
public class IntegerDemo {
public static void main(String[] args) {
//String ‐‐‐ int
String s = "100";
//方式1:String ‐‐‐ Integer ‐‐‐ int
Integer i = Integer.valueOf(s);
//public int intValue()
int x = i.intValue();
System.out.println(x);
//方式2
//public static int parseInt(String s)
int y = Integer.parseInt(s);
System.out.println(y);
}
}
2.5 字符串数据排序案例(应用)
(1)案例需求 :
有一个字符串:“91 27 46 38 50”,请写程序实现最终输出结果是:27 38 46 50 91
(2)代码示例:
public class IntegerTest {
public static void main(String[] args) {
//定义一个字符串
String s = "91 27 46 38 50";
//把字符串中的数字数据存储到一个int类型的数组中
String[] strArray = s.split(" ");
// for(int i=0; i<strArray.length; i++) {
// System.out.println(strArray[i]);
// }
//定义一个int数组,把 String[] 数组中的每一个元素存储到 int 数组中
int[] arr = new int[strArray.length];
for(int i=0; i<arr.length; i++) {
arr[i] = Integer.parseInt(strArray[i]);
}
//对 int 数组进行排序
Arrays.sort(arr);
for(int i=0; i<arr.length; i++){
System.out.print(arr[i] + " ");
}
}
3.异常类
3.1 异常(记忆)
(1) 异常的概述:
异常就是程序出现了不正常的情况
(2)异常的体系结构
3.2 编译时异常和运行时异常的区别(记忆)
(1)编译时异常:
都是Exception类及其子类 必须显示处理,否则程序就会发生错误,无法通过编译
(2)运行时异常
都是RuntimeException类及其子类 无需显示处理,也可以和编译时异常一样处理
(3)图示:
3.3 JVM默认处理异常的方式(理解)
如果程序出现了问题,我们没有做任何处理,最终JVM 会做默认的处理,处理方式有
如下两个步骤:
把异常的名称,错误原因及异常出现的位置等信息输出在了控制台
程序停止执行
3.4 查看异常信息 (理解)
控制台在打印异常信息时,会打印异常类名,异常出现的原因,异常出现的位置 我们调
bug时,可以根据提示,找到异常出现的位置,分析原因,修改异常代码
3.5 throws方式处理异常(应用)
(1)定义格式:
public void 方法() throws 异常类名 {
}
(2)示例代码 :
public class ExceptionDemo {
public static void main(String[] args) throws ParseException{
System.out.println("开始");
// method();
method2();
System.out.println("结束");
}
//编译时异常
public static void method2() throws ParseException {
String s = "2048‐08‐09";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy‐MM‐dd");
Date d = sdf.parse(s);
System.out.println(d);
}
//运行时异常
public static void method() throws ArrayIndexOutOfBoundsException {
int[] arr = {1, 2, 3};
System.out.println(arr[3]);
}
}
(3)注意事项
1>这个throws格式是跟在方法的括号后面的
2>编译时异常必须要进行处理,两种处理方案:try...catch …或者 throws,如果采用 throws 这种方案, 在方法上进行显示声明,将来谁调用这个方法谁处理
3>运行时异常因为在运行时才会发生,所以在方法后面可以不写,运行时出现异常默认交给jvm处理
3.6 throw抛出异常 (应用)
(1) 格式:
throw new 异常();
(2)注意:
这个格式是在方法内的,表示当前代码手动抛出一个异常,下面的代码不用再执行了
(3)throws和throw的区别 :
throws | throw |
用在方法声明后面,跟的是异常类名 | 用在方法体内,跟的是异常对象名 |
表示声明异常,调用该方法有可能会出现这样的异 常 | 表示手动抛出异常对象,由方法体内的语句处 理 |
(4)代码示例:
public class ExceptionDemo8 {
public static void main(String[] args) {
//int [] arr = {1,2,3,4,5};
int [] arr = null;
printArr(arr);
//就会 接收到一个异常.
//我们还需要自己处理一下异常.
}
private static void printArr(int[] arr) {
if(arr == null){
//调用者知道成功打印了吗?
//System.out.println("参数不能为null");
throw new NullPointerException();
//当参数为null的时候
//手动创建了一个异常对象,抛给了调用者,产生了一个异常
}else{
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
}
3.7 try-catch方式处理异常(应用)
(1)定义格式:
try {
可能出现异常的代码;
} catch(异常类名 变量名) {
异常的处理代码;
}
(2)执行流程
1>程序从 try 里面的代码开始执行
2>出现异常,就会跳转到对应的 catch 里面去执行
3> 执行完毕之后,程序还可以继续往下执行
(3)代码示例:
public class ExceptionDemo01 {
public static void main(String[] args) {
System.out.println("开始");
method();
System.out.println("结束");
}
public static void method() {
try {
int[] arr = {1, 2, 3};
System.out.println(arr[3]);
System.out.println("这里能够访问到吗");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("你访问的数组索引不存在,请回去修改为正确的索引");
}
}
}
(4)注意:
1. 如果 try 中没有遇到问题,怎么执行? 会把try中所有的代码全部执行完毕,不会执行catch里面的代码
2. 如果 try 中遇到了问题,那么 try 下面的代码还会执行吗? 那么直接跳转到对应的catch语句中,try下面的代码就不会再执行了 当catch里面的语句全部执行完毕,表 示整个体系全部执行完全,继续执行下面的代码
3. 如果出现的问题没有被捕获,那么程序如何运行? 那么try...catch就相当于没有写.那么也就是自己没有处理. 默认交给虚拟机处理.
4. 同时有可能出现多个异常怎么处理? 出现多个异常,那么就写多个catch就可以了. 注意点:如果多个异常之间存在子父类关系.那么父类一定要 写在下面
3.8 Throwable成员方法(应用)
(1)常用方法:
方法名 | 说明 |
public String getMessage() | 返回此 throwable 的详细消息字符串 |
public String toString() | 返回此可抛出的简短描述 |
public void printStackTrace() | 把异常的错误信息输出在控制台 |
(2)代码示例:
public class ExceptionDemo02 {
public static void main(String[] args) {
System.out.println("开始");
method();
System.out.println("结束");
}
public static void method() {
try { int[] arr = {1, 2, 3};
System.out.println(arr[3]);
//new ArrayIndexOutOfBoundsException();
System.out.println("这里能够访问到吗");
} catch (ArrayIndexOutOfBoundsException e) {
//new ArrayIndexOutOfBoundsException();
// e.printStackTrace();
//public String getMessage():返回此 throwable 的详细消息字符串
// System.out.println(e.getMessage());
//Index 3 out of bounds for length 3
//public String toString():返回此可抛出的简短描述
// System.out.println(e.toString());
//java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
//public void printStackTrace():把异常的错误信息输出在控制台 e.printStackTrace();
// java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
// at com.itheima_02.ExceptionDemo02.method(ExceptionDemo02.java:18)
// at com.itheima_02.ExceptionDemo02.main(ExceptionDemo02.java:11)
}
}
}
3.9 异常的练习 (应用)
(1) 需求 :
键盘录入学生的姓名和年龄,其中年龄为18 - 25岁,超出这个范围是异常数据不能赋值.
需要重新录入,一直录到 正确为止
(2)实现步骤
1> 创建学生对象
2> 键盘录入姓名和年龄,并赋值给学生对象
3> 如果是非法数据就再次录入
(3)代码示例:
学生类
public class Student {
private String name;
private int age;
public Student() { }
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age >= 18 && age <= 25){
this.age = age;
}else{
//当年龄不合法时,产生一个异常
throw new RuntimeException("年龄超出了范围");
}
}
@Override
public String toString() {
return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}
测试类
public class ExceptionDemo12 {
public static void main(String[] args) {
// 键盘录入学生的姓名和年龄,其中年龄为 18 ‐ 25岁,
// 超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止。
Student s = new Student();
Scanner sc = new Scanner(System.in);
System.out.println("请输入姓名");
String name = sc.nextLine();
s.setName(name);
while(true){
System.out.println("请输入年龄");
String ageStr = sc.nextLine();
try {
int age = Integer.parseInt(ageStr);
s.setAge(age);
break;
} catch (NumberFormatException e) {
System.out.println("请输入一个整数");
continue;
} catch (AgeOutOfBoundsException e) {
System.out.println(e.toString());
System.out.println("请输入一个符合范围的年龄");
continue;
}
/*if(age >= 18 && age <=25){
s.setAge(age);
break;
}else{
System.out.println("请输入符合要求的年龄");
continue;
}*/
}
System.out.println(s);
}
}
3.10 自定义异常(应用)
(1)自定义异常概述:
当Java中提供的异常不能满足我们的需求时,我们可以自定义异常
(2)实现步骤
1>定义异常类
2>写继承关系
3>提供空参构造
4>提供带参构造 代码实现
异常类
public class AgeOutOfBoundsException extends RuntimeException {
public AgeOutOfBoundsException() {
}
public AgeOutOfBoundsException(String message) {
super(message);
}
}
学生类
public class Student {
private String name;
private int age;
public Student() { }
public Student(String name, int age) {
this.name = name; this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age >= 18 && age <= 25){
this.age = age;
}else{
//如果Java中提供的异常不能满足我们的需求,我们可以使用自定义的异常
throw new AgeOutOfBoundsException("年龄超出了范围");
}
}
@Override
public String toString() {
return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}
测试类
public class ExceptionDemo12 {
public static void main(String[] args) {
// 键盘录入学生的姓名和年龄,其中年龄为 18 ‐ 25岁,
// 超出这个范围是异常数据不能赋值.需要重新录入,一直录到正确为止。
Student s = new Student();
Scanner sc = new Scanner(System.in);
System.out.println("请输入姓名");
String name = sc.nextLine();
s.setName(name);
while(true){
System.out.println("请输入年龄");
String ageStr = sc.nextLine();
try {
int age = Integer.parseInt(ageStr);
s.setAge(age);
break;
} catch (NumberFormatException e) {
System.out.println("请输入一个整数");
continue;
} catch (AgeOutOfBoundsException e) {
System.out.println(e.toString());
System.out.println("请输入一个符合范围的年龄");
continue;
}
/*if(age >= 18 && age <=25){
s.setAge(age);
break;
}else{
System.out.println("请输入符合要求的年龄");
continue;
}*/
}
System.out.println(s);
}
}