day04常用API和异常

最新推荐文章于 2024-04-27 17:30:34 发布

Jenius87V5

最新推荐文章于 2024-04-27 17:30:34 发布

阅读量444

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/Jenius87v5/article/details/124237899

版权

Java基础专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1.包装类

1.1基本类型包装类（记忆）

基本类型包装类的作用

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一：用于基本数据类型与字符串之间的转换
基本类型对应的包装类

基本数据类型包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

1.2Integer类（应用）

Integer类概述

包装一个对象中的原始类型 int 的值

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

示例代码

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);
    }
}

1.3int和String类型的相互转换（记忆）

int转换为String

转换方式
- 方式一：直接在数字后加一个空字符串
- 方式二：通过String类静态方法valueOf()

示例代码

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("--------");
    }
}

String转换为int

转换方式
- 方式一：先将字符串数字转成Integer，再调用valueOf()方法
- 方式二：通过Integer静态方法parseInt()进行转换

示例代码

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);
    }
}

1.4字符串数据排序案例（应用）

案例需求

有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：“27 38 46 50 91”

代码实现

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);

        //把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
        StringBuilder sb = new StringBuilder();
        for(int i=0; i<arr.length; i++) {
            if(i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();

        //输出结果
        System.out.println(result);
    }
}

1.5自动拆箱和自动装箱（理解）

自动装箱

把基本数据类型转换为对应的包装类类型
自动拆箱

把包装类类型转换为对应的基本数据类型

示例代码

Integer i = 100;  // 自动装箱
i += 200;         // i = i + 200;  i + 200 自动拆箱；i = i + 200; 是自动装箱

2.时间日期类

2.1Date类（应用）

Date类概述

Date 代表了一个特定的时间，精确到毫秒

Date类构造方法

方法名	说明
public Date()	分配一个 Date对象，并初始化，以便它代表它被分配的时间，精确到毫秒
public Date(long date)	分配一个 Date对象，并将其初始化为表示从标准基准时间起指定的毫秒数

示例代码

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);
    }
}

2.2Date类常用方法（应用）

常用方法

方法名说明
public long getTime() 获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time) 设置时间，给的是毫秒值

方法名	说明
public long getTime()	获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time)	设置时间，给的是毫秒值

示例代码

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);
    }
}

2.3SimpleDateFormat类（应用）

SimpleDateFormat类概述

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。

我们重点学习日期格式化和解析

SimpleDateFormat类构造方法

方法名	说明
public SimpleDateFormat()	构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern)	构造一个SimpleDateFormat使用给定的模式和默认的日期格式

SimpleDateFormat类的常用方法
- 格式化(从Date到String)
  - public final String format(Date date)：将日期格式化成日期/时间字符串
- 解析(从String到Date)
  - public Date parse(String source)：从给定字符串的开始解析文本以生成日期

示例代码

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);
    }
}

2.4日期工具类案例（应用）

案例需求

定义一个日期工具类(DateUtils)，包含两个方法：把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，然后定义一个测试类(DateDemo)，测试日期工具类的方法

代码实现

工具类

public class DateUtils {
    private DateUtils() {}

    /*
        把日期转为指定格式的字符串
        返回值类型：String
        参数：Date date, String format
     */
    public static String dateToString(Date date, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }


    /*
        把字符串解析为指定格式的日期
        返回值类型：Date
        参数：String s, String format
     */
    public static Date stringToDate(String s, String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(s);
        return d;
    }

}

测试类

public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d = new Date();

        String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        String s2 = DateUtils.dateToString(d, "yyyy年MM月dd日");
        System.out.println(s2);

        String s3 = DateUtils.dateToString(d, "HH:mm:ss");
        System.out.println(s3);
        System.out.println("--------");

        String s = "2048-08-09 12:12:12";
        Date dd = DateUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);
    }
}

2.5Calendar类（应用）

Calendar类概述

Calendar 为特定瞬间与一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

Calendar 提供了一个类方法 getInstance 用于获取这种类型的一般有用的对象。

该方法返回一个Calendar 对象。

其日历字段已使用当前日期和时间初始化：Calendar rightNow = Calendar.getInstance();

Calendar类常用方法

方法名	说明
public int get(int field)	返回给定日历字段的值
public abstract void add(int field, int amount)	根据日历的规则，将指定的时间量添加或减去给定的日历字段
public final void set(int year,int month,int date)	设置当前日历的年月日

示例代码

public class CalendarDemo {
    public static void main(String[] args) {
        //获取日历类对象
        Calendar c = Calendar.getInstance();

        //public int get(int field):返回给定日历字段的值
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

        //public abstract void add(int field, int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
        //需求1:3年前的今天
//        c.add(Calendar.YEAR,-3);
//        year = c.get(Calendar.YEAR);
//        month = c.get(Calendar.MONTH) + 1;
//        date = c.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");

        //需求2:10年后的10天前
//        c.add(Calendar.YEAR,10);
//        c.add(Calendar.DATE,-10);
//        year = c.get(Calendar.YEAR);
//        month = c.get(Calendar.MONTH) + 1;
//        date = c.get(Calendar.DATE);
//        System.out.println(year + "年" + month + "月" + date + "日");

        //public final void set(int year,int month,int date):设置当前日历的年月日
        c.set(2050,10,10);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH) + 1;
        date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

    }
}

2.6二月天案例（应用）

案例需求

获取任意一年的二月有多少天

代码实现

public class CalendarTest {
    public static void main(String[] args) {
        //键盘录入任意的年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年：");
        int year = sc.nextInt();

        //设置日历对象的年、月、日
        Calendar c = Calendar.getInstance();
        c.set(year, 2, 1);

        //3月1日往前推一天，就是2月的最后一天
        c.add(Calendar.DATE, -1);

        //获取这一天输出即可
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年的2月份有" + date + "天");
    }
}

3.异常

3.1异常（记忆）

异常的概述

异常就是程序出现了不正常的情况
异常的体系结构

3.2JVM默认处理异常的方式（理解）

如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理，处理方式有如下两个步骤：
把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
程序停止执行

3.3try-catch方式处理异常（应用）

定义格式

try {
	可能出现异常的代码;
} catch(异常类名 变量名) {
	异常的处理代码;
}

执行流程
- 程序从 try 里面的代码开始执行
- 出现异常，就会跳转到对应的 catch 里面去执行
- 执行完毕之后，程序还可以继续往下执行

示例代码

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("你访问的数组索引不存在，请回去修改为正确的索引");
            e.printStackTrace();
        }
    }
}

3.4Throwable成员方法（应用）

常用方法

方法名	说明
public String getMessage()	返回此 throwable 的详细消息字符串
public String toString()	返回此可抛出的简短描述
public void printStackTrace()	把异常的错误信息输出在控制台

示例代码

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.5编译时异常和运行时异常的区别（记忆）

编译时异常
- 都是Exception类及其子类
- 必须显示处理，否则程序就会发生错误，无法通过编译
运行时异常
- 都是RuntimeException类及其子类
- 无需显示处理，也可以和编译时异常一样处理

3.6throws方式处理异常（应用）

定义格式

public void 方法() throws 异常类名 {
    
}

示例代码

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("开始");
//        method();
        try {
            method2();
        }catch (ParseException e) {
            e.printStackTrace();
        }
        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]);
    }
}

注意事项
- 这个throws格式是跟在方法的括号后面的
- 编译时异常必须要进行处理，两种处理方案：try…catch …或者 throws，如果采用 throws 这种方案，将来谁调用谁处理
- 运行时异常可以不处理，出现问题后，需要我们回来修改代码

3.7throws和throw的区别（记忆）

在这里插入图片描述

3.8自定义异常（应用）

自定义异常类

public class ScoreException extends Exception {

    public ScoreException() {}

    public ScoreException(String message) {
        super(message);
    }

}

老师类

public class Teacher {
    public void checkScore(int score) throws ScoreException {
        if(score<0 || score>100) {
//            throw new ScoreException();
            throw new ScoreException("你给的分数有误，分数应该在0-100之间");
        } else {
            System.out.println("成绩正常");
        }
    }
}

测试类

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入分数：");

        int score = sc.nextInt();

        Teacher t = new Teacher();
        try {
            t.checkScore(score);
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }
}

一、包装类
1.什么是包装类？
这里的包装指的是包装基本数据类型
*将基本数据类型包装成引用数据类型（类）

2.包装类和基本数据类型之间的对应关系
	byte  ----------------  Byte
	short  ---------------  Short
	int  -----------------  Integer  //注意
	long  ----------------  Long
	float ----------------  Float
	double  --------------  Double
	char  ----------------  Character  //注意
	boolean  -------------  Boolean
	
3.为什么要使用包装类？
	两个好处：
		（1）可以在包装类中封装一些我们不容易记忆的属性
		（2）为了给集合做铺垫的   ArrayList<Integer>

二、Integer类
1.java.lang.Object
java.lang.Number
java.lang.Integer
//lang包下的类使用时是不需要导包的

2.成员变量  //了解
	*static int MAX_VALUE 保持最大值一个 int可以有2 31 -1。  
	*static int MIN_VALUE 持有最小值的常数为 int可以为-2 31 。  

3.构造方法  //不用管
	Integer i1 = 100;
	
4.相关方法
	*int ---------- > String
		(1) String s1 = 100+"";   //以后开发中很常用    ☆☆☆☆☆
		(2)String s2 = String.valueOf(100);
	
	*String ---------->  int 
		(1)static int parseInt(String s) 将字符串参数解析为带符号的十进制整数。    // ☆☆☆☆☆
			举例：
				String s1 = "1256";
				int i = Integer.parseInt(s1);
			//注意事项：你需要转的字符串必须是纯数字型的，字符串中不能出现除了数字以外的字符

基本类型->字符串(String)：

1.基本类型的值+""  最简单的方法(工作中常用)

2.包装类的静态方法toString(参数), static String toString(int i) 返回一个表示指定整数的 String 对象。

3.String类的静态方法valueOf(参数),static String valueOf(int i) 返回 int 参数的字符串表示形式。

字符串(String)->基本类型:  

Inteiger类: static int parseInt(String s),注意使用该方法的字符串必须是一个只包含数字字符的字符串。


下列代码能正确运行的是（ ）

	A.

	 int number = Integer.parseInt("123a");
	 System.out.println(number);
	B.

	int number = Integer.parseInt("123");
	System.out.println(number);
	C.

	float number = Float.parseFloat("3.14F");
	System.out.println(number);
	D.

	float number = Float.parseFloat("3.14");
	System.out.println(number);
	E.

	long i1 = Long.parseLong("100L");
	System.out.println(i1);
	
	正确答案：B,C,D
	答案解析： 
	本题考核的知识点是字符串转换成为对应的基本数据类型。

	Integer.parseInt("123a")

	其中的参数中只能有数字不能有字母.否则会抛出NumberFormatException

	Float.parseFloat("3.14")参数中在最后加上F不加F都能解析出来

	Long.parseLong("100L");比较特殊.如果加上L之后,会抛出NumberFormatException.

三、字符串中的数字排序
“21 34 24 67”
*需要将字符串中的每一个数字分离出来：String[] split(String regex) 将此字符串拆分为给定的 regular expression的匹配。
String s = “21 34 24 67”;
String[] strs = s.split(" "); //[“21”,“34”,“24”,“67”]
*需要将String数组转成int类型的数组：循环遍历字符串数组，得到每一个字符串，然后将字符串转成int
int[] ints = new int[strs.length];
for(int i =0;i<strs.leng;i++){
ints[i]=Integer.parseInt(strs[i]);
}

	*将int类型的数组进行排序
		Arrays.sort(ints);
	
	*使用StringBuilder进行拼接

四、自动拆箱和自动装箱
1.概念
自动：就是不需要我们自己去做
装箱：指的是把基本数据类型转换成对应的包装类类型
拆箱：指的是把包装类类型转换成对应的基本数据类型

2.自动装箱
	Integer i1 = 100;  //这里其实触发了自动装箱，就是把100这个基本数据类型的数据封装成了对应包装类Integer类型，就可以赋值给i1了。
	
3.自动拆箱
	Integer i2 = 200;
	Integer i3 = i1 + i2; //两个对象能进行相加吗？
							//不能，首先触发自动拆箱，将i1从Integer类型转成int类型的100，将i2从Integer类型转成int类型的200，得到int类型的300结果
									//再次触发自动装箱，将int类型的300再转成Integer类型的300，就可以复制给i3了
4.注意事项:
	自动装箱是把基本数据类型自动转换成对应的包装类类型

	自动拆箱是把包装类类型自动转换成对应的基本数据类型

	可以实现把基本数据类型的数据直接赋值给对应的引用数据类型变量

	但不能实现类型的自动转换，即Double d = 1;这样写是不正确的
	
	

2.	(1)Float.parseFloat("3.14")参数中在最后加上F不加F都能解析出来 Long.parseLong("100L");比较特殊.如果加上L之后,会抛出NumberFormatException. 
		这是为什么??? 
				//注意字符L （ '\u004C' ）和L （ '\u004C' ）以及l （ '\u006C' ）都不允许作为类型指示符出现在字符串的末尾

Date类 //掌握
一、Date类的概述
1.java.lang.Object
java.util.Date
//在util（不要选成sql包下）包下，所以使用的时候需要导包

	2.构造方法
		（1）Date() 分配一个 Date对象并对其进行初始化，以便它表示分配的时间，以最接近的毫秒为单位。 //以当前的时间为准来创建对象  
			代码实现：
				 Date d2 = new Date();
				System.out.println(d2);
					//Fri Feb 07 09:21:00 CST 2020
			
		（2）Date(long date) 分配一个 Date对象，并将其初始化为表示从标准基准时间（称为“时代”）即1970年1月1日00:00:00 GMT起的指定毫秒数。//是以传入的指定的毫秒值为准来创建对象  
				Date d1 = new Date(1000L*60*60);
				System.out.println(d1);
					//Thu Jan 01 09:00:00 CST 1970
	
	3.Date类的常用方法
			//  Date------------>long
		（1）long getTime() 返回自1970年1月1日以来，由 Date对象表示的00:00:00 GMT的毫秒数。 
			//左边返回值：long类型的毫秒值   中：获取"时间点"距离1970-01-01的毫秒值   右：参数列表为空
				代码实现： 
					 long time = d1.getTime();
					System.out.println(time);
						//3600000
		
			//long-------->Date
		（2）void setTime(long time) 将此 Date对象设置为1970年1月1日00:00:00 GMT后的 time毫秒的时间点。  
				//左边返回值：空   中：设置1970-01-01加上毫秒值后，得到的"时间点"   右：long类型的毫秒值
					代码实现： 
						d2.setTime(1000L);
						System.out.println(d2);
							//Thu Jan 01 08:00:01 CST 1970
	
	4.日期的格式化
		（1）为什么会出现日期格式化？
			因为Date类默认的日期格式不符合咱们中国人看日期的习惯，为了能按照我们的习惯去展示日期，就出现了日期格式化
	
		（2）构造方法
			    SimpleDateFormat()               根据默认模板格式创建日期格式化对象  //忘记吧，基本不用
				SimpleDateFormat(String m) 根据指定模板格式创建日期格式化对象   //掌握
		（3）常用的日期格式
			"yyyy年MM月dd日 HH:mm:ss"
			
		(4)常用方法
			*将日期对象格式化成字符串
				String format(Date d)   将日期对象格式化成字符串
					代码实现：	
						 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
						Date d1 = new Date();
						String time = sdf.format(d1);
						System.out.println(time);
							//2020-02-07 10:02:07
							
				//应用场景：将日期转成指定的格式到前端页面展示
						
			*将字符串日期解析成Date对象
				Date parse(String s)       将字符串日期解析成Date对象
					代码实现： 
						  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
						String time = "2020-02-06 14:00:00";
						Date date = sdf.parse(time);
						System.out.println(date);
							//Thu Feb 06 14:00:00 CST 2020

				//应用场景：用于时间计算差
					比如：计算"2020-02-06 14:00:00"和"2020-02-06 16:47:00"之间的的分钟数
						代码实现 ：
							SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
							String start = "2020-02-06 14:00:00";
							String end = "2020-02-06 16:47:00";

							//需要先将时间字符串转成Date，然后再调用Date类getTime方法
							Date st1 = sdf.parse(start);
							Date end1 = sdf.parse(end);

							long time1 = st1.getTime();
							long end1Time = end1.getTime();
							System.out.println((end1Time-time1)/1000/60);
	
					//中午小作业：计算一下，当前时间距离五一放假还有多长时间？
					public class DateDemo02 {
						public static void main(String[] args) throws ParseException {
							String end = "2020-05-01 00:00:00";
							String start = "2020-02-07 00:00:00";
							SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
							Date date1 = sdf.parse(end);
							Date date2 = sdf.parse(start);
							long time1 = date1.getTime();
							long time2 = date2.getTime();
							System.out.println((time1-time2)*1.0/1000/60/60/24);


						}
					}
	
	5.时间工具类小练习
		（1）工具类
				*工具类所在的包：必须以util或者utils结尾
				*工具类名本身也必须以util或者utils结尾
				*构造方法私有
				*所有的方法必须使用static来修饰
				
		（2）方法：Date---->String 
				*创建SimpleDateFormate对象：需要一个时间格式的参数
				*调用它的format方法：需要提供一个Date类型的对象
		（3）方法：String------->Date
				*创建SimpleDateFormate对象：需要一个时间格式的参数
				*调用它的parse方法：需要提供一个字符串类型的时间对象
	
			代码实现：
				public class DateUtils {
					//构造方法私有
					private DateUtils(){}

					/*
						是将Date类型转成String'类型的方法
					 */
					public static String dateToString(String pattern, Date date){
						SimpleDateFormat sdf = new SimpleDateFormat(pattern);
						String time = sdf.format(date);
						return time;
					}

					 /*
						是将String类型转成Date类型的方法
					 */
					public static Date stringToDate(String pattern,String time) throws ParseException {
						SimpleDateFormat sdf = new SimpleDateFormat(pattern);
						Date date = sdf.parse(time);
						return date;
					}
				}

				class Test1{
					public static void main(String[] args) throws ParseException {
						String pattern = "yyyy-MM-dd HH:mm:ss";
						Date d1 = new Date();
						String time = DateUtils.dateToString(pattern, d1);
						System.out.println(time);

						//-----------------------------------------------------

						String time1 = "2020-05-01 10:20:30";
						Date date = DateUtils.stringToDate(pattern, time1);
						System.out.println(date);

					}
				}

Calendar类 //了解
一、Calendar的概述
1.public abstract class Calendar
//Calendar类是一个抽象类，所以不能直接创建对象

	2.Calendar这个类是用来描述什么的？
		用来描述生活中的日历
		
	3.创建对象的方式
		static Calendar getInstance() 使用默认时区和区域设置获取日历。 
			//为什么Calendar类创建对象时不用new，而是调用getInstance方法？
				因为Calendar这个类它可以表示各个国家的时间对象，比如日本时间、格里尼治时间。。。  ，而不同的国家的日历对象创建方式是不一样的，
					所以系统为了给我们减少工作量，就把对当前系统的判断是哪个国家包含在了getInstance方法里面。
	
	4.比较Date、SimpleDateforamt、Calendar三个类之间的区别？
		*Date类： 
			表示的是 星期、年月日时分秒  //简单
		*SimpleDateformat类
			是用来格式化日期的
		*Calendar类
			表示的和日期相关的信息比较丰富   //全面
			
			//总结：以后我们基本上使用 Date + SimpleDateforamt
	
二、常用方法
	1.获取日历字段方法： int get(int filed)
			左：返回值为int类型的  中：获取方法   右：参数field不能乱写，要使用Calendar中的属性
				代码实现： 
					Calendar instance = Calendar.getInstance();
					int year = instance.get(Calendar.YEAR);
					System.out.println(year);
						//2020
					
				
	2.修改日历字段方法：void add(int filed,int count)  //偏移方法
		//参数：第一个参数field不能乱写，第二个参数是偏移量，  如果是正数，表示加  如果是负数，表示减
			代码实现： 
				Calendar instance = Calendar.getInstance();

				instance.add(Calendar.YEAR,-1);
				int year = instance.get(Calendar.YEAR);
				System.out.println(year);
		
	3.设置日历字段方法：void set(int year,int month,int date)
		参数：设置的是年月日
			代码实现： 
				instance.set(2019,10,26);
				int date = instance.get(Calendar.DATE);
				System.out.println(date);
	
	
	4.二月天案例	
		*设置时间为  xxxx-03-01   （使用calendar的set方法）
		*将3.1往前推一天，就是二月份的最后一天   （使用calendar的add方法） 
		*获取二月份最后一天的日期即可   （使用了calendar类的get方法）

异常
一、异常的体系结构
public class Throwable ：它是所有异常的根类

	1.分类
		（1）错误：以Error结尾
			//常见的代码中的错误有两种
				*内存溢出错误
					代码举例：
						public class Demo1 {
							public static void main(String[] args) {
								ArrayList<String>  arr = new ArrayList<>();

								while (true){   //死循环会导致内存溢出错误
									arr.add("遇见你是一个美丽的错误");
								}
							}
						}
						//Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
		
				*栈内存溢出错误
					代码举例：
						public class Demo2 {
								public static void main(String[] args) {
									show();
								}

								public static void show(){
									show();    //自己调用自己死循环
								}
							}
						//Exception in thread "main" java.lang.StackOverflowError
				
		
		（2）异常：以Exception结尾
			*运行期异常
			*编译期异常
	
	
	2.JVM默认处理异常的方式
		（1）把异常的名称、原因、位置等信息输出在控制台  //好处
				代码举例：
					public class Demo3 {
							public static void main(String[] args) {
								System.out.println("main方法开始执行了");
								int[] ints = {12,45,78};
								int i = ints[6];

								System.out.println("main方法执行结束了");
							}
						}
			//	   异常	  在  线程   线程的名称          异常类名                   出异常的数据
		执行结果：	Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 6
			//      在  包名  类名  方法名        第7行
					at demo3.Demo3.main(Demo3.java:7)
			
		（2）结束程序的运行
				//不好

	3.异常的第一种处理方式
		（1）格式
			try…catch处理方式标准格式
			  try{
				  xxxxxx   //就是可能出现异常的代码
			  }catch(异常类型 对象名) {
				  处理方式
			  }
			  
			 *第一种执行代码举例：
				public class Demo3 {
						public static void main(String[] args) {
							try {
								System.out.println("main方法开始执行了");
								int[] ints = {12,45,78};
								int i = ints[6];

								System.out.println("main方法执行结束了");
							} catch (Exception e) {
								System.out.println("出异常了");
							}
						}
					}
			//运行结果
				main方法开始执行了
				出异常了
		//结论一：如果在try大括号中有一行代码出现异常了，然后会进入到对应的catch大括号中执行，在catch大括号执行结束之后，不会在回到try大括号中继续执行
				//所以，我们在以后写代码的时候，在try的大括号里一定要尽量少写代码，越少越好
			*第二种执行代码举例
				public class Demo3 {
					public static void main(String[] args) {
						try {
							System.out.println("main方法开始执行了");
							int[] ints = {12,45,78};
							int i = ints[6];

						} catch (NullPointerException e) {
							System.out.println("出异常了");
						}

						System.out.println("main方法执行结束了");
					}
				}
	
			//运行结果 
				main方法开始执行了
				Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 6
					at demo3.Demo3.main(Demo3.java:8)
	
		//结论二：如果try大括号中出现的异常，在catch大括号中没有对应的异常，那么就捕捉不了try大括号中的异常，执行JVM默认处理异常的方式
		
		try{
			int a = 1/0;//ArithmeticException
				System.out.println(a);
			}catch (ArrayIndexOutOfBoundsException e){
				System.out.println("异常出现了");
			}finally {
				System.out.println("我会执行吗？");
			}
			System.out.println("程序结束");
		运行结果:
		我会执行吗？
		Exception in thread "main" java.lang.ArithmeticException: / by zero
			at dome01.ThrowableDemo.main(ThrowableDemo.java:8)
		
		//finally语句体无论上面代码是否出现异常，它都会执行，
					
	
	4.Throwable中的成员方法  //了解
		（1）这几个方法都在什么位置使用？
			//都在catch的大括号中使用
			
		（2）成员方法
			*获取异常"简短消息"：String getMessage()  
				//结果举例：  6
				
			*获取异常"详细消息"：String toString()
				//结果举例：java.lang.ArrayIndexOutOfBoundsException: 6
				
			*获取异常"完整消息"：void printStackTrace()    //推荐使用
				//java.lang.ArrayIndexOutOfBoundsException: 6
					//at demo3.Demo3.main(Demo3.java:8)
		
		(3)补充：怎么去写这个 try--catch 
				在idea中
			选中你觉得可能出现问题的代码 -------  快捷键  CTRL  + ALT +  T   ------------  再选中try/catch
			
	5.编译期异常和运行期异常的区别
		（1）编译期异常（Exception）：就是在执行javac这个命令的时候，出现的异常
			*编译：在java中使用javac命令
			*区别：
				第一个区别：是在编译期产生的
				第二个区别：在idea中，如果出现编译期异常，会有红色波浪线提示，不处理就无法运行程序
					//举例：
						 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
						String time = "2020-02-07 15:47:30";
						Date parse = sdf.parse(time); //parse会有红色波浪线提示，说明解析异常是一个编译期异常
		
		（2）运行期异常（RuntimeException）：就是在执行java这个命令的时候，出现的异常
			*运行：在java中使用java命令
			*区别：
				第一个区别：是在运行期产生的
				第二个区别：在idea中，如果出现运行期异常，不会有红色波浪线提示，运行时才会出现该异常
					//举例：
							int[] ints = {12,45,6};
							int i = ints[6];  //这里的6是索引越界异常，但是没有红色波浪线提示，所以这个异常是运行期异常
		
		
	6.异常的第二种处理方式
		（1）格式
			在方法声明上：throws 异常"类名"
				举例：
					public static void main(String[] args) throws ParseException {xxx}
		(2)位置
			位置在方法申明中小括号的后面（或者说在大括号的前面）
			
		（3）原理 
			实际上它并没有处理异常，只是将异常抛给了调用这个方法对象
			
		（4）注意事项 
			*不要在main方法上使用throws抛出异常
				//因为调用main方法的是JVM，JVM就会使用异常的默认处理方式
				
			*throws的后面可以跟多个异常类名，多个类名之间使用逗号分隔
	
	7.扩展：异常的设计理念
		问题：为什么异常要分为编译期异常和运行期异常？
			//编译期异常和运行期异常针对的角色是不一样的
			（1）运行期异常
				针对于"用户"来说的，也就是说运行期异常其实是由用户产生的，因为用户提供了不合法的数据才导致的异常。
				怎么办么？我们只能去给出用户一个友好的提示，不能喷用户。
				
				异常的处理方式使用：try---catch
				
				
			（2）编译期异常	
				针对的是我们"开发人员"，比如说咱们的日期字符串转成Date案例，之所以parse会被红色波浪线提示，那是因为JVM在提醒我们开发人员，这个地方很
				容易出现异常，那么这个时候我们开发人员看到这个提示就知道我们要小心的检查这个匹配是否真的有问题，如果最后真没问题，我们怎么告诉虚拟机我
				检查过了，是ok的。使用throws + 异常类名 真正的作用是告诉虚拟机我已经检查好了，你让我编译通过吧
				
				异常的处理方式使用：
					throws + 异常类名
					try---catch
		
		
	8.自定义异常  //了解
		（1）为什么要使用自定义异常？
			就是为了让开发人员看到这个异常的名字，就能知道大概出现了什么样的错误
			
		（2）步骤
			*定义一个类
				名字的要求：
					一定要见名知意
					必须以Exception结尾
			
			*必须有继承关系
				如果是编译期异常，那么必须继承Exception
				如果是运行期异常，那么必须继承RuntimeException
				
			*提供构造方法
				无参构造
				带参构造
		
		代码实现： 
			public class AgeOutOfBoundsException extends RuntimeException{
					public AgeOutOfBoundsException() {
					}

					public AgeOutOfBoundsException(String message) {
						super(message);
					}
				}

				class Test2{
					public static void main(String[] args) {
						int age = 201;
						if (age<0||age>200){
							throw new AgeOutOfBoundsException(age+"");
						}
					}
				}
		
		（3）throw和throws的区别
			第一点：位置上的区别
				throw用在方法体内
				throws用在方法申明的小括号后面
			
			第二点：后面跟的东西不一样
				throw后面跟的是异常的"对象"
				throws后面跟的是异常的"类名",并且可以跟多个，以逗号分隔就行
				
			第三点：发生异常的可能性不同
				throw 那么异常一定会发生
				throws 可能会发生，也可能不会发生

Jenius87V5

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day04常用API和异常

1.包装类1.1基本类型包装类（记忆）基本类型包装类的作用将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据常用的操作之一：用于基本数据类型与字符串之间的转换基本类型对应的包装类基本数据类型包装类byteByteshortShortintIntegerlongLongfloatFloatdoubleDoublecharCharacterbooleanBoolean1.2
复制链接

扫一扫