java包装类和自动拆装箱

一、什么是包装类

Java中的数据类型分为基本数据类型和引用数据类型，而java当中的基本数据类型不具有对象特征的，也就是说它们不能像对象一样拥有属性和方法。
包装类的产生就是为了解决基本数据类型存在的这样一些问题，通过包装类可以让基本数据类型获取对象一样的特征，行使对象相关的权力。

1.java中的基本数据类型和引用数据类型

1.基本数据类型只有8种，可按照如下分类
.
1.整数类型：long、int、short、byte
2.浮点类型：float、double
3.字符类型：char
4.布尔类型：boolean
.
2.引用数据类型非常多，大致有： 类、 接口类型、 数组类型、 枚举类型、 注解类型、 字符串型 我们常用的String类型就是引用类型。
.
3.二者之间的区别：
1.存储位置 基本数据类型：在方法中定义的非全局基本数据类型变量的具体内容是存储在栈中的。 引用数据类型变量，其具体内容都是存放在堆中的，而栈中存放的是其具体内容所在内存的地址。
2.传递方式 基本数据类型调用方法数据按数值传递。 引用数据类型调用方法传递的是地址，也就是参数与原变量指向的是同一个地址。

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

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
char	Character
floar	Float
double	Double
boolean	Boolean

3.包装类的特点：

1.所有包装类都是final类型，因此不能创建他们的子类。
2.包装类是不可变类，一个包装类的对象自创建后，他所包含的基本类型数据就不能被改变。

二、自动装拆箱

装箱：将基本数据类型变为包装类对象。
拆箱：将包装类中包装的基本数据类型取出。

package com.heavysea.l;

/**
 * @author heavysea
 * @date 2021/6/18
 */
public class MyInt {
    public static void main(String[] args) {
        int i=0;
        Integer num = new Integer(5);
        // 自动装箱 把基础数据类型打包成包装类
        Integer num2 = 0;
        // 自动拆箱 把包装类拆成基本数据类型
        int j = num2;
        // Integer 中的静态方法  取最大值
        Integer.max(3,4);
        // 把字符串转变为int类型 打印出来
        int m = Integer.parseInt("2344");
        System.out.println(m);
    }
}

注意：在有些项目文件中定义类的属性时往往采用基本类型对应的包装类。例如可能去定义private Integer num1,而不去定义private int num2.因为不初始化时，num1为空即为null,更具有实际意义。

三、练习 包装数组

SuperArray.java
封装一个 SuperArray的类，实现相应的功能

package com.heavysea.l;


/**
 * @author heavysea
 * @date 2021/6/18
 */
public class SuperArray {
    private int[] array;
    private int currentSize = -1;

    public SuperArray(int size)
    {
        array = new int[size];
    }

    public SuperArray()
    {
        this(10);
    }

    public void addNum(int num)
    {
        currentSize++;
        if(currentSize>array.length-1){
            int[] temp = new int[array.length*2];
            for(int i=0;i<=currentSize;i++){
                temp[i] = array[i];
            }
            temp[temp.length-1] = num;
            array = temp;
        }else{
            array[currentSize] = num;
        }

    }

    public void deleteNum(int index)
    {
       if(index<0||index>currentSize){
           System.out.println("位置有错误");
       }
       for(int i=index;i<=currentSize;i++){
            array[i] = array[i+1];
        }
        currentSize--;
    }

    // 冒泡法排序 从小到大

    public void sort(){
        int temp;
        for(int j=0;j<currentSize;j++){
            for(int i=0;i<currentSize-j;i++){
                if(array[i+1]<array[i]){
                    temp = array[i+1];
                    array[i+1] = array[i];
                    array[i] = temp;
                }
            }
        }
    }

    public void printData()
    {
        for(int i=0;i<=currentSize;i++){
            System.out.println(array[i]);
        }
    }

    public String toStr()
    {
        String ret = "";

        for(int i=0;i<=currentSize;i++){
            if(i==currentSize){
                ret += array[i]+"";
            }else{
                ret += array[i]+",";
            }
        }

        return ret;
    }
}

Test.java

package com.heavysea.l;

/**
 * @author heavysea
 * @date 2021/6/19
 */
public class Test {
    public static void main(String[] args) {
        SuperArray superArray = new SuperArray(10);
        superArray.addNum(3);
        superArray.addNum(5);
        superArray.addNum(1);
        superArray.addNum(0);

        superArray.sort();
        superArray.printData();
        superArray.deleteNum(1);
        System.out.println("after delete-----");
        superArray.printData();
        System.out.println(superArray.toStr());
    }
}

经过人为封装后，可以在Test.java中像操作其他封装类一样操作这个类，需要对数组进行排序或打印只要直接调用方法即可，这就是封装的魅力所在吧。