11.异常_throws_try...catch_BigInteger_BigDecimal_Date_Calendar_LocalDate_Integer

第一章.异常

1.异常介绍

1.概述:代码出现了不正常的现象,在java中异常都是一个一个的类,一个一个的对象
2.分类:
  Error(错误):代码出现了重大问题,相当于人得了绝症,不能通过throws和try...catch去处理
  Exception(异常):代码出现了一些问题,相当于人得了感冒,可以通过throws和try...catch去处理
3.异常的分类:所有的异常类都有一个共同的父类   -> Exception
  a.编译时期异常:没有语法错误,但是调用某个方法,底层给咱们抛出来一个编译时期异常,编译的时候就导致我们调用方法的地方报红了
               点到方法底层,看看抛出来的异常,然后再看看异常的继承体系中有没有RuntimeException,如果没有,一定是编译时期异常
  b.运行时期异常:没有语法错误,但是一运行就报红(报错了)
               点到这个异常的底层,看看这个异常的继承体系中有没有RuntimeException,如果有,一定是运行时期异常
      
  c.注意:Exception作为所有异常的父类,但是Exception这个父类本身属于编译时期异常

    @Test
    public void test01(){
        //运行时期异常
        //int[] arr = new int[3];
        //System.out.println(arr[5]);

        //编译时期异常
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //Date date = sdf.parse("2020-01-01 10:10:10");
        //System.out.println(date);
    }

2.异常出现的过程

3.创建异常对象(了解)

1.格式: throw new 异常()    

public class Demo03Exception {
    public static void main(String[] args) {
        String s = "abc.txt1";
        method(s);
        System.out.println("呵呵呵");
    }


    /**
     * String类中的方法
     * boolean endsWith(String str) -> 判断字符串是否以指定的串儿结尾
     *   比如:  "abcde".endsWith("e") -> 判断abcde是否以e结尾
     * @param s
     */
    private static void method(String s) {
        if (!s.endsWith(".txt")){
            //创建异常对象
            throw new NullPointerException("空指针");
        }
        System.out.println("哈哈哈");
    }
}

4.异常处理方式(重点)

1 异常处理方式一_throws

1.格式:
  throws 异常  -> 参数后面写  -> 往上抛异常

public class Demo04Exception {
    public static void main(String[] args) throws FileNotFoundException {
        String s = "abc.txt1";
        insert(s);//添加功能
        System.out.println("删除功能");
        System.out.println("修改功能");
        System.out.println("查询功能");
    }

    private static void insert(String s) throws FileNotFoundException {
        if (!s.endsWith(".txt")){
            //创建异常对象
            throw new FileNotFoundException("文件找不到异常");
        }
        System.out.println("哈哈哈");
    }
}

2 异常处理方式一_throws多个异常

1.格式:
  throws 异常1,异常2...  -> 参数后面写  -> 往上抛异常
2.注意:如果throws多个异常之间有子父类继承关系,我们可以直接throws父类异常

public class Demo05Exception {
    public static void main(String[] args) throws /*FileNotFoundException,*/IOException {
        String s = "abc.txt1";
        insert(s);//添加功能
        System.out.println("删除功能");
        System.out.println("修改功能");
        System.out.println("查询功能");
    }

    private static void insert(String s) throws /*FileNotFoundException,*/IOException {
        if (s==null){
            throw new IOException();
        }

        if (!s.endsWith(".txt")){
            //创建异常对象
            throw new FileNotFoundException("文件找不到异常");
        }


        System.out.println("哈哈哈");
    }
}

3.异常处理方式二_try...catch

1.格式:
  try{
      可能出现异常的代码
  }catch(异常 对象名){
      处理异常的代码(打印异常信息到日志文件中)
  }

2.执行流程:
  如果try中的代码有异常,直接走catch进行捕获,捕获到了,就走catch里面的代码,如果没有捕获到,相当于没处理
3.特点:
  如果出现了异常并且捕获到了,不会影响后面代码的运行

public class Demo06Exception {
    public static void main(String[] args){
        String s = "abc.txt1";
        try {
            //String s1 = null;
            //System.out.println(s1.length());

            insert(s);//添加功能
        } catch (FileNotFoundException e) {
            e.printStackTrace();//将异常信息打印到控制台上
        }
        System.out.println("删除功能");
        System.out.println("修改功能");
        System.out.println("查询功能");
    }

    private static void insert(String s) throws FileNotFoundException {
        if (!s.endsWith(".txt")){
            //创建异常对象
            throw new FileNotFoundException("文件找不到异常");
        }
        System.out.println("哈哈哈");
    }
}

4.异常处理方式二_多个catch

1.格式:
  try{
      可能出现异常的代码
  }catch(异常 对象名){
      处理异常的代码(打印异常信息到日志文件中)
  }catch(异常 对象名){
      处理异常的代码(打印异常信息到日志文件中)
  }catch(异常 对象名){
      处理异常的代码(打印异常信息到日志文件中)
  }...
      
2.注意:如果catch的多个异常之间有子父类继承关系,我们直接catch父类 

public class Demo07Exception {
    public static void main(String[] args) {
        String s = "abc.txt1";
        try {
            insert(s);//添加功能
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("删除功能");
        System.out.println("修改功能");
        System.out.println("查询功能");
    }

    private static void insert(String s) throws /*FileNotFoundException,*/IOException {
        if (s==null){
            throw new IOException();
        }

        if (!s.endsWith(".txt")){
            //创建异常对象
            throw new FileNotFoundException("文件找不到异常");
        }


        System.out.println("哈哈哈");
    }
}

1.运行时期异常一般不用throws,和try...catch,因为一旦出现了运行时期异常,肯定是代码有点问题,直接改代码就行了

2.我们一般都是处理编译时期异常

3.怎么处理:alt+回车

5.finally关键字

1.格式:
  try{
      可能出现异常的代码
  }catch(异常 对象名){
      处理异常的代码(打印异常信息到日志文件中)
  }finally{
      不管是否捕获到了异常都一定会执行的代码
  }

public class Demo08Exception {
    public static void main(String[] args){
        String s = "abc.txt1";
        try {
            String s1 = null;
            System.out.println(s1.length());//空指针异常

            insert(s);//添加功能
        } catch (FileNotFoundException e) {
            e.printStackTrace();//将异常信息打印到控制台上
        }finally {
            System.out.println("我一定会执行的,不管是否捕获到了异常");
        }
        System.out.println("删除功能");
        System.out.println("修改功能");
        System.out.println("查询功能");
    }

    private static void insert(String s) throws FileNotFoundException {
        if (!s.endsWith(".txt")){
            //创建异常对象
            throw new FileNotFoundException("文件找不到异常");
        }
        System.out.println("哈哈哈");
    }
}

使用场景:

​ finally中的代码一般都是用作释放资源使用->说白了就是咱们的对象只要创建出来,后续代码是否执行成功我们最后都要将其释放,释放内存空间

​ 为啥有的对象需要在finally中手动释放呢?堆内存中的对象,一般都是由GC(垃圾回收器)释放,但是有些对象GC是回收不了的,比如:Socket,IO流,数据库连接对象(Connection)

public class Demo09Exception {
    public static void main(String[] args) {
        int result = method();
        System.out.println(result);
    }

    public static int method() {
        try {
            String s = null;
            System.out.println(s.length());//空指针异常
            return 2;
        } catch (Exception e) {
            //System.exit(0);//退出当前正在执行的jvm
            return 1;
            //System.out.println("哈哈哈哈");
        } finally {
            System.out.println("我一定要执行");
           // return 3;
        }
    }
}

6.抛异常时注意的事项(扩展)

1.父类中的方法抛异常了,子类重写之后要不要抛? 可抛可不抛
2.父类中的方法没有抛异常,子类重写之后要不要抛? 不能抛

7.try_catch和throws的使用时机

1.如果处理异常之后,还想让后续的代码正常执行,我们使用try...catch
2.如果方法之间是调用关系,我们可以先throws,但是到了最后需要用try...catch做一个统一的异常处理

8.打印异常信息的三个方法

Throwable中的方法:  -> 这个类是Error 和 Exception 的父类
  String toString():打印异常类型和异常信息
  String getMessage():获取异常信息
  void printStackTrace():获取最详细的异常信息

public class Demo10Exception {
    public static void main(String[] args){
        String s = "abc.txt1";
        try {

            insert(s);//添加功能
        } catch (FileNotFoundException e) {
            //System.out.println(e.toString());
            //System.out.println(e.getMessage());
            e.printStackTrace();//将异常信息打印到控制台上
        }
        System.out.println("删除功能");
        System.out.println("修改功能");
        System.out.println("查询功能");
    }

    private static void insert(String s) throws FileNotFoundException {
        if (!s.endsWith(".txt")){
            //创建异常对象
            throw new FileNotFoundException("文件找不到异常");
        }
        System.out.println("哈哈哈");
    }
}

第二章.BigInteger

1.BigInteger介绍

1.概述:我们学到的long是接收整数的最大类型,如果这个整数超出了long的范围,我们可以称之为"对象"
2.作用:处理超大整数    

2.BigInteger使用

1.构造:
  BigInteger(String val) -> 字符串中的内容,必须是数字格式
2.常用方法:
  BigInteger add(BigInteger val) -> 加法
  BigInteger subtract(BigInteger val) -> 减法
  BigInteger multiply(BigInteger val) -> 乘法
  BigInteger divide(BigInteger val) -> 除法     

    @Test
    public void test01(){
       //BigInteger(String val) -> 字符串中的内容,必须是数字格式
        BigInteger b1 = new BigInteger("121212121212121212121212121212121212");
        BigInteger b2 = new BigInteger("121212121212121212121212121212121212");
        //BigInteger add(BigInteger val) -> 加法
        BigInteger add = b1.add(b2);
        System.out.println(add);
        //BigInteger subtract(BigInteger val) -> 减法
        BigInteger subtract = b1.subtract(b2);
        System.out.println(subtract);
        //BigInteger multiply(BigInteger val) -> 乘法
        BigInteger multiply = b1.multiply(b2);
        System.out.println(multiply);
        //BigInteger divide(BigInteger val) -> 除法
        BigInteger divide = b1.divide(b2);
        System.out.println(divide);

    }

int intValue()  -> 将BigInteger转成int型
long longValue()-> 将BigInteger转成long型

BigInteger能处理的整数最大为42亿21亿次方,内存根本扛不住这么大的数,所以我们认为BigInteger是无限大的

第三章.BigDecimal类

1.BigDecimal介绍

1.作用:解决float和double直接做运算出现的精度损失问题

2.BigDecimal使用

1.构造:
  BigDecimal(String val) 字符串内容必须是数字格式
2.方法:
  static BigDecimal valueOf(double a)  创建BigDecimal对象
  BigDecimal add(BigDecimal val) -> 加法
  BigDecimal subtract(BigDecimal val) -> 减法
  BigDecimal multiply(BigDecimal val) -> 乘法
  BigDecimal divide(BigDecimal val) -> 除法  -> 如果除不尽,会报错    
  BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) -> 除法  
                    a.divisor:代表的是除号后面的数
                    b.scale:保留几位小数
                    c.roundingMode:舍入方式 -> 类型是一个RoundingMode类型(它是一个枚举类)
                                   UP:向上加1 
                                   DOWN:直接舍去 
                                   HALF_UP:四舍五入 

    @Test
    public void test01(){
        float a = 3.55F;
        float b = 2.12F;

        float sum = a+b;
        System.out.println(sum);

        float sub = a-b;
        System.out.println(sub);
    }

    @Test
    public void test02(){
        BigDecimal b1 = BigDecimal.valueOf(3.55);
        BigDecimal b2 = BigDecimal.valueOf(2.12);
        BigDecimal add = b1.add(b2);
        System.out.println(add);
        BigDecimal subtract = b1.subtract(b2);
        System.out.println(subtract);
        BigDecimal multiply = b1.multiply(b2);
        System.out.println(multiply);
        BigDecimal divide = b1.divide(b2);
        System.out.println(divide);
    }

    @Test
    public void test03(){
        BigDecimal b1 = BigDecimal.valueOf(3.55);
        BigDecimal b2 = BigDecimal.valueOf(2.12);
        BigDecimal divide = b1.divide(b2, 2, RoundingMode.DOWN);
        System.out.println(divide);
    }

第四章.Date日期类

1.Date类的介绍

1.概述:表示特定的瞬间，精确到毫秒
2.地理常识:
  a.1秒 = 1000毫秒
  b.北京时间所在的时区:东8区
  c.时间原点:1970年1月1日 0时0分0秒  -> 时间原点所在的时区比我们北京时间差8个小时    

2.Date类的使用

1.构造:
  Date()  根据当前系统时间创建Date对象 (从时间原点开始算起的)
  Date(long time) 根据指定的毫秒值创建Date对象(从时间原点开始算)   

    @Test
    public void test01(){
        //Date()  根据当前系统时间创建Date对象 (从时间原点开始算起的)
        Date date = new Date();
        System.out.println(date);
        //Date(long time) 根据指定的毫秒值创建Date对象(从时间原点开始算)
        Date date1 = new Date(1000L);
        System.out.println(date1);
    }

3.Date类的常用方法

1.void setTime(long time) 设置时间,传递毫秒值,从时间原点开始算
2.long getTime() 获取时间对应的毫秒值

    @Test
    public void test02(){
        Date date = new Date();
        //1.void setTime(long time) 设置时间,传递毫秒值,从时间原点开始算
        date.setTime(1000L);
        System.out.println(date);
        //2.long getTime() 获取时间对应的毫秒值
        long time = date.getTime();
        System.out.println("time = " + time);
    }

第五章.Calendar日历类

1.Calendar介绍

1.概述:日历类,是一个抽象类
2.获取对象:
  static Calendar getInstance()
3.方法:
  int get(int field) ->返回给定日历字段的值
  void set(int field, int value)  :将给定的日历字段设置为指定的值
  void add(int field, int amount) :根据日历的规则,为给定的日历字段添加或者减去指定的时间量
  Date getTime():将Calendar转成Date对象
      
  日历字段都是静态的成员变量 -> 我们可以直接用类名调用    
      
4.注意:Calendar中设置的月份比咱们实际月份少一个月
      Calendar : 0 1 2 3 4 5 6 7 8 9 10 11
         实际   : 1 2 3 4 5 6 7 8 9 10 11 12
             
             

    @Test
    public void test01(){
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);
    }

    @Test
    public void test02(){
        Calendar calendar = Calendar.getInstance();
        //int get(int field) ->返回给定日历字段的值
        int year = calendar.get(Calendar.YEAR);
        System.out.println("year = " + year);
        //void set(int field, int value)  :将给定的日历字段设置为指定的值
        calendar.set(Calendar.YEAR,2020);
        System.out.println(calendar.get(Calendar.YEAR));
        //void add(int field, int amount) :根据日历的规则,为给定的日历字段添加或者减去指定的时间量
        calendar.add(Calendar.YEAR,1);
        System.out.println(calendar.get(Calendar.YEAR));
        //Date getTime():将Calendar转成Date对象
        Date time = calendar.getTime();
        System.out.println(time);
    }

扩展方法:

void set(int year, int month, int date) 设置年月日
问题:定义一个year,计算这个年份的2月份有多少天    

    @Test
    public void test03() {
        //1.定义一个年份
        int year = 2016;
        //2.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        //3.设置年月日,由于Calendar月份从0开始,所以2月就是咱们的3月
        calendar.set(year,2,1);
        //4.将1号往前推一天
        calendar.add(Calendar.DATE,-1);
        //5.获取day字段
        int day = calendar.get(Calendar.DATE);
        System.out.println(day);
    }

第六章.SimpleDateFormat日期格式化类

1.SimpleDateFormat介绍

1.概述:日期格式化类
2.作用:
  a.可以将Date对象按照指定的格式格式化成一个字符串
  b.还可以将符合指定格式的字符串转回Date对象
3.创建:
  SimpleDateFormat(String pattern)
                   pattern:传递的是我们自己指定的格式
                           比如:yyyy-MM-dd HH:mm:ss
                               
4.方法:
  String format(Date date) 将Date对象按照指定的格式转成字符串
  Date parse(String time) 将符合日期格式的字符串转回Date对象

时间字母表示	说明
y	年
M	月
d	日
H	时
m	分
s	秒

指定的日期格式:连接符可以改变,但是字母不能变

    @Test
    public void test01(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = new Date();

        String time = sdf.format(date);
        System.out.println("time = " + time);

    }

    @Test
    public void test02() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse("2020-05-05 09:09:09");
        System.out.println("date = " + date);
    }

第七章.JDK8新日期类

1. LocalDate 本地日期

1.1.获取LocalDate对象

1.概述:是一个不可变的日期时间对象，表示日期，通常被视为年月日
2.获取:
  static LocalDate now() 从默认时区的系统时钟获取当前日期
  static LocalDate of(int year, int month, int dayOfMonth) 根据指定的年月日创建LocalDate对象   

@Test
public void test01(){
    //static LocalDate now() 从默认时区的系统时钟获取当前日期
    LocalDate localDate = LocalDate.now();
    System.out.println(localDate);
    //static LocalDate of(int year, int month, int dayOfMonth) 根据指定的年月日创建LocalDate对象
    LocalDate localDate1 = LocalDate.of(2020, 10, 10);
    System.out.println(localDate1);
}

1.2.LocalDateTime对象

1.概述:是一个不可变的日期时间对象，代表日期时间，通常被视为年 - 月 - 日 - 时 - 分 - 秒
2.获取:
  static LocalDateTime now()  
  static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second)     

    @Test
    public void test01(){
        //static LocalDateTime now()
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);
        //static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second)
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 10, 10, 10, 10);
        System.out.println(localDateTime1);
    }

1.3.获取日期字段的方法 : 名字是get开头

int getYear()->获取年份
int getMonthValue()->获取月份
int getDayOfMonth()->获取月中的第几天

    /**
     * 获取时间字段
     */
    @Test
    public void test01(){
        LocalDate localDate1 = LocalDate.of(2020, 10, 10);
        //int getYear()->获取年份
        int year = localDate1.getYear();
        System.out.println(year);
        //int getMonthValue()->获取月份
        int month = localDate1.getMonthValue();
        System.out.println(month);
        //int getDayOfMonth()->获取月中的第几天
        int day = localDate1.getDayOfMonth();
        System.out.println(day);
    }

1.4.设置日期字段的方法 : 名字是with开头

LocalDate withYear(int year):设置年份
LocalDate withMonth(int month):设置月份
LocalDate withDayOfMonth(int day):设置月中的天数

    @Test
    public void test02(){
        LocalDate localDate = LocalDate.now();
        //LocalDate withYear(int year):设置年份
        //LocalDate localDate1 = localDate.withYear(2020);
        //System.out.println(localDate);
        //System.out.println(localDate1);
        //LocalDate withMonth(int month):设置月份
        //LocalDate localDate2 = localDate1.withMonth(10);
        //System.out.println(localDate2);
        //LocalDate withDayOfMonth(int day):设置月中的天数
        //LocalDate localDate3 = localDate2.withDayOfMonth(10);
        //System.out.println(localDate3);
        //链式调用
        LocalDate localDate1 = localDate.withYear(2020).withMonth(10).withDayOfMonth(10);
        System.out.println(localDate1);
    }

1.5.日期字段偏移

设置日期字段的偏移量,方法名plus开头,向后偏移
设置日期字段的偏移量,方法名minus开头,向前偏移

    /**
     * 向后偏移
     */
    @Test
    public void test01(){
        LocalDate localDate = LocalDate.now();
        LocalDate localDate1 = localDate.plusYears(1);
        System.out.println(localDate1.getYear());
    }


    /**
     * 向前偏移
     */
    @Test
    public void test02(){
        LocalDate localDate = LocalDate.now();
        LocalDate localDate1 = localDate.minusYears(1);
        System.out.println(localDate1.getYear());
    }

2.Period和Duration类

2.1 Period 计算日期之间的偏差

1.作用:计算年月日时间偏差
2.方法:
  static Period between(LocalDate d1,LocalDate d2):计算两个日期之间的差值
  
  getYears()->获取相差的年
  getMonths()->获取相差的月
  getDays()->获取相差的天

 @Test
    public void test01(){
        LocalDate local1 = LocalDate.of(2023, 10, 10);
        LocalDate local2 = LocalDate.of(2024, 11, 9);

        Period period = Period.between(local1, local2);
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());
    }

2.2 Duration计算时间之间的偏差

1.作用:计算精确时间
2.方法:
  static Duration between(Temporal startInclusive, Temporal endExclusive)  -> 计算时间差
      
  Temporal是一个接口,常用的实现类:LocalDate,LocalDateTime ,但是Duration是计算精确时间偏差的,所以这里传递能操作时分秒的LocalDateTime对象

3.利用Duration获取相差的时分秒 -> to开头
  toDays() :获取相差天数
  toHours(): 获取相差小时
  toMinutes():获取相差分钟
  toMillis():获取相差秒(毫秒)

    @Test
    public void test02(){
        LocalDateTime local1 = LocalDateTime.of(2023, 10, 10, 10, 10, 10);
        LocalDateTime local2 = LocalDateTime.of(2024, 11, 11, 11, 11, 11);
        Duration duration = Duration.between(local1, local2);
        System.out.println(duration.toDays());
        System.out.println(duration.toHours());
        System.out.println(duration.toMinutes());
        System.out.println(duration.toMillis());

    }

计算年月日:Period

计算精确时间偏差:Duration

3.DateTimeFormatter日期格式化类

1.获取:
  static DateTimeFormatter ofPattern(String pattern)   -> 获取对象,指定格式
2.方法:
  a.String format(TemporalAccessor temporal)-> 将日期对象按照指定的规则转成String
    TemporalAccessor:是一个接口,实现类有LocalDate以及LocalDateTime  
   
  b.TemporalAccessor parse(CharSequence text)-> 将符合规则的字符串转成日期对象       
                           CharSequence是一个接口,它有一个实现类-> String
  c.LocalDateTime类中的方法:static LocalDateTime parse(CharSequence text,DateTimeFormatter formatter)-> 将符合规则的字符串转成日期对象

    @Test
    public void test02(){
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String str = "2020-10-10 10:10:10";
        //TemporalAccessor temporalAccessor = dtf.parse(str);
        //LocalDateTime localDateTime = LocalDateTime.from(temporalAccessor);
        //System.out.println(localDateTime);

        LocalDateTime localDateTime = LocalDateTime.parse(str, dtf);
        System.out.println(localDateTime);
    }

第八章.包装类

1.基本数据类型对应的引用数据类型(包装类)

1.概述:基本类型对应的那个引用类型
2.为啥要使用包装类:
  当我们调用方法的时候,人家方法的形参或者返回值类型都要求使用包装类,所以我们就需要将基本类型转成包装类去返回,去传参
  而且包装类里面有很多的方法可以去操作我们的数据

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

2.Integer的介绍以及使用

2.1.Integer基本使用

1.概述:Integer是int对应的包装类
2.构造:
  Integer(int i)
  Integer(String s) -> s的内容必须是数字格式
3.方法:
  static Integer valueOf(int i)  
  static Integer valueOf(String s) -> s的内容必须是数字格式  

    @Test
    public void test01(){
        Integer i1 = Integer.valueOf(1);
        Integer i2 = Integer.valueOf(10);
        System.out.println(i1);
        System.out.println(i2);
    }

2.1.1.装箱

1.概述:将基本类型转成包装类
2.方法:
  static Integer valueOf(int i)  

Integer i = Integer.valueOf(100);
System.out.println(i);

2.1.2.拆箱

1.概述:将包装类转成基本类型
2.方法:
  int intValue()

//装箱
Integer i = Integer.valueOf(100);
System.out.println(i);

//拆箱
int i1 = i.intValue();
System.out.println(i1+1);

2.2.自动拆箱装箱

将来拆箱和装箱都是自动的

    @Test
    public void test03() {
        //自动装箱
        Integer i = 10;

        /*
          1.先将i自动拆箱变成int型
          2.做运算
          3.将结果自动装箱成Integer型
         */
        i += 10;

        System.out.println(i);
    }

    @Test
    public void test04() {
        Integer i1 = 100;
        Integer i2 = 100;
        System.out.println(i1 == i2);//true

        System.out.println("==================");
        Integer i3 = 200;
        Integer i4 = 200;
        System.out.println(i3 == i4);//false
    }

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

3.基本类型和String之间的转换

3.1 基本类型往String转

1.方式1: 拼接
2.方式2:String中的静态方法:
       static String valueOf(int i)  

    @Test
    public void test05() {
        int i = 10;
        String s1 = i+"";
        System.out.println(s1+1);

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

        String s2 = String.valueOf(10);
        System.out.println(s2+1);
    }

3.2 String转成基本数据类型

每一个包装类中都有一个类似的方法:parseXXX()

位置	方法	说明
Byte	static byte parseByte(String s)	将字符串转成byte类型
Short	static short parseShort(String s)	将字符串转成short类型
Integer	static int parseInt(String s)	将字符串转成int类型
Long	static long parseLong(String s)	将字符串转成long类型
Float	static float parseFloat(String s)	将字符串转成float类型
Double	static double parseDouble(String s)	将字符串转成double类型
Boolean	static boolean parseBoolean(String s)	将字符串转成boolean类型

    @Test
    public void test06() {
        String s = "123";
        int i = Integer.parseInt(s);
        System.out.println(i+1);
    }

1.将来我们定义javabean的时候,里面的属性如果是基本类型的,我们都要将其变成包装类类型
2.原因:
  a.包装类中有方法可以直接操作数据
  b.将来我们学框架的时候,人家都要求用包装类型
  c.将来我们的javabean是和数据库表对应的,javabean中的属性值是和表中的数据对应
如果表的主键列是主键自增的约束,我们使用包装类类型在添加的数据比较方便

主键自增长列中的数据在添加的时候不需要我们自己维护 

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer uid;//null
    private String username;
    private String password;
}