day01_Object类、常用API

主要内容

Object类
Date类
DateFormat类
Calendar类
System类
StringBuilder类
包装类

教学目标

-[ ] 能够说出Object类的特点
-[ ] 能够重写Object类的toString方法
-[ ] 能够重写Object类的equals方法
-[ ] 能够使用日期类输出当前日期
-[ ] 能够使用将日期格式化为字符串的方法
-[ ] 能够使用将字符串转换成日期的方法
-[ ] 能够使用System类的数组复制方法
-[ ] 能够使用System类获取当前毫秒时刻值
-[ ] 能够说出使用StringBuilder类可以解决的问题
-[ ] 能够使用StringBuilder进行字符串拼接操作
-[ ] 能够说出8种基本类型对应的包装类名称
-[ ] 能够说出自动装箱、自动拆箱的概念
-[ ] 能够将字符串转换为对应的基本类型
-[ ] 能够将基本类型转换为对应的字符串

第一章 Object类

1.1 概述

java.lang.object类是java语言中的根类，即所有类的父类。它中描述所有子类都可以使用。在实例化对象的时候，最终父类就是object。

如果一个类没有特别指定的父类，那么默认集成的就是object类。

代码如下：

public class MyClass /*extends Object*/{
    // ...
}

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。今天我们主要学习其中的2个：

public String toString():返回改对象的字符串表示。
public boolean eqals(object obj):指示其他某个对象是否与此对象“相等”

1.2 toString方法

方法摘要：

public String toString（）：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

覆盖重写

如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

public class Person{
    private String name;
    private int age;
    
    @Override
    public String toString(){
        return "Person{"+"name"+name+'\''+",age="+age+'}';
    }
    public Person(){
        
    }
    public Preson(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
}

重写toString快捷方法

在IntelliJ IDEA中，可以点击Code菜单中的Generate...，也可以使用快捷键alt+insert，点击toString()选项。选择需要包含的成员变量并确定。

小贴士：在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

1.3 equals方法

方法摘要

public boolean equals(Object obj):指示其他某个对象是否与此对象”相等“。
equals方法源码：

public Boolean equals(Object obj){

return(this == obj);

}

参数：

object obj：可以传递任意的对象
== 比较运算符，返回值是一个布尔值 true 或 false
- 基本数据类型：比较的是值
- 引用运算符：比较的是两个对象的地址值
this是指：那个对象调用的方法，方法中的this就是那个对象。
- 如boolean b = p1.equals(p2);
- p1调用的equals方法所以this就是p1；
- obj就是p2
- this == obj --> p1 == p2

// 调用上边定义好的person类
Person p1 = new Person("迪丽热巴",19);
Person p2 = new Person("古力娜扎"，20);
boolean b = p1.equals(p2);
结果为;false

默认地址比较

如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

重写Object类的equals方法

在IntelliJ IDEA中，可以使用Code菜单中的Generate…选项，也可以使用快捷键alt+insert，并选择equals() and hashCode()进行自动代码生成。

1.4 Objects类

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。

代码如下：

public class Demo03Objcets {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = "999";
        // NullPointerException null是不能调用方法的会报空指针异常
        /*boolean b = s1.equals(s2);
        System.out.println(b);*/
        /*
        * objects类equals方法：对两个对象进行比较，防止空指针异常
        *public static boolean equals(Object a, Object b) {
             return (a == b) || (a != null && a.equals(b));
            }
        * */

        boolean b2 = Objects.equals(s1, s2);
        System.out.println(b2);
    }
}

第二章日期时间类

2.1 Date类

概述

java.util.Date类表示特定的瞬间，精确到毫秒。

继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

public Date()：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
public Date(long date)：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

tips: 由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。

简单来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。

import java.util.Date;

public class Demo01Date {
    public static void main(String[] args) {
        demo01();
        demo02();
        demo03();
    }
    /**
* Date类空参的构造方法
* Date（）获取当前的时间和日期
* */
    private static void demo01() {
        Date date = new Date();
        // Mon Mar 09 13:02:04 CST 2020
        System.out.println(date);
    }
    /**Date类带参的构造方法
     * Date（Long date）传递毫秒值，把毫秒值转换为Date的日期
     */
    private static void demo02() {
        Date date = new Date(0L);
        // Thu Jan 01 08:00:00 CST 1970
        System.out.println(date);
    }
    /**
    *   long getTime()  把日期转换为毫秒值相当于（system.currentTime()方法）
     *   返回自 1970年 1 月 1日00:00:00 GMT 以来此 Date 对象表示的毫秒数-
    * */
    public static void demo03(){
        Date date = new Date();
        long time = date.getTime();
        // 1583731291264
        System.out.println(time);
    }
}

tips:在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。

常用方法

Date类中的多数方法已经过时，常用的方法有：

public long getTime() 把日期对象转换成对应的时间毫秒值。

2.2 DateFormat类

java.text.DateFormat：是日期的/时间格式化子类的抽象类

作用：

格式化（也就是日期--> 文本）、解析（文本-->日期）

成员方法：

String format（Date date）按照指定的模式，把Date日期，格式化为符合模式的。

Date parse(String source) 把符合模式的字符串，解析为Date日期

注意

DateForamt类是一个抽象类，无法直接创建对象使用，可以使用DateFormat类的子类

java.text.SimpleDateFormat extends DateFormat.

构造方法

SimpleDateFarmat(String pattern)

用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。

参数：

String pattern：传递指定的模式

模式：区分大小写

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档0。

创建SimpleDateFormat对象的代码如：

import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class Demo02SimpleDateFormat {
    public static void main(String[] args) {
        // 对应的日期格式如：2018-01-16 15:06:38
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }    
}

常用方法

DateFormat类的常用方法有：

public String format(Date date)：将Date对象格式化为字符串。
public Date parse(String source)：将字符串解析为Date对象。

format方法

使用DateFormat类中的方法format，把日期格式转化为文本
使用步骤：
1.创建SimpleDateFormat对象，构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的方法format，按照构造方法中的指定模式，吧Fate日期转化为符合模式的字符串（文本）

使用format方法的代码为：

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date对象转换成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

parse方法

使用DateFormat类中的parse方法，把文本转换为日期
使用步骤：
1.创建SimpleDateFormat对象，构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的方法parse，吧符合构造方法中模式的字符串，解析为Date日期
注意：
public Date parse(String source) throws ParseException
parse方法声明了一个异常叫ParseException
如果字符串和构造方法的模式不一样，那么程序就会出下异常
调出一个抛出了异常的方法，就必须得处理这个异常，要么throws继续抛出这个异常要么try catch自己处理

使用parse方法的代码为：

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把String转换成Date对象
*/
public class Demo04DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = "2018年12月11日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
    }
}

2.3 练习

请使用日期时间相关的API，计算出一个人已经出生了多少天。

思路：

1.获取当前时间对应的毫秒值

2.获取自己出生日期对应的毫秒值

3.两个时间相减（当前时间– 出生日期）

/*
     *练习：
     *  请使用日期相关的API，计算出一个人已经出生了多少天
     *分析：
     *  1.使用Scanner类中的next方法，获取出生日期
     *  2.使用DateFormat类中的方法parse，把字符串解的出生日期析为Date格式
     *  3.把Date格式的出生日期转换为毫秒值
     *  4.获取当前日期转换为毫秒值
     *  5.使用当前日期的毫秒值  -  出生日期的毫秒值
     *  6.把毫秒值的差转换为天（s/1000/60/60/24）
     * */
public class test{
    
    public static void main(String[] args){
        // 使用Scanner类中的方法next，获取出生日期
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入出生日期");
        String csrq = sc.next();
        // 2.使用DateFormat类中的方法parse，把字符串解的出生日期析为Date格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd");
        Date birtdayDate = sdf.parse(csrq);

        // 3.把Date格式的出生日期转换为毫秒值
        long time = birtdayDate.getTime();

        // 4.获取当前日期转换为毫秒值
        long todayTime = new Date().getTime();

        // 5.使用当前日期的毫秒值  -  出生日期的毫秒值
        long t = todayTime - time;

        // 6.把毫秒值的差转换为天（s/1000/60/60/24）
        System.out.println(time/1000/60/60/24);
        
    }
}

2.4 Calendar类

日历类 java.util.Calender,在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

获取方式

Calendar为抽象类，无法直接创建对象使用，里面有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象。

static Calendar getInstance() 使用默认时区和语言环境获取一个日历

// 导包
java.util.Calendar

public class Calendar{
public void main(String[] aegs){
    // 多态
    Calendar c = Calendar.getInstance();
    Syste.out.println(c);
    
}
}

常用方法

get方法用来获取指定字段的值，set方法用来设置指定字段的值

Calendar类的常用成员方法

get方法

格式：

public int get(int field):返回给定日历字段的值
参数：传递指定的日历字段（YEAR,MONTH...）
返回值：日历字段代表的具体的值

public static void main(String[] args) {
        demo01();
}

public static void demo01(){
        // 使用getInstance方法获取Calendar对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);
        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        int mouth = c.get(Calendar.MONTH);
        // 西方月份0-11  东方月份1-12
        System.out.println(mouth);

        int date = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(date);
        int date2 = c.get(Calendar.DATE);
        System.out.println(date2);
    }

set方法

格式：

public void set(int field,int value):将给定的日历字段设置为给定值
参数：
int field:传递指定的日历字段（YEAR,MONTH...）
int value:给指定的字段设置值

public static void main(String[] args) {
         demo02();
   }
 public static void demo02(){
        // 使用getInstance方法获取calendar对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        c.set(999,6,6);
        // 获取年
        c.set(Calendar.YEAR,666);
        int year = c.get(Calendar.YEAR);
        System.out.println("系统时间："+year);
        System.out.println("重新设置年：："+year);

        // 重新设置月
        c.set(Calendar.MONTH,6);
        int month = c.get(Calendar.MONTH);
        System.out.println("月份："+month);

        // 重新设置日
        c.set(Calendar.DATE,11);
        // 获取日
        int date = c.get(Calendar.DATE);
        System.out.println(date);

        c.set(999,6,6);
        System.out.println(year+"年"+month+"月"+date+"日");
    }

add方法

格式：

public abstract void add(int field,int amount):根据日历的规则，得指定的日历字段添加或者减去指定的时间量把指定的字段量增加/减少指定的值
参数：
int field:传递指定的日历字段（YEAR,MONTH...）
int amount:增加/减少指定的值
正数：增加
负数：减少

public static void main(String[] args) {
         demo03();
}

public static void demo03(){
        Calendar c = Calendar.getInstance();
        // 增加两年
        c.add(Calendar.YEAR,2);
        int year = c.get(Calendar.YEAR);
        System.out.println(year);

        // 减少两个月
        c.add(Calendar.MONTH,-1);
        int month = c.get(Calendar.MONTH);
        System.out.println(month);
    }

getTime方法

Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。

格式：

public Date getTime():返回一个表示此calendar时间值（从历元到现在的毫秒值偏移量）的Date对象
把日历对象，转换为日期对象

public static void main(String[] args) {
         demo04();
}
public static void demo04(){
        // 使用getInstance方法获取calendar对象
        Calendar c = Calendar.getInstance();

        Date date = c.getTime();
        System.out.println(date);
        // Thu Mar 12 23:20:35 CST 2020

    }

小贴士：

西方星期的开始为周日，中国为周一。

在Calendar类中，月份的表示是以0-11代表1-12月。

日期是有大小关系的，时间靠后，时间越大。

练习

public void main(String[] args){
    //Date
    
    Date d = new Date();
    System.out.println(d);
    // Fri Mar 13 21:29:03 CST 2020
    
    // 根据本地格式显示
   System.out.println(d.toLocaleString());
    //2020-3-13 21:29:03
    
    // Date(Long date)传递毫秒值，把毫秒值转换为Date日期
    d = new Date(66666L);
    System.out.println(d);
    // Thu Jan 01 08:01:06 CST 1970
    
    
    // DateFormat类
    
    // String format(Date date)按照指定的模式，把date日期转换为符合模式的
    // 创建日期格式化对象
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");
    String s = sdf.format(d);
    System.out.println(s);
    // 1970年01月01日 08:01:06
    
    // 把文本格式转换为日期
    String str = "2088年08月08日 06:09:00";
    Date parse = sdf.parse(str);
    System.out.println(parse);
    // Sun Aug 08 06:09:00 CST 2088
    
    
    // Calendar类
    
    //获取日历对象
    Calendar c = Calendar.getInsance();
    
    // get
    int year = c.get(Calendar.YEAR);
    System.out.println(year);
    
    // set
    c.set(Calendar.YEAR,2066);
    year = c.get(Calendar.YEAR);
    System.out.println(year);
    
    // add
    c.add(Calendar,YEAR,2);
    year = c.get(Calendar.YEAR);
    System.out.println(year);
}

第三章 System类

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

public static long currentTimeMillis()`：返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

3.1 currentTimeMillis方法

实际上，currentTimeMillis方法就是获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

public static long currentTimeMillis();返回以毫秒为单位的当前时间
用来程序测试的效率

练习

验证for循环打印数字1-9999所需要使用的时间（毫秒）

 public static void main(String[] args) {
        demo01();
    }
private static void demo01(){
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("程序运行时间为"+(end - start)+"毫秒");
    }

3.2 arraycopy方法

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：

参数序号	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

练习

将src数组中前3个元素，复制到dest数组的前3个位置上复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

 public static void main(String[] args) {
        demo02();
    }
/**
 * 练习：
 * 将src数组中前3个元素，复制到dest数组的前3个位置上
 * 复制元素前：
 *      src数组元素[1,2,3,4,5]，
 *      dest数组元素[6,7,8,9,10]
 * 复制元素后：
 *      src数组元素[1,2,3,4,5]，
 *      dest数组元素[1,2,3,9,10]
 * public static void arrayCopy(Object src,int srcPos,Object dest,int destPos,int length):将数组指定数据拷贝到另一个数组中
 * 参数：
 *      src - 源数组。
 *      srcPos - 源数组中的起始位置(起始索引)。
 *      dest - 目标数组。
 *      destPos - 目标数据中的起始位置。
 *      length - 要复制的数组元素的数量。
 */
private static void demo02(){
    // 定义源数组
    int[] src = {1,2,3,4,5};
    // 定义目标数组
    int[] dest = {6,7,8,9,10};
    // 复制前
    System.out.println("复制前"+ Arrays.toString(dest));
    // 使用System类中的arrayCory把原数组的前三个元素复制到目标数组的前三个位置上
    System.arraycopy(src,0,dest,0,3);
    // 复制后
    System.out.println("复制后："+ Arrays.toString(dest));



}

第四章 StringBuilder类

4.1 字符串拼接问题

String类

字符串是常量，他们的值再创建后不能更改。

字符串底层是一个被final修饰的数组，不可改变，是一个常量

private final byte[] value；

进行字符串的相加，内存中就会有很多个字符串，占用空间多，效率低下：

比如

String s = "a"+"b"+"c" = "abc";

"a","b","c"  3个字符串
"a"+"b" "ab" 1个字符串
"ab"+"c" "abc" 1个字符串

4.2 StringBuilder类

字符串缓冲区，可以提高字符串的操作效率（看成一个长度可以变化的字符串）

底层也是一个数组，但是没有被final修饰，可以改变长度

byte[] value = new byte[16];

StringBuilder在内存中始终是一个数组，占用空间少，效率高

如果超出了StringBuilder的容量，会自动扩容

4.3 构造方法

根据StringBuilder的API文档，常用的两个构造方法：

public StringBuilder():构造一个空的StringBuilder容器
public StringBuilder(String str):构造一个StringBuilder容器，并将字符串添加进去

public static void main(String[] args){
    // 空参
    StringBuilder bu1 = new StringBuilder();
    System.out.println(bu1);// （空白）
    // 带字符串的构造方法
     StringBuilder bu2 = new StringBuilder("abc");
    System.out.println(bu2);// （abc）
}

4.4 常用成员方法

StringBuilder常用的方法有两个：

append方法

public stringBuilder append（。。）：添加任意数据类型的字符串形式，病返回自身

public static void main(String[] args){
    // 创建StringBuilder对象
    StringBuilder bu1 = new StringBuilder();
    // 使用append方法添加数组
    StringBuilder bu2 = bu1.append("abc");// 把bu1的地址值赋值给了bu2
    Systom.out.println(bu1);// abc
    Systom.out.println(bu2);// abc
    Systom.out.println(bu1 == bu2); // ture
    // 使用appen方法无需接收返回值
    bu1.appen("a");
    bu1.appen("b");
    bu1.appen("c");
    Systom.out.println(bu1);// abc

    // 链式编程:方法返回值是一个对象，可以继续调用方法
    bu1.appen("a").appen("b").appen("c");
    Systom.out.println(bu1);// abc
}

toString方法

StringBuilder和string可以相互转换
- stringbuillder-->String：public String toString（）：将当前的StringBuilder对象转换为String对象
- string-->StringBuillder：可以使用StringBuilder的构造方法StringBuilder（String str）构造一个字符串生成器，并初始化指定字符串的内容

string-->StringBuillder
public static void main(String[] args){
    // string-->StringBuillder

    String str = "hello";
    System.out.println("str"+str);// str
    StringBuilder bu = new StringBuilder(str);
    // 往StringBuilder里添加数据
    bu.append("wold");
     System.out.println("bu"+bu);// helloworld
     
     // stringbuillder-->String
     String s = bu.toString();
     System.out.println("s"+s);// helloworld
}

reverse方法

public static void main(String[] args){
    StringBuilder str = new StringBuilder();
    str.append("j").append("a").append("va");
    str.reverse();
    System.out.println(str);// avaj
}

第五章包装类

5.1 概述

java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

5.2 装箱拆箱

基本类型与对应的包装类对象之间，来回转换过称称为“装箱”与“拆箱”:

装箱：从基本类型转换为对应的包装类对象。（基本类型的数据-->包装类）
构造方法：
- Integer（int value）构造一个新分配的 Integer 对象，他表示指定的 int 值。
- Integer（String s）构造一个新分配的Integer对象，它表示 String 参数所指示的 int 值。
- 传递的字符串，必须是基本类型的字符串，否则会抛出异常 "100" 正确 "a" 抛异常
静态方法：
- static Integer valueOf(int i) 返回一个指定的 int 值的 Integer 实例。
- static Integer valueOf(String s) 返回保存指定的String 的值的 Integer 对象
拆箱：从包装类对象转换为对应的基本类型。（包装类-->基本类型的数据）
- 成员方法：
  - int intValue() 以 int 类型返回该 Integer 的值。

用Integer与int为例：

基本类型 -- > 包装对象

// 使用构造函数
Integer i= new Integer(6);
// 使用包装类中的valueOf方法
Integer ii = Integer.valueIf("6");

包装对象-->基本数值

int num = i.intvalue();

5.3 自动装箱与自动拆箱

自动装箱与自动拆箱：基本类型的数据和包装类之间可以进行相互转换

JDK1.5之后出现的新特性

自动装箱：直接把int类型的整数赋值于包装类

如：Integer in = 1；就相当于 Integer in = new Integer(1);
自动拆箱：int是包装类，无法直接参与运算，可以自动转换为基本数据类型，再进行计算

如：in + 2;就相当于 in.intVale() + 2 = 3;

int = in.intVale() + 2 = 3 又是一个自动装箱

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

5.4基本类型与字符串之间的转换

1.基本类型-->字符串（String）

基本类型的值+" " 最简单的方法（工作中常用）
包装类的静态方法toString（参数），不是Object类的toString方法（）重载

static String toString（int i）返回一个表示指定整数的string 对象。
String类的静态方法valueOf（参数）

static String valueOf（int i）返回 int 参数的字符串表示形式。

2.字符串（String）--> 基本类型

使用包装类的静态方法parseXXX（"字符串"）；

如：

Integer类： static int parseInt（Sting s）

Double类：static double parseDouble（String s）；

 public static void main(String[] args) {
        // 基本类型-->字符串
        int i1 = 100;
        String s1 = i1 +"";
        System.out.println(s1+999);

        String s2 = Integer.toString(100);
        System.out.println(s2+300);

        String s3 = String.valueOf(100);
        System.out.println(s3 + 100);

        // 字符串（String）--> 基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i - 10);

        // 不能转换字符串报错 数字格式异常 NumberFormatException
        /*int a = Integer.parseInt("a");
        System.out.println(a);*/

    }