包装类，装箱和拆箱————一篇就搞定了

1.包装类——一篇就搞定了

2.1.java 里面对应的8中基本数据类型准备了8中包装类

• 思考？为什么要提供8种包装类？

-----看代码

public class IntegerTest {
    public static void main(String[] args){`在这里插入代码片`

    }

    public static void doSOme(Object object){
        System.out.println(object);
    }
}

---：代码里面我们设计了一个方法，输出这个对象，
 *      我们发现，只能对形参进引用类型的赋值，基本的数据类型都不能加进去
 *      我们怎么加进去一个基本的数据类型呢？
 * 

解决办法：：：：

class MyInt{
    int value;

    public MyInt() {
    }

    public MyInt(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

描述：

 *      接下来我们设计了一个MyInt的类，里面有一个int类型的value数据，
 *      重写他的toString方法，利用valueOf方法返回一个字符串类型的数据
 *      return这个数据，当我们输出一个对象的时候就输出了这个对象类里面的
 *      int类型的数据。
 *
 *      我们虽然不能传进去一个int类型的数据，但是可以设计一个类，把这个类的
 *      对象的引用给传递过去，间接的达到传进去一个int类型数据的效果，这就是包装类
 * 
 *

结果：

public class IntegerTest {
    public static void main(String[] args){
        MyInt myInt =new MyInt(100);
        doSome(myInt);

    }

100

Process finished with exit code 0

-----描述：这里我们输出了一个100，好像就是对doSome方法里传进去一个100一样，但是其实我们传进去的是一个引用数据类型，但是效果是一样的，

.
.
.
.

2.八种基本数据类型对应的包装类

    基本数据类型：                              包装类
 *  -------------------------------------------------------------------
 *      byte                                        java.lang.Byte(父类：Number)
 *      short                                       java.lang.Short(父类：Number)
 *      int                                         java.lang.Integer(父类：Number)
 *      long                                        java.lang.Long(父类：Number)
 *      float                                       java.lang.Float(父类：Number)
 *      double                                      java.lang.Double(父类：Number)
 *      boolean                                     java.lang.Boolean------(父类：Object)
 *      char                                        java.lang.Character----(父类：Object)
 *
 -----**有两个父类是Object 其余的直接父类都是Number，Number 里面有一下的方法代码下图**

--------知道上面的我们就能理解什么是装箱和拆箱了
----------------什么是装箱和拆箱呢？？？
.
.
.
.
.

我们以Integer类来说明
---------------------------------------------------------------先看几个方法

**----------------------------------------Number 类里面的方法：**
**----------------------------------------------方法摘要** 
byte byteValue() 
          以 byte 形式返回指定的数值。 
abstract  double doubleValue() 
          以 double 形式返回指定的数值。 
abstract  float floatValue() 
          以 float 形式返回指定的数值。 
abstract  int intValue() 
          以 int 形式返回指定的数值。 
abstract  long longValue() 
          以 long 形式返回指定的数值。 
 short shortValue() 
          以 short 形式返回指定的数值。 

我们可以调用这种类型的方法把这个引用数据类型的数据返回成指定数据类型的
这与我们把基本数据类型转换为引用数据类型的方式相反，

基本数据类型————————>引用数据类型（装箱）
引用数据类型————————>基本数据类型（拆箱）

  Integer i=new Integer(100);//-----装箱

        int i1=i.intValue();//-----拆箱

3.自动拆箱自动装箱

Integer i=5;//自动装箱，相当于执行 Integer i=Integer.valueOf(5);
.
.
.
int i2=i;//自动拆箱，相当于执行 int i2=i.intValue();

详解自动装箱过程：

.
.

-------自动装箱的时候我们不是系统给我们执行了一个
Integer.valueOf(5) ;------（上个图的例子，5是可变的）
我们执行了这样一个方法，但是这个方法是怎么回事呢，
这得看一下，否则影响我们对装箱的细节理解
.
.

——上代码！！！！！！！！！

 public static Integer valueOf(int i) {
 return  i >= 128 || i < -128 ? new Integer(i) : SMALL_VALUES[i + 128];
}

分析：

.—我们把数组传递给这个int 类型名为i的形参，然后呢有一个三目运算符，如果i>=128或者i<=128就创建一个Integer对象，（是新建了一个对象在堆内存里面）如果-128<=i<128 就返回SMALL_VALUES[i + 128]这个数（下面讲这个数是什么，这里你先知道返回了一个这个样的数据，根据 方法的返回值类型我们看到这个数据是一个
Integer类型的，）
.
.
.

1.是创建一个对象：
------创建一个对象，这个对象指向常量池里数据为5的数据，i指向了这个对象，从而调用到5 所以i指向这个对象，可以说是i保存了这个对象的地址，重要的事情说3遍
（i保存了这个对象的地址）
（i保存了这个对象的地址）
（i保存了这个对象的地址）
.
.

2.是返回一个我们不知道的什么东西：
----我们来看这个东西是什么
上代码！！！！！

private static final Integer[] SMALL_VALUES = new Integer[256];

这是什么呢？
.
.

-----------private static final ————定义了一个常量
---------- Integer[] SMALL_VALUES———— Integer类型的名为 SMALL_VALUES的一个数组
-----------256代表数组的长度是256
.

其实里卖相当于存储了从 -128-----127的数据，
返回这个 Integer[] SMALL_VALUES = new Integer[256]; 这个东西的就是当你的 i 的范围在-128<=i<128的时候，就不用创建对象了，直接把你要存的数据给你返回了，这个数据早已经存在，不需要创建对象了，直接返回已经存在的值就行了，
不用创建对象不是节省了空间，这就很妙，妙啊~~~~
这里提一句 整数类型的数据，如Byte Short Integer Long 都适用
.
.
.
.
-----------那么 Float Double 不行呢：
-----------因为小数在整数之间有无数个数字，这样显然不恰当，没法用一个数组给一定范围内的数据给直接包括了，就不行
.
.

下面看一下题：

Integer i = 50;  
 int i2 = 50;  
Long i3 = 100l;  
 System.out.println(i + i2);  //100
 System.out.println(i3 == (i + i2));  //true
 System.out.println(i3.equals(i + i2));  //false
 

我们一条条分析：

第一句：

System.out.println(i + i2);  //100

分析：i是Integer类型的，和一个 int 类型的i2 相加，一个引用和一个基本数据类型相加
这里不同类型相加怎么加的呢？这里会自动拆箱，把i 给拆箱，把i对应的数据和i2相加，然后输出

第二句：

 System.out.println(i3 == (i + i2));  //true

分析：同理一，i 先拆箱，和i2相加是int类型的数据 i3是 Long 类型的引用（不是long 大小写要分清）
然后i3也拆箱，数据和数据比较显然是正确的

第三句：

 System.out.println(i3.equals(i + i2));  //false

分析：为什么用了equals方法就不行了呢？
我们看一下这里代码用的equals方法是怎么回事

public boolean equals(Object o) {
   return (o instanceof Integer) && (((Integer) o).value == value);
 }

分析：这里的equals方法是Long 类里面重写的方法
他返回了一个 boolean 真或者假

(o instanceof Integer) && (((Integer) o).value == value);

这里先判断equals(i + i2)括号里面的东西是不是一个Long类型的
然后再装箱看你传入的i + i2 的value就是i + i2的值和 i3 的value的值是否相等
我们要主要到调用方法的是i3 后面的value肯定就是i3的值
这里我们看到 类型并不相同，显然false
.
.
…

.

！！！！！！！！！！！！！！码字很累，给个赞再溜！！！！！！！！！！！！！！！！！！！！！

.