【java篇】分析java中的包装类以及类型转换

南斋孤鹤

已于 2023-05-26 12:36:08 修改

阅读量460

点赞数 4

分类专栏： JAVASE基础知识文章标签： java 开发语言服务器

于 2022-06-21 23:39:58 首次发布

本文链接：https://blog.csdn.net/m0_64231944/article/details/125400055

版权

JAVASE基础知识专栏收录该内容

27 篇文章 1 订阅

订阅专栏

为什么会有包装类呢？

我们Java这门语言讲究的是面向对象，其中很重要的一方面就是类，而我们的八大基本类型呢，它仅仅只是一个类型，并非只是一个类，那这岂不是就脱离了java的面向对象以及万事万物皆对象的特征，这时我们java为了弥补这一缺陷，就引进了包装类，包装类就是将我们平时使用的八种基本类型封装在了八个不同的类中，这时就体现出了java的面向对象特征。下面是八种基本类型相对应的包装类。

那么基本类型如何和包装类相联系呢？这就说到了包装类和基本类型之间的相互转化，也就会提到装箱这个概念。

这里你可能会说为什么非要用包装类呢，就用基本类型它不香吗？，这里是因为，将基本类型封装到包装类之后我们就可以使基本类型也可以像对象一样调用一些函数，以满足以后项目中的需求。

这个过程我们叫装箱；调用包装类的构造函数：

下面以int类型演示装箱

  int num1 = 10 ;

//        System.out.println(num1.toString());这段程序报错；原因：基本类型无法调用函数

  Integer in1=new Integer(num1);//装箱操作
  System.out.println(in1.toString());//结果：10

这其中我们调用了基本类型对应的包装类的含参构造函数来进行装箱。

说到装箱，就要提到自动装箱：下面演示

int num1 = 10 ;

Integer in2=num1;//自动装箱

上面这个过程就叫自动装箱，就是java帮我们进行了调用构造函数的过程，我们再不需要去自己调用包装类的构造函数去包装基本类型，就可以直接将基本类型赋值给对应包装类。

包装类——>基本类型：

这个过程我们叫拆箱：调用包装类的***Value（）；

Integer in1 = new Integer(12);
int i=in1.intValue();
System.out.println(i)://12

其他value方法：

自动装箱：

     int num1 = 10 ;
     int num2 = 20 ;

     Integer in1=num1;//自动装箱
     Integer in2=num2;//自动装箱

     int i=in1+in2;
     System.out.println(i);
//

在程序的第五行，原本in1和in2都是Integer类的一个对象，对象是不能进行加减运算的，但是程序却没有报错，这里是因为进行了自动拆箱操作即系统隐式的帮助你进行了拆箱，拆箱之后就可以进行加减操作了。

这里添加一个新的知识点：

再说到包装类的时候，我们会经常提到或者用到基本类型和包装类与String类型之间的转换：下面用代码演示：

String——>基本类型/ 包装类：

调用对应包装类的parse***()方法。（例如parseInt() / parsedouble()等）



//第调用Integer中的parse***()方法；
        int i= Integer.parseInt(s1);
        System.out.println();//输出字符10

其他parse***方法示例：（对应的还有parsefloat(),parsebyte()等等）；

注意：这里有些人可能会想到强转这个方法，但是却是不行的，强转是建立在有继承关系的前提下的，在进行强转时代码会提示类型错误的。(String) 是标准的类型转换，可将 Object 类型转为 String 类型，使用(String) 方法进行强转时，最好使用 instanceof 做一个类型检查，（ instanceof就是判断是否有继承关系的），以判断是否可以进行强转，否则容易抛出 ClassCastException 异常。需要注意的是编写的时候，编译器并不会提示有语法错误，所以这个方法要谨慎的使用。

基本类型/ 包装类——>String：

        int num1 = 10 ;
//第一种，在基本类型后加双引号
        String s1=num1+"";
        System.out.println(s1);//输出字符10
//第二种方式，调用String类中的Valueof(*** ***)方法
 String s = String.valueOf(num1);
        System.out.println(s);//输出字符10

不同类型的基本类型对应着不同得valueof方法，如下图：

综上我们进行代码演示：

public class WrapperTest {

    //基本类型——>String
    @Test
    public void test1(){

        int num1 = 10 ;
//        一、连接型
        String s1=num1+"";
//        num1=s1+2;会报错，说明s1是个字符型数据
        System.out.println(s1);

//        二、调用string类得valueof方法
        String s = String.valueOf(num1);
        System.out.println(s);//输出字符10

        boolean b=true;
        String s2 = String.valueOf(b);
        System.out.println(s2);//输出字符true

        double d=12.34;
        String s3 = String.valueOf(d);
        System.out.println(s3);//输出字符12.34


    }
    //String--->基本类型  调用了包装类中的parse***的方法
    @Test
    public void test2(){

        String s1="123";
        Integer in1=Integer.parseInt(s1);
        System.out.println(in1);//123

        String s2="true123";
        String s3="TuRe";
        Boolean b1=Boolean.parseBoolean(s3);
        Boolean bo=Boolean.parseBoolean(s2);
        System.out.println(bo);//false
        System.out.println(s3);//TuRe

        String s4="1234";
        Double d=Double.parseDouble(s4);
        System.out.println(d);//1234.0

    }
    //
    @Test
    public void test3(){

        int num1 = 10 ;
        int num2 = 20 ;
//        System.out.println(num1.toString());基本类型无法调用函数
        Integer in=new Integer(num1);
        System.out.println(in.toString());
        Integer in1=num1;//自动装箱
        Integer in2=num2;

        int i=in1+in2;
        System.out.println(i);

    }
    @Test//测试包装类到基本类型
    public void test4(){

//        double v = 1.23;
        Double D=new Double(1.23);
        double v = D.doubleValue();
        System.out.println(v);//1.23
    }

    @Test//包装类到string
    public void test5(){
        Integer i=new Integer(123);
        String s = String.valueOf(i);
        /*在上面一行的代码中，String.valueOf()函数中，
         传进去的因该是int型但是传入Integer类型也不会报错，
         这里就用到了自动拆箱
         */
        System.out.println(s);//123

        Boolean b=new Boolean(false);
        String s1 = String.valueOf(b);
        //同上
        System.out.println(s1);//false
    }

    @Test//String-->包装类
    public void test6(){

        String s1="123";
        int i = Integer.parseInt(s1);
        System.out.println(i);//123

        String s4="TruE";
        String s2="true123";
        boolean b1 = Boolean.parseBoolean(s4);
        boolean b = Boolean.parseBoolean(s2);
        System.out.println(b1);//true这里要特别注意
        System.out.println(b);//false

//        String s3="d333";
//        double v = Double.parseDouble(s3);
//        System.out.println(v);
        //报错，因为s3装换后对应的不是double类型。

    }
}

我们尤其注意有关Boolean的转换，比如test6中 String-->包装类时，string类型的字符串在不区分大小写的情况下，只要不是true那么转换后就会输出false。