Java包装类与异常处理的过程

更新时间：2026年04月07日 10:40:31 作者：辞忧要靠自己

本文介绍了Java中包装类和异常处理的概念,解析了它们的用途和使用方法,包装类主要用于将基本数据类型转换为对象,解决面向对象编程中的限制；异常处理机制则帮助程序优雅地处理运行时错误,包括常见异常类型、异常处理语句及自定义异常的使用

一、包装类：让基本数据类型 “对象化”

1. 什么是包装类？

Java 中的数据类型从本质上分为两类：

基本数据类型：byte, short, int, long, float, double, char, boolean。它们不是对象，在面向对象编程的某些场景（如集合操作）中会受到限制。
引用类型：通过 new 关键字创建的对象。

为了让基本数据类型也能以对象的形式存在，Java 提供了一组包装类，专门用来创建与 8 种基本数据类型对应的对象。

2. 基本数据类型与包装类的对应关系

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

这些包装类全部存放于 java.lang 包中，它们的继承关系如下：

一级父类：Object
二级父类：Character, Number, Boolean
Number 的子类：Byte, Short, Integer, Long, Float, Double

public class Test {
    public static void main(String[] args) {
        byte b = 1;
        Byte byt = new Byte(b);
        
        short s = 2;
        Short shor = new Short(s);
        
        int i = 3;
        Integer integer = new Integer(i);
        
        long l = 4;
        Long lon = new Long(l);
        
        float f = 5.5f;
        Float flo = new Float(f);
        
        double d = 6.6;
        Double dou = new Double(d);
        
        char cha = 'J';
        Character charac = new Character(cha);
        
        boolean bo = true;
        Boolean bool = new Boolean(bo);
    }
}

注意：从 Java 5 开始，引入了自动装箱（Autoboxing）功能，编译器会自动完成这个转换，例如 Integer i = 3;。

拆箱：包装类 → 基本数据类型

将包装类对象转换回对应的基本数据类型。

public class Test {
    public static void main(String[] args) {
        byte b = 1;
        Byte byt = new Byte(b);
        byte b1 = byt.byteValue();
        
        short s = 2;
        Short shor = new Short(s);
        short i1 = shor.shortValue();
        
        int i = 3;
        Integer integer = new Integer(i);
        int i2 = integer.intValue();
        
        long l = 4;
        Long lon = new Long(l);
        long l1 = lon.longValue();
        
        float f = 5.5f;
        Float flo = new Float(f);
        float v = flo.floatValue();
        
        double d = 6.6;
        Double dou = new Double(d);
        double v1 = dou.doubleValue();
        
        char cha = 'J';
        Character charac = new Character(cha);
        char c = charac.charValue();
        
        boolean bo = true;
        Boolean bool = new Boolean(bo);
        boolean b2 = bool.booleanValue();
    }
}

注意：同样，Java 5 也引入了自动拆箱（Unboxing）功能，例如 int i = new Integer(3);。

二、异常处理：让程序 “优雅” 地应对错误

1. 什么是异常？

Java 中的错误可以分为两大类：

编译时错误：一般指语法错误，编译器会在编译阶段就提示，无法生成 .class 文件。
运行时错误：语法没有问题，可以正常通过编译，但在运行时报错。

异常就是 Java 提供的一套机制，用来专门处理各种运行时错误。它会将具体的错误信息以及出错位置统一告知程序员，帮助我们快速定位和解决问题。

2. 常见的异常类型

Java 内置了丰富的异常类，以下是几个最常见的：

ArithmeticException：数学异常，如除数为零。

System.out.println(10 / 0); // 抛出此异常

ClassNotFoundException：类未定义异常，当尝试加载一个不存在的类时抛出。

System.out.println(Class.forName("Test2"));

IllegalArgumentException：参数格式异常，当传递了不合法或不恰当的参数时抛出。

public void test(Integer integer) {
    System.out.println(integer);
}
// 当通过反射调用此方法并传入字符串 "1" 时会抛出此异常

ArrayIndexOutOfBoundsException：数组下标越界异常。

int[] array = {1, 2, 3};
System.out.println(array[3]); // 数组长度为3，索引最大为2

NullPointerException：空指针异常，当调用一个 null 对象的方法或属性时抛出。

Integer num = null;
System.out.println(num.equals(1));

NoSuchMethodException：方法未定义异常，当尝试调用一个不存在的方法时抛出。
NumberFormatException：将其他数据类型转换为数值类型时的不匹配异常。

Integer integer = new Integer("a"); // 字符串 "a" 无法转换为整数

3. 异常的使用：try-catch-finally

Java 提供了 try-catch-finally 语句块来捕获和处理异常。

try：监听可能会抛出异常的代码。一旦出现错误，JDK 会自动创建一个错误对象（异常对象）。
catch：用来捕获 JDK 创建的异常对象，并进行后续的处理。
finally：无论程序是否抛出异常，finally 代码块中的程序一定会执行（try 代码块里），通常用于释放资源。

public class Test3 {
    public static void test3(String str) {
        Integer integer = null;
        try {
            integer = Integer.valueOf(str);
        } catch (Exception e) {
            // 打印异常信息
            System.out.println(e.getMessage());
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        System.out.println(test());
    }

    public static int test() {
        try {
            System.out.println("try");
            return 10;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("finally...");
            return 20;
        }
    }
}
// 输出:
// try
// finally...
// 20

注意：如果 try 或 catch 中有 return 语句，finally 块仍然会在方法返回前执行。如果 finally 中也有 return，则会覆盖 try 或 catch 中的返回值。

4.throw和throws：主动抛出异常

throw 和 throws 是 Java 在处理异常时使用的关键字，都用来抛出异常，但是使用方式和表示的含义完全不同。

throw：开发者主动创建一个异常对象并抛出，用于在代码逻辑中主动发现并报告错误。

public class Test {
    public static void main(String[] args) throws Exception {
        String str = "Java";
        if (str.equals("Java")) {
            // 主动创建并抛出一个 NumberFormatException
            throw new NumberFormatException();
        } else {
            int num = Integer.parseInt(str);
        }
    }
}

throws：标注在方法声明上，用来描述该方法可能会抛出的异常。它告诉调用者，调用此方法时需要处理这些可能的异常。

public class Test {
    public static void main(String[] args) throws Exception {
        try {
            test();
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
    }

    // 声明此方法可能会抛出 NumberFormatException
    public static void test() throws NumberFormatException {
        String str = "Java";
        int num = Integer.parseInt(str);
    }
}

5. 自定义异常

当内置的异常类无法满足业务需求时，我们可以创建自定义异常。自定义异常类需要继承自 Exception 类（或其子类）。

示例：定义一个方法，对传入的参数进行 ++ 操作并返回结果，同时要求参数传入的必须是整数类型，如果不是整数类型则抛出自定义异常。

// 1. 定义自定义异常类，继承 Exception
public class NumberException extends Exception {
    public NumberException(String message) {
        super(message);
    }
}

// 2. 使用自定义异常
public class Test {
    public static void main(String[] args) {
        Test test = new Test();
        try {
            int add = test.add("a"); // 传入字符串，不是整数
            System.out.println(add);
        } catch (NumberException e) {
            // 捕获并处理自定义异常
            e.printStackTrace();
        }
    }

    // 方法声明可能抛出 NumberException
    public int add(Object object) throws NumberException {
        if (!(object instanceof Integer)) {
            // 主动抛出自定义异常
            throw new NumberException("传入的参数不是整数类型");
        } else {
            int num = (int) object;
            return ++num;
        }
    }
}

总结

包装类是基本数据类型的对象表示，解决了基本数据类型在面向对象编程中的局限性。装箱和拆箱是它们之间转换的核心操作。
异常处理是 Java 提供的强大机制，通过 try-catch-finally、throw、throws 以及自定义异常，我们可以编写出更健壮、更易于调试的代码。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

SpringBoot中Mockito单元测试入门
单元测试在很多地方都用的到，本文主要介绍了SpringBoot中Mockito单元测试入门，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-06-06
关于Java Interface接口的简单练习题
这篇文章主要给大家分享的是关于Java Interface接口的简单练习题，难度不算大，但是要有一个清晰的逻辑建立接口和链接Java类。下面来看看文章的详细介绍吧,需要的朋友可以参考一下
2021-11-11
spring Boot 应用通过Docker 来实现构建、运行、发布流程
这篇文章主要介绍了spring Boot 应用通过Docker 来实现构建、运行、发布流程，图文详解，非常不错，具有参考借鉴价值，需要的朋友可以参考下
2017-11-11
Spring内存泄漏异常分析与解决详解
文章介绍了基于Spring框架的企业级应用开发中常见的内存泄漏问题,通过分析和使用jstack、Arthas、MAT、jmap等工具,定位内存泄漏的原因,并提供了优化缓存策略和排查无用引用的解决方案
2025-11-11
Java中对象与C++中对象的放置安排的对比
这篇文章主要介绍了Java中对象与C++中对象的放置安排的对比的相关资料,希望通过本文能帮助到大家，需要的朋友可以参考下
2017-09-09
Netty分布式ByteBuf使用的回收逻辑剖析
这篇文章主要介绍了Netty分布式ByteBuf使用的回收逻辑剖析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-03-03
Spring 注入静态对象使用三种方式示例
这篇文章主要为大家介绍了Spring注入静态对象使用的三种方式示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-07-07
Java数据结构之线段树中的懒操作详解
对于线段树，若要求对区间中的所有点都进行更新，可以引入懒操作。懒操作包括区间更新和区间查询操作。本文将通过一个示例和大家详细聊聊线段树中的懒操作，需要的可以参考一下
2022-10-10
Spring底层原理由浅入深探究
Spring事务有可能会提交，回滚、挂起、恢复，所以Spring事务提供了一种机制，可以让程序员来监听当前Spring事务所处于的状态，这篇文章主要介绍了Spring底层事务原理,需要的朋友可以参考下
2023-02-02
IDEA+GIT使用入门图文详解
这篇文章主要介绍了IDEA+GIT使用入门详解,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2020-11-11