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对象

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

    @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.为啥要使用包装类:
  当我们调用方法的时候,人家方法的形参或者返回值类型都要求使用包装类,所以我们就需要将基本类型转成包装类去返回,去传参
  而且包装类里面有很多的方法可以去操作我们的数据

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

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