JAVA 基础篇（三）----API 异常处理好好看好好学

本文链接：https://blog.youkuaiyun.com/qq_59472803/article/details/121324909

JAVA----API

一、API

1.Scanner的基本使用

API解释：
	全称叫应用程序编程接口(Application Programming Interface), 本意指的是JDK提供的各种类和接口

例如： Scanner获取字符串
	public String nextLine();	获取用户录入的字符串，能获取整行数据。
	public String nextInt();	获取整数类型的数据
	public String next();		获取用户录入的字符串，但是只能获取空格以前的内容

代码演示

//会自动导包
import java.util.Scanner;

/*
    演示Scanner如何获取字符串
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你爱的人的名字: ");

        // 接收键盘输入的结果
        String str = scanner.nextLine();

        // 只能接收空格之前的内容
        //String str = sc.next();
        //打印
        System.out.println(str);
    }
}

2.Scanner的小技巧.

Scanner的细节问题：
	问题描述：
		先用 nextInt() 接收整数，再用 nextLine() 接收字符串，发现字符串无法接收。
	产生原因：
		1. nextInt() 、 nextLine() 两个方法结束标记都是 \r\n
		2. nextInt() 方法只接收用户录入的整数，不接收 \r\n
		3. 它遗留下来的 \r\n 只能被 nextLine() 识别， 导致 nextLine() 方法直接结束。

	解决方案：
		1. 都用字符串接收，然后把字符串形式的整数转化成对应的整数。  ----》【掌握： 这是实际开发做法】
			int num = Integer.parseInt("123");
				
		2. 重新 new 一个Scanner对象。
		3. 重新调用一次 newLine() 方法。
		4. 通过 next() 方法实现。
		5. 尽量先 nextLine(), 然后 nextInt() 也能解决。

基本操作：

package demo01_scanner;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        // ==============[问题代码]==============
    /*
        //创建 Scanner对象
        Scanner sc = new Scanner(System.in);

        // 接收键盘输入的结果
        System.out.println("请输入一个整数: ");
        // 接收输入的整数
        int num = sc.nextInt();
        // 打印
        System.out.println("num " + num);   //520

        //再调用nextLine() 接收字符串
        System.out.println("请输入字符串 ");
        String str = sc.nextLine();
        System.out.println(str);
        //问题描述  ： 数字输完之后   无法输入字符串  直接自动退出运行 原因 \r\n

     */

        System.out.println("----------------[华丽分割线]----------------");

        //=================[解决方案]=================
        // 1 都用字符串接收 然后把字符串形式的整数 转化成对应的整数 -----》【掌握，实际开发的做法】
        // int num = Integer.parseInt("123");

        Scanner sc = new Scanner(System.in);

        // 接收键盘输入的结果
        System.out.println("请输入一个整数: ");

        // 接收整数
        String str_num = sc.nextLine();
        //将字符串"123" ===》123整型
        // Integer.parseInt("123")  ==> 123   强转
        int num = Integer.parseInt(str_num);

        // 打印内容
        System.out.println("num " + num);

        //再用nextLine() 接收字符串
        System.out.println("请输入字符串: ");

        String str = sc.nextLine();
        System.out.println(str);

    }
}

3.Object类的toString和 equals方法

Object类 简介： '它是所有类的父类， 所有的类都直接或者间接的继承自Object类'
	构造方法：
		public Object();

	成员方法：
		public String toString()
			
			返回该对象的字符串表示形式。
			作者：格式为： 全类名，@标记符 ，该对象的哈希码的无符号十六进制形式组成。 ===》对象的地址
	实际开发：无意义，实际开发中，子类都会重写该方法，改为打印：该对象的各个属性值。

	如何重写呢？ 快捷键生成。

	public boolean equals(Object obj)；
		作者：比较两个对象是否相等(即：是否是同一个对象)，默认比较的是地址值是否相等，无意义
		实际开发：子类都会重写该方法，用来比较各个对象的属性值是否相等。
		举例：
			stu1.name == stu2.name
            stu1.age == stu2.age
            stu1和stu2地址肯定不一样 new了两次
            如果各个属性都相等，可以认为是同一个对象

细节（'记忆'）:
	1. 实际开发中，我们认为，如果同一个类的多个对象，只要属性值相同，他们就是同一个对象，即：
		Student s1 = new Student("马佳玉" ，23)；
		Student s2 = new Student("马佳玉" ，23);
		上述两个对象实际开发中，我们也会认为他们是同一个对象。
	2. 输出语句直接打印对象，默认调用了该对象的toString()方法。

代码

public class Demo01 {
    public static void main(String[] args) {
        //1.演示toString方法
        Student student = new Student();

        //还未重写：toString方法
        //作者：格式为: 全类名, @标记符, 该对象的哈希码的无符号十六进制形式组成. ==> 对象的地址
        //重写了toString方法：实际开发：无意义, 实际开发中, 子类都会重写该方法, 改为打印: 该对象的各个属性值.
        System.out.println(student);
        System.out.println(student.toString());

        //演示equals方法
        Student stu1 = new Student("马佳玉" ,23);
        Student stu2 = new Student("马佳玉" ,23);
        //还未重写equals方法
        //作者：比较两个对象是否相等(即: 是否是同一个对象), 默认比较的是地址值是否相等, 无意义, false

        //已经重写了equals
        //实际开发：子类都会重写该方法，用来比较各个对象的属性值是否相等
        boolean flag = stu1.equals(stu2);
        System.out.println(flag); //true
    }
}

4.字符串比较详解

String类简介：
	他是java.lang包下的类，可以直接使用，无需导包，他表示所有的字符串，每一个字符串都是它的对象。
		String s1 = new String("abc");
		String s1 = "abc";  //免new 语法糖

				成员方法：
		public boolean equals(Object obj);
			这个是String重写了Object#equals() 方法，比较字符串的内容是否相同，区分大小写。
			注意：不再是比较地址是否一致，非要比较地址是否一致： ===比较运算符
		public boolean equalsIgnoreCase(String s)
			这个是String独有的方法，比较字符串的内容是否相同，不区分大小写。

	需求：
		定义字符数组chs，初始化值为：'a' ,'b' ,'c' ，这三个字符。
		将其分别封装成s1 ，s2这两个字符串对象
		直接通过 "" 的方式创建两个字符串对象s3 和 s4 
		通过 == 分别判断s1 和s2 ， s3 和 s4 是否相同。
		通过equals() 分别判断 s1 和s2 ， s3 和 s4 是否相同。
		通过equalsIgnoreCase() 判断字符串abc 和 ABC 是否相同

	细节：（记忆）
		1. == 的作用：
			比较基本类型：比的是 数值。     10 == 20  比较数值
			比较引用类型：比的是 地址值     s1 == s2  比较地址值
		2. String# equals() 区分大小写  equalsIgnoreCase()忽略大小写

代码

package demo02_object;

/**
 * 需求：
 *  定义字符数组chs 初始化值为：‘a’，'b', 'c', 这三个字符 .
 *  将其分别封装成s1，s2这两个字符串对象
 *  直接通过 “” 的方式创建两个字符串对象s3和s4
 *  通过 == 分别判断是s1 和 s2  s1和s3 s3和s4是否相同
 *  通过equals()分别判断s1和s2, s1和s3, s3和s4是否相同.
 *  通过equalsIgnoreCase()判断字符串abc和ABC是否相同.
 */
public class Demo02 {
    public static void main(String[] args) {
        //定义字符数组chs  初始化值为 ：'a', 'b', 'c', 这三个字符 .
        char[] chs = {'a' ,'b' ,'c'};
        // 快捷键： alt + shift + 光标选中多行
        // 将其分别封装成s1, s2这两个字符串对象.
        String s1 = new String(chs);
        String s2 = new String(chs);

        //直接通过“”的方式创建两个字符串对象s3和s4
        String s3 = "abc";
        String s4 = "abc";

        // 通过==分别判断s1和s2, s1和s3, s3和s4是否相同.
        // TODO:注意：不再是比较地址是否一致，非要比较地址是否一致：==比较运算符
        System.out.println(s1 == s2); // false  因为new了两次，不是同一块空间
        System.out.println(s1 == s3); // false  两个不同的对象，地址不一致
        System.out.println(s3 == s4); // true   在内存只会存在一块空间
        System.out.println("----------------[华丽分割线]----------------");
        // 通过equals()分别判断s1和s2, s1和s3, s3和s4是否相同.
        // TODO:equals()判断内容是否一致
        System.out.println(s1.equals(s2)); // true 比较的是内容，内容一致
        System.out.println(s1.equals(s3)); // true 比较的是内容，内容一致
        System.out.println(s3.equals(s4)); // true 比较的是内容，内容一致

        System.out.println("----------------[华丽分割线]----------------");
        // 通过equalsIgnoreCase()判断字符串abc和ABC是否相同.  忽略大小写
        System.out.println("abc".equals("ABC")); // false equals区分大小写
        System.out.println("abc".equalsIgnoreCase("ABC")); // true 不区分大小写\
    }
}

在这里插入图片描述

5. 模拟登陆

思路

1. 定义变量，记录账号密码
2. 创建Scanner对象
3. 因为只有三次机会 使用for循环
4. 提示用户录入账号和密码 并接收
5. 判断录入的账号密码是否正确 正确就等于成功 退出程序
6. 如果不正确 判断是否还有剩余的登录次数 有就继续  没有就锁定账号

代码

package demo02_object;

import java.util.Scanner;

/*
    案例: 模拟登陆.

    需求:
       模拟用户登录, 只给3次机会, 登录成功则提示"欢迎您, ***".
       登录失败则判断是否还有登录机会, 有则提示剩余登录次数, 没有则提示"您的账号已被锁定".
       假设初始化账号和密码分别为: "传智播客", "黑马程序员".

     // 1.定义变量，记录账号和密码  "传智播客", "黑马程序员".
     // 2.创建Scanner对象
     // 3.因为只有三次机会，使用for循环
     // 4.提示用户输入账号密码，并接收
     // 5.判断录入的账号和密码是否正常，正确，登录成功则提示"欢迎您, ***".
     // 6.如果不正确，判断剩余登录次数，有就提示剩余登录次数，继续， 没有就提示"您的账号已被锁定".

 */
public class Demo03_Login {
    public static void main(String[] args) {
        // 1.定义变量，记录账号和密码  "传智播客", "黑马程序员".
        String username = "马佳玉";
        String password = "你好";

        // 2.创建scanner对象
        Scanner sc = new Scanner(System.in);

        // 3.因为只有3次机会 所有使用for循环
        // 快捷键 fori
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入您的密码: ");
            String usern = sc.nextLine();
            System.out.println("请输入您的密码: ");
            String pass = sc.nextLine();

            // 5.判断录入的账号和密码是否正常，正确，登录成功则提示"欢迎您, ***".
            // 判断值相等：equals方法
            if (usern.equals(username) && pass.equals(password)) {
                System.out.println("欢迎您登录: " + usern);

                //跳出循环
                break;
            }else {
                // 6.如果不正确，判断剩余登录次数，有就提示剩余登录次数，继续， 没有就提示"您的账号已被锁定".
                // 剩余次数？？？ 公式： 2 - i = 次数
                /*if((2 - i) > 0){
                    System.out.println("录入错误 您还有 " + (2-i)  + " 次机会");
                }else{
                    System.out.println("错误次数已达上限，账号锁定，请联系管理员");
                }*/

                // 优化：三目运算符
                System.out.println(2 - i > 0 ? "录入错误 您还有" + (2 - i) + "次机会" : "错误次数 已达上限，账号锁定，请联系管理员");
            }
        }
    }
}

6.遍历字符串

思路：

1. 提示用户录入字符串 并接收
2. 遍历字符串

代码

package demo02_object;

import java.util.Arrays;
import java.util.Scanner;

/*
    案例: 遍历字符串.

    需求:
        键盘录入一个字符串, 使用程序实现在控制台遍历打印该字符串.

    涉及到的String类中的成员方法:
        public char charAt(int index);      根据索引, 获取对应的字符.
        public int length();                获取字符串的长度.
        public char[] toCharArray();        将字符串转成其对应的字符数组形式.
 */
public class Demo03_Iter {
    public static void main(String[] args) {
        // 1.提示用户输入字符串 并接收
        // 快速导包快捷键 alt + 回车
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串: ");
        //"abcde"
        String s = sc.nextLine();
        // 2.遍历字符串
        // 方案1：for循环遍历
        for (int i = 0; i < s.length(); i++) {
            // i 就是下标
            char c = s.charAt(i);
            System.out.println(c);
        }
        System.out.println("----------------[华丽分割线]----------------");

        //方案2 toCharArray() 将字符串转换字符数组
        // "abcde" ==>['a' ,'b' ,'c' ,'d' ,'e']
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[i];
            System.out.println(ch);
        }
        System.out.println("----------------[华丽分割线]----------------");

        // 实际开发
        //s.toCharArray() 转换成字符串数组
        // Arrays.toString() 打印数组每个元素
        System.out.println(Arrays.toString(s.toCharArray()));
    }
}

7. 统计每类字符的次数

思路

定义统计变量 用来记录结果
键盘录入一个字符串 并接收
遍历字符串 获取每一个字符
判断该字符属于那种类别 对应类别得到计数器就 ++

代码

package demo04_exercise;

import java.util.Scanner;

/*
    案例:  统计没类字符的次数 并打印结果
    需求：
        键盘录入一个字符串 统计该字符串中大写字符串 小写字母字符 数字字符出现的次数
        注意: 不考虑其他字符 例如@ ! \ /等
 */
public class Demo03 {
    public static void main(String[] args) {
        // 定义统计变量 用来记录结果
        int smallCount = 0, bigCount = 0, numberCount = 0;
        // 键盘录入一个字符串 并接收  abc12ABCD!@#$
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串: ");
        String s = sc.nextLine();

        //3.遍历字符串 获取每一个字符
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            //ch 就是字符串中的每一个字符
            char ch = chs[i];  //"a" ,'B'
            // 判断该字符属于那个类别  属于谁 对应的计数器就++
            if (ch >= 'a' && ch <= 'z')
                smallCount ++;
            else if (ch >= 'A' && ch <= 'Z')
                bigCount++;
            else if (ch >= 'O' && ch <= '9')
                numberCount++;
        }
        // 打印结果
        System.out.println("小写字母字符: " + smallCount);
        System.out.println("大写字母字符: " + bigCount);
        System.out.println("数字字符: " + numberCount);
    }
}

8.StringBuilder基本使用

思路

StringBuilder 简介：
	它表示字符串缓冲区类，内容是可变的

构造方法：
	public StringBulider();
	public StringBulider(String s);
	可以把这个构造方法理解为就是用来实现： 把字符串转成 对应的StringBuilder 对象的。
	String 字符串  ==》 StringBulider 字符串缓冲区类

成员方法：
	public String toString(); 	重写object#toString(),打印对象内容
	public String reverse(String); 反转字符串 返回自身
	public boolean append(Object obj); 添加元素 返回自身

代码

package demo08_StringBuilder;
/*
    //StringBuilder简介:
           它表示字符串缓冲区类, 内容是可变的.

    //构造方法:
        public StringBuilder();
        public StringBuilder(String s);
        可以把这个构造方法理解为就是用来实现:把 字符串 转成 对应的StringBuilder对象 的.
        String 字符串类 ==>  StringBuilder 符串缓冲区类

    //成员方法:
          public String toString();           重写Object#toString(), 打印对象内容.
          public String reverse(String);      反转字符串, 返回自身.
          public boolean append(Object obj);  添加元素, 返回自身.
 */

/**
 * 演示StringBuilder入门
 * 需求：
 *     通过上述的两种方式 创建StringBuilder对象
 *     在控制台直接打印上述创建好的两个对象 并观察结果
 */
public class Demo01 {
    public static void main(String[] args) {
        // 方案1: 空参构造创建StringBuilder对象
        StringBuilder sb1 = new StringBuilder();
        // 添加元素，返回StringBuilder对象
        StringBuilder sb2 = sb1.append("abc");
        StringBuilder sb3 = sb1.append("123");

        System.out.println(sb1);
        System.out.println(sb2);
        System.out.println(sb3);

        System.out.println("----------------[华丽分割线]----------------");

        System.out.println(sb1 == sb2); //地址相同 true
        System.out.println(sb1 == sb3); //地址相同 true
        System.out.println(sb2 == sb3); //地址相同 true

        //结论：
        // 1.因为只有一开始的时候使用new创建 sb1对象
        // 2.sb2 ，sb3都是指向同一块内存区域的变量

        System.out.println("----------------[华丽分割线]----------------");
        //方案2：使用字符串初始化 创建StringBuilder对象
        // 本质：String ==》StringBuilder
        StringBuilder sb4 = new StringBuilder("james");
        System.out.println(sb4);
    }
}

9.StringBuilder和string相互转换

问题: 为什么会有类型互相转换？
- 答案: 当某个类A 想用类B的功能的，我们可以尝试把类A对象转换成类B对象，这样就可以调用类B的方法之后，调用完毕之后，再转回类A即可。

package demo08_StringBuilder;
/*
    案例: 演示String和StringBuilder之间的相互转换.

    String -> StringBuilder:
        通过 StringBuilder的构造方法, 即: public StringBuilder(String s);

    StringBuilder -> String:
        通过 StringBuilder#toString()方法, 即: public String toString();
 */
public class Demo02 {
    public static void main(String[] args) {
        // 1.String -> StringBuilder;
        String name = "马佳玉";
        StringBuilder sb1 = new StringBuilder(name);
        System.out.println(sb1);
        System.out.println("----------------[华丽分割线]----------------");

        // 2.StringBuilder -> String
        String new_str = sb1.toString();
        System.out.println(new_str);
    }
}

10.拼接数组元素

链式调用：
- 如果某个方法的返回值是一个对象，可以再后边直接通过，语法继续调用对象的方法
实际开发写法
Arrays.toSring(arr)
代码

package demo05_StringBuilder;

import java.util.Arrays;

/*
    拼接数组元素
    需求：
        定义方法arrayToString() 把int数组的元素按照指定的格式拼接成一个字符串，并返回
        在main 方法中 调用上述的方法
        例如：数组int[] arr = {1,2,3},则拼接后，结果为：[1,2,3]
 */
public class Demo03 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1,2,3};

        //实际开发写法：
        System.out.println(Arrays.toString(arr));

        System.out.println("----------------[华丽分割线]----------------");

        //调用自定义的arrayTostring方法
        String s = arrayToString(arr);
        System.out.println(s);
    }

    /**
     * 将数组转换成字符串
     * @param arr   int类型数组
     * @return      字符串
     * 例如： 数组为int[] arr = {1,2,3} 则拼接后 结果为：[1,2,3]
     */
    public static String arrayToString(int[] arr) {
        // 1.数组非空判断
        if (arr == null || arr.length == 0) {
            // 返回空数组
            return "[]";
        }

        //2.定义StringBuilder类的对象，接受缓存的字符串数据
        StringBuilder sb = new StringBuilder("[");

        // 遍历数组 完成数据拼接
        // 数组遍历快捷键 itar
        for (int i = 0; i < arr.length; i++) {
            //arr = {1,2,3} 则拼接后，结果为：[1,2,3]
            // 如果没有到最后一个元素 我们添加数组的元素和逗号
            if (i != (arr.length - 1)) {
                //添加数组的元素和逗号
                // 链式调用：如果某一个方法返回值是该类的对象，后面可以继续掉该对象的其他方法，这种继续调用
                sb.append(arr[i]).append(",");
            } else {
                // 如果到最后一个元素 我们添加数元素和 “]”
                sb.append(arr[i]).append("]");
            }
        }
        // 将StringBuilder对象转换成字符串返回
        return sb.toString();
    }
}

11.StringBuilder反转字符串

链式调用：
如果某个方法的返回值是一个对象可以在后边直接通过，语法继续调用对象的方法
代码

package demo05_StringBuilder;

import java.util.Scanner;

/*
    反转字符串
    需求：
        键盘录入一个字符串 然后反转其内容 并打印

    思路：通过StringBuilder#reverse()方法实现.
        1. 把 String -> StringBuilder.
        2. 调用StringBuilder#reverse()反转内容.
        3. 把StringBuilder -> String.
        4. 打印结果.
 */
public class Demo04 {
    public static void main(String[] args) {
        // 输入字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串: ");
        String s = sc.nextLine();
        System.out.println("反转之前: " + s);  //反转之前: sdfslkdfjsldf
        System.out.println("----------------[华丽分割线]----------------");
        //1.把String -》StringBuilder
        StringBuilder sb = new StringBuilder(s);

        //2. 把StringBuilder#reverse()反转内容
        sb.reverse();

        //3.把StringBuilder -》String
        String new_str = sb.toString();
        //4.打印结果
        System.out.println("反转之后: " + new_str);   //反转之后: fdlsjfdklsfds
        System.out.println("----------------[华丽分割线]----------------");

        //方案2：链式调用，一句代码搞定
        String s1 = new StringBuilder(s).reverse().toString();
        System.out.println(s1);

    }
}

数据结构算法：冒泡排序，快速排序，希尔排序，堆排序。。。。。。。

12.冒泡排序

冒泡排序原理：
- 相邻元素两两比较，大的往后走，这样第一轮比较完之后，最大值就在最大所引出
代码

package demo06_sort;

import java.util.Arrays;

/*
    案例: 演示冒泡排序.
    需求:
        已知数组int[] arr = {25, 69, 80, 57, 13}, 请编写代码对齐进行升序排序.
        即: 排序后结果为: arr = {13, 25, 57, 69, 80};

    核心点:
        1. 总共比较几轮?
            arr.length - 1
        2. 每轮比较多少次?
            arr.length - 1 - i
        3. 谁和谁比较?
            arr[j] 和 arr[j+1]

    灵魂三连问:
        1. 外循环的-1是什么意思?
            最后一轮不需要和自己再比较，减少比较次数，提高性能
        2. 内循环的-1是什么意思?
            防止出现索引越界
        3. 内循环的-i是什么意思?
            减少每一轮的比较次数，提高性能
 */
public class Demo01_Sort {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {25,69,80,57,13};

        //2.定义外层循环控制: 比较的总轮数 arr.length -1
        //折叠快捷键ctrl + -
        for (int i = 0; i < arr.length - 1; i++) {// 0 1 2 3
            //3.定义内层循环控制每一轮比较的次数 arr.length -1 -i
            for (int j = 0; j < arr.length -1 - i; j++) {
                // 4. 两两比较 如果前面的值比后面一个值大 就交换位置 大的元素 ==》冒泡
                //前一个值: arr[j]
                //后面一个值: arr[j + 1]
                if (arr[j] > arr[j + 1]) {
                    /*
                        a和b交换
                        temp临时变量 记录
                        int temp = a;
                        a = b;
                        b = temp;
                     */
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        // 5.打印结果
        System.out.println(Arrays.toString(arr));
            //结果为：[13, 25, 57, 69, 80]
        /*for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }*/
    }
}

二、Arrays

1.演示Arrays工具类的用法

Arrays工具类概念：
- 他是用来操作数组的工具类，里边定义了大量操作数组元素的方法，例如：排序、转换字符串等。
格式：

涉及到的成员方法:
	1. 对数组进行升序排序，默认是升序。
		public static void sort(int[] arr);
	2. 把数组转换成其对应的字符串表示形式，例如: int[] arr = [1,2,3]; --> "[1,2,3]"
		public static String toString(数组对象)；

工具类:
	1. 成员都是静态的
	2. 构造方法私有化

代码：

package demo06_sort;

import java.util.Arrays;

public class Demo02_Array_Sort {
    public static void main(String[] args) {
        //1. 定义数组
        int[] arr = {25,69,80,57,13};

        //2.对数组进行排序
        Arrays.sort(arr);

        //3.打印数组结果
        System.out.println(Arrays.toString(arr));
    }
}

四、包装类

1.包装类入门

概念

包装类入门
包装类简介:
	'	所谓的包装类指的就是 基本类型对应的引用类型。	'
	对应关系：
		基本类型				对应的包装类(引用类型)
		byte					Byte
		short					Short
		char					Character
		int  					Integer
		long					Long
		float					Float
		double					Double
		boolean					Boolean

	学习包装类主要目的：
		'	String类型的数据  ==转换==》  该包装类对应的基本类型	'

	例如：
		Integer	是用来把	"123" 	-> 123
		Double	是用来把	"10.3" 	-> 10.3
		Boolean 是用来把 "false" -> false
		..........

	Integer类解释:
		概述：
			'	他是int类型对应的引用类型(包装类)，主要适用于把"123" 	-> 123	'
		构造方法:
			public Integer(int i);			创建Integer对象，封装：整数。
			public Integer(String s)；		创建Integer对象，封装：字符串，必须是纯数字形式的字符串
		成员变量:
			public static final int MAX_VALUE;		int类型最大值。
			public static final int MIN_VALUE;		int类型最小值。

代码

package demo04_exercise;
/*
    案例：包装类入门
 */
public class Demo01 {
    public static void main(String[] args) {
        // int类型最大值
        System.out.println(Integer.MAX_VALUE);

        //int类型最小值
        System.out.println(Integer.MIN_VALUE);

        //构造方法
        //创建Integer对象，封装: 整数.
        Integer il = new Integer(10);
        System.out.println(il);

        // 创建Integer对象, 封装: 字符串, 必须是纯数字形式的字符串.
        Integer i1 = new Integer("123");
        System.out.println(i1);
    }
}

2.int和String相互转换

int 和 String 之间相互转换

int 和 String 之间如何相互转换
	int ---》 String：
		String s = "" + 10；

	String ---》 Int：
		int num = Integer.parseInt("123");

Integer类中的方法解释:
     public static int parseInt(String s);  把字符串形式的整数转成其对应的int类型.

记忆（细节）：
	所有包装类都有一个parseXXX（）方法，用于把字符串数据转换成该类型对应的基本类型的数据
	例如：
		int num = Integer.parseInt("123");
		double d = Double.parseDouble("10.3");
        boolean flag = Boolean.parseBoolean("true");

代码：

package demo07_interger;
/*
    int 和String之间如何相互转换
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求：int 和 String之间如何相互转换:

        //1. int -> String:
        String str = "" + 10;
        System.out.println(str);
        System.out.println("----------------[华丽分割线]----------------");

        //2.String -> Int
        String str_int = "520";
        int num  = Integer.parseInt(str_int);
        System.out.println(num);

        // 举一反三
        /*
        Double.parseDouble("10.11");
        Float.parseFloat("11.11");
        Boolean.parseBoolean("true");
        */
    }
}

3.字符串元素排序

需求:
    已知字符串String s = "91 27 45 38 50";
    请通过代码实现最终输出结果是: "27, 38, 45, 50, 91"

思路：
	1. 把String字符串转换成其对应的字符串数组。
			String[] arrstr = {"91", "27", "45", "38", "50"};
	2. 把String[]  -> int[]
            int[] arr = [91, 27, 45, 38, 50];
    3. 对int[]进行排序.
            int[] arr = [27, 38, 45, 50, 91];
    4. 把上一获取到的数组元素拼接成对应格式的字符串.
            "27, 38, 45, 50, 91"

涉及到的成员方法：
	String类中的成员的方法：
		public String[] split(String regex);	根据规则，切割字符串。
		public String substring(int start ，int end)；  截取字符串，包左不包右。
		public String replaceAll(String older ,String newStr); 替换字符串

	Integer类中的成员方法：
		将字符串转换成int类型
			parseInt();
			
	Arrays类中的成员方法：
		数组排序
			sort(),
			打印数组
			toString()

代码

package demo07_interger;

import java.util.Arrays;

/**
 * 案列：字符串元素排序
 * 已知字符串String s = "91 27 45 38 50";
 * 请通过代码实现最终输出结果是: "27, 38, 45, 50, 91"
 */
public class Demo02 {
    public static void main(String[] args) {
        String str = "91 27 45 38 50";
        //1.将字符串String 转换成对应的字符串数组
        //"91 27 45 38 50" ==>  String[] arrStr = {"91", "27", "45", "38", "50"}
        String[] arrstr = str.split(" ");

        //2.字符串数组String[] 转换成 int[]整型数组
        //int[] arr = {91, 27, 45, 38, 50}
        int[] intArr = new int[arrstr.length];
        // 遍历字符串数组，将每一个字符串转换成整型，再装入到int[]整型数组
        for (int i = 0; i < arrstr.length; i++) {
            String str1 = arrstr[i];
            // 将每一个字符串转换成整型
            intArr[i] = Integer.parseInt(str1);
        }
        //3.int[]整型数组进行升序排序
        Arrays.sort(intArr);

        //4.排序后的int[]整型数组，拼接成字符串
        // [27, 38, 45, 50, 91] ==> 目标："27, 38, 45, 50, 91"
        String s11 = Arrays.toString(intArr);
        // 字符串的截取
        //String s12 = s11.substring(1, s11.length() - 1);
        // 字符串的替换
        // 参数1：旧的字符串 参数2：新的字符串  注意点：\\ 转译
        String s12 = s11.replaceAll("\\[","").replaceAll("]","");
        //"27, 38, 45, 50, 91"
        System.out.println(s12);

    }
}

4.自动拆装箱(JDK1.5的特性)

代码

package demo07_interger;

import com.sun.tools.corba.se.idl.InterfaceGen;

/*
    案例: 演示自动拆装箱(JDK1.5的特性)

    装箱: int -> Integer, 即: 把基本类型 -> 包装类.
    拆箱: Integer -> Int, 即: 包装类 -> 基本类型.
 */
public class Demo03 {
    public static void main(String[] args) {
        // 1.装箱
        // JDK1.5之前的写法  装箱: int -> Integer,
        Integer i1 = new Integer(1);

        // JDK1.5版本 以上版本
        Integer i2 = 10;

        System.out.println(i1);
        System.out.println(i2);
        System.out.println("----------------[华丽分割线]----------------");

        // 2.拆箱
        // JDK1.5之前的写法 拆箱: Integer -> Int
        int a = i2.intValue();

        // JDK1.5 以上的写法 拆箱: Integer -> Int
        int b = i2;

        System.out.println(a);
        System.out.println(b);

        // 观察如下代码 发生了什么
        // 装箱
        Integer i3 = 10;
        // 等价于：i3 = i3 + 20   先拆箱i3变成int，然后和20相加，再把结果int类型装箱变成Integer
        i3 += 20;
    }
}

五、Date和Calendar

Date类


Date解释:java.util包下的类, 它表示日期类,可以精确到毫秒,里边大多数的方法已过时,已经被Calendar替代了.

   构造方法:
            public Date();    // 获取当前时间           

   成员方法:
            public void setTime(long time);      //设置时间, 单位: 毫秒.
            public long getTime();      				 //获取时间, 单位: 毫秒.

   细节:
        1. 直接打印Date对象, 格式我们不习惯, 能不能换成我们习惯的格式.
           可以, SimpleDateFormat可以实现.
        2. 翻看API发现Date大多数方法已过时, 被Calendar替代了.
            Calendar: 日历类.
        3. 获取当前时间毫秒值.
            long time = System.currentTimeMillis();

代码

package demo08_date;
import java.util.Date;

/*
    案例: 演示Date类的用法.
 */
public class Demo01 {
    public static void main(String[] args) {
        //演示Date的用法
      
      	// 1.获取当前时间
        Date d = new Date();
        System.out.println(d);      //Thu Sep 09 17:41:30 CST 2021
        System.out.println(d.getTime());  //1631180490798, 从1970到当前时间, 总共有多少毫秒.
        System.out.println("--------------------");
				
        // 2.设置时间
        Date d2 = new Date(1631180490798L);
        System.out.println(d2); //Thu Sep 09 17:41:30 CST 2021
        System.out.println("--------------------");

        //3.获取当前时间毫秒值, 实际开发做法.
        long time = System.currentTimeMillis();
        System.out.println(time);
    }
}

2.SimpleDateFormat时间格式化类的用法

概述：
	他表示日期格式化类，主要用来格式化或者解析日期的。

构造方法：
	public SimpleDateFormat();			默认模板
	public SimpleDateFormat(String pattern) 指定模板

成员方法：
	Date -》 String：	格式化
		format();
	String -> Date:		解析
		parse();
案例：
	自定义DateUtils工具类。

代码

package demo08_SimpleDateFormat;

import java.text.SimpleDateFormat;
import java.util.Date;

/*
    案例:演示SimpleDateFormat的用法.
    案例:
        自定义DateUtils工具类.
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        // 1.获取当前日记
        Date d = new Date();
        System.out.println(d);
        System.out.println("===================");

        //2.演示：Date 转化 -》String：
        // 格式化日期： YYYY-MM-DD HH-mm-ss
        // 创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        String new_date = sdf.format(d);
        System.out.println(new_date);
        System.out.println("=================");

        //3.演示：String -》Date:
        String s = "2021年10月10日 15:50:50";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //此处有异常，需要抛出异常 快捷：alt + 回车
        Date d2 = sdf2.parse(s);
        System.out.println(d2);
    }
}

3.Calendar基本使用

案例: 演示Calendar的用法.

Calendar简介：
	概述：
		它表示日历类，是一个抽象类，里面大多数的方法都是代替 Date类的功能。
	成员常量：
		public static final int YEAR；
		public static final int MONTH;
        public static final int DATE;
        public static final int DAY_OF_MONTH;
        public static final int DAY_OF_YEAR;

	成员方法：
		public static Calendar getInstance()；	获取Calendar类的实例.
		public int get(int field);      根据指定的日历字段, 获取值.
		public int set(int year, int month, int day);  设置时间.

代码

package demo08_SimpleDateFormat;

import java.util.Calendar;

/*
    案例: 演示Calendar的用法.
 */
public class Demo02 {
    public static void main(String[] args) {
        //抽象类多态  Calendar类的子类对象.
        Calendar c = Calendar.getInstance();

        //获取时间字段.
        System.out.println(c.get(Calendar.YEAR));   //2021
        System.out.println(c.get(Calendar.MONTH));  //8, Java中月份范围: 0 ~ 11
        System.out.println(c.get(Calendar.DATE));   //9
        System.out.println(c.get(Calendar.DAY_OF_MONTH));   //9
        System.out.println(c.get(Calendar.DAY_OF_YEAR));    //252
        System.out.println("-----------------------------");
    }
}

4. 异常处理

异常简介:
        概述:
            Java中, 把所有的非正常情况统称为异常.
        分类:
            父类: Throwable
                Exception:  这个才是我们常说的异常.
                    运行时异常: 指的是 RuntimeException及其子类.
                    编译期异常: 指的是 非RuntimeException及其子类.
        编译期异常和运行时异常的区别是什么?
            编译期异常: 必须处理, 才能通过编译.
            运行时异常: 不处理, 也能通过编译, 但是运行报错.

        JVM默认是如何处理异常的?
            1. 会把异常的类型, 原因, 位置打印到控制台上.
            2. 并终止程序的执行.

        异常的处理方式:
            方式1: 声明抛出异常, throws
                大白话翻译: 告诉调用这里, 我这里有问题, 谁调用, 谁处理.
                处理之后, 程序终止运行, JVM默认用的就是这个.

            方式2: 捕获异常, 处理之后, 程序继续执行.
                try {
                    可能出现问题的代码;
                } catch(Exception e) {
                    e.printStackTrace();  //打印异常的类型, 位置, 原因
                } finally {
                     里边放一定会执行的代码.
                }

代码

package com.itheima.demo09_exception;

import java.text.ParseException;
import java.text.SimpleDateFormat;

/*
    案例: 演示异常.
 */
public class Demo01 {
    public static void main(String[] args) {
        //运行时异常
        //System.out.println(1 / 0);      //ArithmeticException(算术异常)
        //System.out.println("看看我执行了吗?");

        //编译期异常
        //SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        //sdf2.parse("2020年1月1日");

        try{
            //可能出现问题的代码;
            show();
        }catch (Exception e){
            e.printStackTrace();  //打印异常的类型, 位置, 原因
        }finally {
            //释放资源的, 正常情况下, 里边的代码永远会执行.
        }
        System.out.println("看看我执行了吗?");
    }
    public static void show() throws ParseException {
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        sdf2.parse("2020/1/1");
    }

}