Java零基础入门-基本类型转换、包装类详解！

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

在前一篇文章《Java零基础入门-基本数据类型和取值范围》中，我们详细介绍了Java的基本数据类型及其取值范围。理解这些基本数据类型是编写有效Java程序的基础，因为它们定义了我们处理数据的基本单位。在这篇文章中，我们将进一步探索Java中的基本类型转换和包装类，这两者在实际开发中扮演着重要的角色。基本类型转换帮助我们在不同数据类型之间进行转换，而包装类则提供了将基本数据类型与对象操作之间的桥梁。

摘要

本文将介绍Java中基本类型转换和包装类的概念及使用方法。我们将首先讲解基本类型转换的规则和应用，然后深入探讨Java中的包装类，包括其功能和常用方法。最后，我们将通过实际代码示例和应用场景分析，帮助读者更好地理解这些概念，并掌握如何在实际开发中使用它们。

简介

Java语言提供了丰富的数据类型和转换机制，以便在编程中处理不同的数据需求。基本类型转换涉及将一种基本数据类型的值转换为另一种类型的值，而包装类则允许基本数据类型以对象的形式存在，使得基本数据类型能够与Java的集合框架等对象操作机制兼容。掌握这两个概念将大大提升Java编程的灵活性和效率。

概述

基本类型转换

在Java中，基本类型转换包括隐式转换和显式转换。隐式转换（自动类型转换）是由编译器自动完成的，通常用于将较小的类型转换为较大的类型，如int转换为long。显式转换（强制类型转换）则需要开发者明确指定，通常用于将较大的类型转换为较小的类型，如double转换为int。

包装类

Java中的每个基本数据类型都有一个对应的包装类，这些包装类都位于java.lang包中。包装类的主要作用是将基本数据类型封装为对象，并提供了一些实用的方法来处理这些对象。常见的包装类包括Integer、Double、Character等。

核心源码解读

基本类型转换示例

public class TypeConversion {
    public static void main(String[] args) {
        // 隐式转换
        int intValue = 100;
        long longValue = intValue;  // 自动转换为long类型
        
        // 显式转换
        double doubleValue = 9.78;
        int intValue2 = (int) doubleValue;  // 强制转换为int类型
        
        System.out.println("隐式转换后的 longValue: " + longValue);
        System.out.println("显式转换后的 intValue2: " + intValue2);
    }
}

包装类示例

public class WrapperExample {
    public static void main(String[] args) {
        // 使用包装类创建对象
        Integer intObj = Integer.valueOf(123);
        Double doubleObj = Double.valueOf(45.67);
        
        // 使用包装类提供的方法
        int intValue = intObj.intValue();
        double doubleValue = doubleObj.doubleValue();
        
        System.out.println("包装类 Integer 的 intValue: " + intValue);
        System.out.println("包装类 Double 的 doubleValue: " + doubleValue);
    }
}

案例分析

在实际开发中，基本类型转换和包装类的使用非常普遍。例如，在处理用户输入时，通常需要将输入的字符串转换为相应的基本数据类型。包装类的使用则可以方便地处理与对象相关的操作，如在集合中存储和操作基本数据类型值。

import java.util.ArrayList;

public class CollectionExample {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);  // 使用包装类存储整数
        
        for (Integer number : list) {
            System.out.println("集合中的数字: " + number);
        }
    }
}

应用场景演示

基本类型转换的应用场景

在计算过程中，尤其是当涉及到不同数据类型的操作时，基本类型转换是不可避免的。例如，数学运算和类型兼容性要求我们在执行操作时正确处理不同的数据类型。

包装类的应用场景

包装类在集合框架中尤为重要，因为Java的集合框架只能存储对象而非基本数据类型。通过包装类，我们可以将基本数据类型转换为对象，从而能够在集合中使用。

优缺点分析

基本类型转换

优点：

• 简化了不同数据类型之间的操作。
• 自动类型转换减少了编写显式转换代码的需求。

缺点：

• 显式转换可能会导致数据丢失，如将double转换为int。
• 需要开发者理解类型转换规则，避免错误。

包装类

优点：

• 提供了对基本数据类型的对象操作支持。
• 可以与Java的集合框架兼容使用。

缺点：

• 包装类的使用可能会带来额外的内存开销。
• 自动装箱和拆箱可能影响性能。

类代码方法介绍及演示

Integer类

public class IntegerExample {
    public static void main(String[] args) {
        Integer intObj = Integer.valueOf("123");
        System.out.println("整数对象的值: " + intObj);
        
        int intValue = intObj.intValue();
        System.out.println("基本数据类型的值: " + intValue);
    }
}

代码解析：

  针对如上示例代码，这里我给大家详细的代码剖析下，以便于帮助大家理解的更为透彻，帮助大家早日掌握。

这段 Java 代码演示了如何使用 Integer 类来创建一个 Integer 对象，并如何将该对象转换回基本数据类型 int。

代码解释如下：

1. IntegerExample 类定义了一个 main 方法，这是 Java 程序的入口点。

2. 在 main 方法中，首先使用 Integer.valueOf() 方法创建了一个 Integer 对象 intObj。这个方法接受一个字符串参数，并尝试将其解析为整数，然后返回一个包含该整数的 Integer 对象。在这个例子中，字符串 "123" 被解析并用于创建 intObj 对象。

3. 接着，代码使用 System.out.println 方法打印出 intObj 对象的值。由于 intObj 是一个对象，所以打印的是对象的字符串表示形式，即 123。

4. 然后，代码调用 intObj 的 intValue() 方法，这个方法返回 Integer 对象中封装的 int 值，并将其赋值给基本数据类型 int 的变量 intValue。

5. 最后，代码再次使用 System.out.println 方法打印出 intValue 的值。这次打印的是基本数据类型 int 的值，也是 123。

当这段代码被编译和运行时，它将输出以下结果：

整数对象的值: 123
基本数据类型的值: 123

这些输出表明 Integer 对象 intObj 已经被成功创建，并且它的值可以通过 intValue() 方法被转换回基本数据类型 int。这种转换是常见的，因为虽然 Java 中的数学运算通常在基本数据类型上执行，但有时候我们需要将字符串解析为数字，或者需要使用对象的方法和属性。

Double类

public class DoubleExample {
    public static void main(String[] args) {
        Double doubleObj = Double.valueOf("45.67");
        System.out.println("双精度浮点对象的值: " + doubleObj);
        
        double doubleValue = doubleObj.doubleValue();
        System.out.println("基本数据类型的值: " + doubleValue);
    }
}

代码解析：

  针对如上示例代码，这里我给大家详细的代码剖析下，以便于帮助大家理解的更为透彻，帮助大家早日掌握。

这段 Java 代码展示了如何使用 Double 类来创建一个 Double 对象，并如何将该对象转换回基本数据类型 double。

代码解释如下：

1. DoubleExample 类定义了一个 main 方法，这是 Java 程序的入口点。

2. 在 main 方法中，首先使用 Double.valueOf() 方法创建了一个 Double 对象 doubleObj。这个方法接受一个字符串参数，并尝试将其解析为 double 值，然后返回一个包含该值的 Double 对象。在这个例子中，字符串 "45.67" 被解析并用于创建 doubleObj 对象。

3. 接着，代码使用 System.out.println 方法打印出 doubleObj 对象的值。由于 doubleObj 是一个对象，所以打印的是对象的字符串表示形式，即 45.67。

4. 然后，代码调用 doubleObj 的 doubleValue() 方法，这个方法返回 Double 对象中封装的 double 值，并将其赋值给基本数据类型 double 的变量 doubleValue。

5. 最后，代码再次使用 System.out.println 方法打印出 doubleValue 的值。这次打印的是基本数据类型 double 的值，也是 45.67。

当这段代码被编译和运行时，它将输出以下结果：

双精度浮点对象的值: 45.67
基本数据类型的值: 45.67

这些输出表明 Double 对象 doubleObj 已经被成功创建，并且它的值可以通过 doubleValue() 方法被转换回基本数据类型 double。这种转换是常见的，因为虽然 Java 中的数学运算通常在基本数据类型上执行，但有时候我们需要将字符串解析为数字，或者需要使用对象的方法和属性。

测试用例

基本类型转换测试

public class TypeConversionTest {
    public static void main(String[] args) {
        // 测试隐式转换
        int intValue = 50;
        long longValue = intValue;
        System.out.println("隐式转换后的 longValue: " + longValue);

        // 测试显式转换
        double doubleValue = 12.34;
        int intValue2 = (int) doubleValue;
        System.out.println("显式转换后的 intValue2: " + intValue2);
    }
}

代码解析：

  针对如上示例代码，这里我给大家详细的代码剖析下，以便于帮助大家理解的更为透彻，帮助大家早日掌握。

这段 Java 代码演示了两种类型转换：隐式转换和显式转换。

1. 隐式转换：也称为自动类型转换，发生在不同数据类型之间的赋值操作中，当一个较小的数据类型（数值范围较小）的变量赋值给一个较大数据类型（数值范围较大）的变量时。在这段代码中，intValue 是一个 int 类型的变量，它被赋值给了一个 long 类型的变量 longValue。因为 long 类型的数值范围比 int 类型大，所以这个转换是安全的，不需要显式地进行类型转换。程序输出 longValue 的值，它将显示为 50，因为 intValue 的值被自动提升为 long 类型。

2. 显式转换：也称为强制类型转换，发生在将一个较大数据类型的变量赋值给一个较小数据类型的变量时。在这段代码中，doubleValue 是一个 double 类型的变量，它被强制转换为 int 类型的变量 intValue2。由于 double 类型的数值范围比 int 类型大，直接赋值会导致精度丢失，因此需要在类型前加上括号进行显式转换。在这个例子中，doubleValue 的小数部分将被截断，只保留整数部分，因此 intValue2 的值将为 12。

当这段代码被编译和运行时，它将输出以下结果：

隐式转换后的 longValue: 50
显式转换后的 intValue2: 12

这些输出表明隐式转换和显式转换都已成功执行，并且变量的值被正确地转换和打印出来了。需要注意的是，显式转换可能会导致数据丢失或不精确，因此在进行转换时要特别小心。

包装类测试

public class WrapperTest {
    public static void main(String[] args) {
        // 测试 Integer 包装类
        Integer intObj = Integer.valueOf(123);
        System.out.println("Integer 对象的值: " + intObj);

        // 测试 Double 包装类
        Double doubleObj = Double.valueOf(45.67);
        System.out.println("Double 对象的值: " + doubleObj);
    }
}

测试结果预期

• TypeConversionTest 输出应包含隐式转换后的 longValue 和显式转换后的 intValue2。
• WrapperTest 输出应显示 Integer 和 Double 对象的值。

测试代码分析

针对如上示例代码，这里我给大家详细的代码剖析下，以便于帮助大家理解的更为透彻，帮助大家早日掌握。

这段 Java 代码是一个简单的示例，用于演示如何使用包装类 Integer 和 Double 来创建对象并打印它们的值。

代码解释如下：

1. WrapperTest 类定义了一个 main 方法，这是 Java 程序的入口点。

2. 在 main 方法中，首先创建了一个 Integer 类型的对象 intObj，并通过 Integer.valueOf(123) 方法将其初始化为整数 123。Integer.valueOf() 方法是一个静态方法，它接受一个整数参数，并返回一个代表该整数的 Integer 对象。

3. 接着，代码打印出 intObj 对象的值，使用 System.out.println 方法将信息输出到控制台。

4. 然后，代码创建了一个 Double 类型的对象 doubleObj，并通过 Double.valueOf(45.67) 方法将其初始化为双精度浮点数 45.67。Double.valueOf() 方法的工作原理与 Integer.valueOf() 类似，但它是用于创建 Double 对象的。

5. 最后，代码打印出 doubleObj 对象的值。

当这段代码被编译和运行时，它将输出以下结果：

Integer 对象的值: 123
Double 对象的值: 45.67

这些输出表明 intObj 和 doubleObj 对象已经被成功创建，并且它们的值被正确地打印出来了。在 Java 中，包装类用于将基本数据类型封装为对象，这在需要对象而不是原始类型的场景中非常有用，例如在需要使用集合类（如 ArrayList）存储基本类型值时。

小结

本文介绍了Java中的基本类型转换和包装类。我们详细讲解了基本类型转换的规则和应用，并探讨了包装类的功能和常用方法。通过代码示例和应用场景分析，帮助读者更好地理解这些概念。

总结

掌握基本类型转换和包装类对于Java编程至关重要。基本类型转换简化了不同数据类型之间的操作，而包装类则提供了将基本数据类型与对象操作之间的桥梁。理解并正确使用这些概念将提升您的Java编程技能，帮助您编写更加高效和灵活的代码。

寄语

学习编程的旅程是充满挑战的，但也是极具成就感的。希望这篇文章能为您的Java学习之路提供帮助。继续探索和实践，您将逐步掌握更多的编程技能，迎接更大的编程挑战。祝您编程愉快，学习进步！

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

… …

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。

⭐️若有疑问，就请评论留言告诉我叭。