51从零开始学Java之详解Java中的包装类

布满荆棘的人生 2024-03-17 16:20 99阅读 0赞

> **作者**：孙玉昌，昵称【**一一哥**】，另外【**壹壹哥**】也是我哦
> 
> 千锋教育高级教研员、CSDN博客专家、万粉博主、阿里云专家博主、掘金优质作者

## 前言 ##

在上一篇文章中，**壹哥**给大家介绍了Java中的Object类，它属于我们开发时的常用类。除此之外，还有另外的一些常用类，比如各种包装类。那么包装类又是怎么回事？有哪些类属于包装类？包装类的作用是干嘛的？包装类有哪些特性？接下来**壹哥**就给大家讲一讲这些包装类。

\-------------------------------------------------**前戏已做完，精彩即开始**\-----------------------------------------------

全文大约【**4500】**字，不说废话，只讲可以让你学到技术、明白原理的纯干货！本文带有丰富的案例及配图视频，让你更好地理解和运用文中的技术概念，并可以给你带来具有足够启迪的思考......

## 配套开源项目资料 ##

> **Github：**
> 
> [GitHub - SunLtd/LearnJava][GitHub - SunLtd_LearnJava]
> 
> **Gitee：**
> 
> [一一哥/从零开始学Java][Java]

## 一. 包装类 ##

### 1. 概念 ###

我们知道，Java中的数据类型**总体上分为基本数据类型和引用数据类型**。引用类型的数据可以通过对象操作的形式进行使用，也就是说，我们可以通过对象的属性和方法来进行操作。但如果是基本数据类型的数据，我们能不能像操作对象那样来操作呢？为了实现这个目标，Java为8种基本数据类型分别设计了对应的类，我们称其为**包装类(Wrapper Classes****)**，或者称其为**外覆类或数据类型类**。因为这些包装类都是引用类型，所以我们就可以方便地操作这些数据的属性和方法了。

其实**之所以为8种基本数据类型都设计出对应的包装类，从深层分析，主要是为了配合Java 5之后出现的泛型。****在泛型的使用中，基本数据类型和泛型不能配合使用，即Primitive Types 和Generic不能混用**。举个简单的例子，比如我们想使用ArrayList、HashMap等集合时，这些集合都需要指明集合中数据的泛型。而int、double等基本类型是不允许被使用的，因为这些集合容器的泛型都必须是Object类型，所以就需要这些包装类型了，如下图所示：

![7deaabaadde3513725fc7eb44e8c60fb.png][]

### 2. 8个包装类 ###

有了这8个包装类，我们就可以按照面向对象的思维来操作数据了，可以操作对象的属性和方法，也可以给对象赋null值，这是基本类型做不到的。我们来看看Java中的基本类型与其对应的包装类，如下表所示：

<table> 
 <tbody> 
 <tr> 
 <td> 基本类型 </td> 
 <td> 包装类型 </td> 
 </tr> 
 <tr> 
 <td> byte </td> 
 <td> Byte </td> 
 </tr> 
 <tr> 
 <td> short </td> 
 <td> Short </td> 
 </tr> 
 <tr> 
 <td> int </td> 
 <td> Integer </td> 
 </tr> 
 <tr> 
 <td> long </td> 
 <td> Long </td> 
 </tr> 
 <tr> 
 <td> float </td> 
 <td> Float </td> 
 </tr> 
 <tr> 
 <td> double </td> 
 <td> Double </td> 
 </tr> 
 <tr> 
 <td> char </td> 
 <td> Character </td> 
 </tr> 
 <tr> 
 <td> boolean </td> 
 <td> Boolean </td> 
 </tr> 
 </tbody> 
</table>

从上面的表中我们可以看出，基本上包装类的类名，就是把基本类型的首字母变成大写，除了Integer和Character特殊一点。另外，Byte、Short、Integer、Long、Float、Double这六个类，都是Number的子类，它们具有一些共同的类型转换方法，方便我们进行类型之间的转换。

## 二. 常用包装类 ##

为了让大家更好地掌握这些包装类的用法及特性，**壹哥**在这里只把几个常用的包装类给大家介绍一下。

### 1. Integer简介 ###

Integer类中包含了一个int类型的字段。该类提供了一些可以方便处理int类型的常量，比如获取整型的最大值和最小值等。另外该类还提供了多个方法，可以在 int类型和 String类型之间互相转换。

#### 1.1 Integer中的常量 ####

Integer类包含以下4个常量：

>  *  **MAX\_VALUE**：是一个常量值，值为 231-1，代表int类型能够表示的最大值；
>  *  **MIN\_VALUE**：是一个常量值，值为 -231，代表int类型能够表示的最小值；
>  *  **SIZE**：以二进制补码的形式，表示 int值的比特位数；
>  *  **TYPE**：代表基本类型 int 的 Class 实例对象。

#### 1.2 Integer中的方法 ####

Integer类中提供的常用方法如下表所示：

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 返回值 </td> 
 <td> 功能 </td> 
 </tr> 
 <tr> 
 <td> byteValue() </td> 
 <td> byte </td> 
 <td> 转换为byte类型 </td> 
 </tr> 
 <tr> 
 <td> shortValue() </td> 
 <td> short </td> 
 <td> 转换为short类型 </td> 
 </tr> 
 <tr> 
 <td> intValue() </td> 
 <td> int </td> 
 <td> 转换为int类型 </td> 
 </tr> 
 <tr> 
 <td> toString() </td> 
 <td> String </td> 
 <td> 转换为String类型 </td> 
 </tr> 
 <tr> 
 <td> equals(Object obj) </td> 
 <td> boolean </td> 
 <td> 比较此对象与指定对象是否相等 </td> 
 </tr> 
 <tr> 
 <td> compareTo(Integer anotherlnteger) </td> 
 <td> int </td> 
 <td> 比较两个 Integer对象的数值大小，如相等，则返回 0； 如调用对象的数值小于 anotherlnteger，则返回负值； 如调用对象的数值大于 anotherlnteger，则返回正值 </td> 
 </tr> 
 <tr> 
 <td> valueOf(String s) </td> 
 <td> Integer </td> 
 <td> 将String类型的数值转为 Integer对象 </td> 
 </tr> 
 <tr> 
 <td> parseInt(String s) </td> 
 <td> int </td> 
 <td> 将String字符串转为 int 数值 </td> 
 </tr> 
 </tbody> 
</table>

我们要注意，在将字符串转换为 int类型数值的过程中，如果字符串为非数值型的内容，转换时可能会出现NumberFormatException异常。

### 2. Byte简介 ###

Byte类中内含了一个byte类型的字段，该类提供了一些可以方便处理byte值的常量和方法，方便了我们的操作。

#### 2.1 Byte中的常量 ####

**Byte类中提供的常量如下：**

>  *  **MIN\_VALUE**：byte类的最小值，-128；
>  *  **MAX\_VALUE**：byte类的最大值，127；
>  *  **SIZE**：以二进制补码形式表示的 byte值位数；
>  *  **TYPE**：表示byte的Class实例对象。

#### 2.2 Byte中的方法 ####

Byte类中的常用方法如下：

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 返回值 </td> 
 <td> 功能 </td> 
 </tr> 
 <tr> 
 <td> byteValue() </td> 
 <td> byte </td> 
 <td> 转换为byte类型 </td> 
 </tr> 
 <tr> 
 <td> compareTo(Byte bytel) </td> 
 <td> int </td> 
 <td> 比较两个byte值的大小 </td> 
 </tr> 
 <tr> 
 <td> doubleValue() </td> 
 <td> double </td> 
 <td> 转换为double类型 </td> 
 </tr> 
 <tr> 
 <td> intValue() </td> 
 <td> int </td> 
 <td> 转换为int类型 </td> 
 </tr> 
 <tr> 
 <td> parseByte(String s) </td> 
 <td> byte </td> 
 <td> 将String类型值转为Byte类型 </td> 
 </tr> 
 <tr> 
 <td> toStringO </td> 
 <td> String </td> 
 <td> 将 byte值转为String字符串 </td> 
 </tr> 
 <tr> 
 <td> valueOf(String s) </td> 
 <td> Byte </td> 
 <td> 将String字符串转为Byte对象 </td> 
 </tr> 
 <tr> 
 <td> equals(Object obj) </td> 
 <td> boolean </td> 
 <td> 比较两个对象是否相等，如果调用该方法的对象与obj相等则返回 true，否则返回false </td> 
 </tr> 
 </tbody> 
</table>

### 3. Float简介 ###

Float类中内含了一个float类型的字段，该类提供了一些可以方便处理float值的常量和方法，方便了我们的操作。

#### 3.1 Float中的常量 ####

Float类的常量值如下所示：

>  *  **MAX\_VALUE**：表示float的最大值，为 1.4E38；
>  *  **MIN\_VALUE**：表示float的最小值，为3.4E-45；
>  *  **MAX\_EXPONENT**：float变量可能具有的最大指数；
>  *  **MIN\_EXPONENT：float**变量可能具有的最小指数；
>  *  **MIN\_NORMAL**：保存float类型值的最小标准值常量，即 2-126；
>  *  **NaN**：保存float类型的非数值常量；
>  *  **SIZE**：以二进制补码形式表示的float值的比特位数；
>  *  **TYPE**：表示float类型的Class对象实例。

#### 3.2 Float中的方法 ####

Float类中的常用的方法如下表所示：

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 返回值 </td> 
 <td> 功能 </td> 
 </tr> 
 <tr> 
 <td> byteValue() </td> 
 <td> byte </td> 
 <td> 转为byte类型 </td> 
 </tr> 
 <tr> 
 <td> doubleValue() </td> 
 <td> double </td> 
 <td> 转为double类型 </td> 
 </tr> 
 <tr> 
 <td> floatValue() </td> 
 <td> float </td> 
 <td> 转为float类型 </td> 
 </tr> 
 <tr> 
 <td> intValue() </td> 
 <td> int </td> 
 <td> 强制转换为int类型 </td> 
 </tr> 
 <tr> 
 <td> longValue() </td> 
 <td> long </td> 
 <td> 强制转换为long类型 </td> 
 </tr> 
 <tr> 
 <td> shortValue() </td> 
 <td> short </td> 
 <td> 强制转换为short类型 </td> 
 </tr> 
 <tr> 
 <td> isNaN() </td> 
 <td> boolean </td> 
 <td> 判断该值是否为非数字值，如果是则返回true，否则返回false </td> 
 </tr> 
 <tr> 
 <td> isNaN(float v) </td> 
 <td> boolean </td> 
 <td> 如果指定的参数是一个非数字值，则返回 true，否则返回 false </td> 
 </tr> 
 <tr> 
 <td> toString() </td> 
 <td> String </td> 
 <td> 将Float值转为 String对象 </td> 
 </tr> 
 <tr> 
 <td> valueOf(String s) </td> 
 <td> Float </td> 
 <td> 将String转为Float对象 </td> 
 </tr> 
 <tr> 
 <td> parseFloat(String s) </td> 
 <td> float </td> 
 <td> 将String转为float数值 </td> 
 </tr> 
 </tbody> 
</table>

### 4. Double简介 ###

Double类中内含了一个double类型的字段，该类提供了一些可以方便处理double值的常量和方法，方便了我们的操作。

#### 4.1 Double中的常量 ####

Double类中的常量如下所示：

>  *  **MAX\_VALUE**：表示double类型的最大值，1.8E308；
>  *  **MIN\_VALUE**：表示double类型的最小值，4.9E-324；
>  *  **NaN**：表示double类型的非数字值；
>  *  **NEGATIVE\_INFINITY**：表示double类型负无穷大的常量值；
>  *  **POSITIVE\_INFINITY**：表示double类型正无穷大的常量值；
>  *  **SIZE**：以二进制补码形式表示的double值的比特位数；
>  *  **TYPE**：表示double类型的Class实例对象。

#### 4.2 Double中的方法 ####

Double类中的常用方法如下表所示：

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 返回值 </td> 
 <td> 功能 </td> 
 </tr> 
 <tr> 
 <td> byteValue() </td> 
 <td> byte </td> 
 <td> 转为byte类型 </td> 
 </tr> 
 <tr> 
 <td> doubleValue() </td> 
 <td> double </td> 
 <td> 转为double类型 </td> 
 </tr> 
 <tr> 
 <td> fioatValue() </td> 
 <td> float </td> 
 <td> 转为float类型 </td> 
 </tr> 
 <tr> 
 <td> intValue() </td> 
 <td> int </td> 
 <td> 强制转换为int类型 </td> 
 </tr> 
 <tr> 
 <td> longValue() </td> 
 <td> long </td> 
 <td> 强制转换为long类型 </td> 
 </tr> 
 <tr> 
 <td> shortValue() </td> 
 <td> short </td> 
 <td> 强制转换为short类型 </td> 
 </tr> 
 <tr> 
 <td> isNaN() </td> 
 <td> boolean </td> 
 <td> 如果该值是一个非数字值则返回true，否则返回false </td> 
 </tr> 
 <tr> 
 <td> isNaN(double v) </td> 
 <td> boolean </td> 
 <td> 如果指定的参数是一个非数字值则返回 true，否则返回 false </td> 
 </tr> 
 <tr> 
 <td> toString() </td> 
 <td> String </td> 
 <td> 将Double值转为String字符串 </td> 
 </tr> 
 <tr> 
 <td> valueOf(String s) </td> 
 <td> Double </td> 
 <td> 将String值转为Double对象 </td> 
 </tr> 
 <tr> 
 <td> parseDouble(String s) </td> 
 <td> double </td> 
 <td> 将数字字符串转换为Double值 </td> 
 </tr> 
 </tbody> 
</table>

### 5. Character简介 ###

Character类用于对单个字符进行操作，内含了一个char类型的字段，该类提供了一些可以方便处理char值的方法，方便了我们的操作。

#### 5.1 Character中的方法 ####

Character类中的常用方法如下表所示：

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 描述 </td> 
 </tr> 
 <tr> 
 <td> void Character(char value) </td> 
 <td> 构造一个新的Character对象，表示指定的char值 </td> 
 </tr> 
 <tr> 
 <td> char charValue() </td> 
 <td> 返回该Character对象的值 </td> 
 </tr> 
 <tr> 
 <td> int compareTo(Character anotherCharacter) </td> 
 <td> 比较两个Character对象的大小 </td> 
 </tr> 
 <tr> 
 <td> boolean equals(Character anotherCharacter) </td> 
 <td> 将该对象与指定对象比较，当且仅当参数不是null，且此对象 与该Character对象相同时，结果为true </td> 
 </tr> 
 <tr> 
 <td> boolean isDigit(char ch) </td> 
 <td> 判断指定字符是否为数字 </td> 
 </tr> 
 <tr> 
 <td> boolean isLetter(int codePoint) </td> 
 <td> 判断指定的字符是否为字母 </td> 
 </tr> 
 <tr> 
 <td> boolean isLetterOrDigit(int codePoint) </td> 
 <td> 判断指定的字符是否为字母或数字 </td> 
 </tr> 
 <tr> 
 <td> boolean isLowerCase(char ch) </td> 
 <td> 判断指定的字符是否为小写字母 </td> 
 </tr> 
 <tr> 
 <td> boolean isUpperCase(char ch) </td> 
 <td> 判断指定的字符是否为大写字母 </td> 
 </tr> 
 <tr> 
 <td> char toLowerCase(char ch) </td> 
 <td> 将指定的字符参数转为小写 </td> 
 </tr> 
 <tr> 
 <td> char toUpperCase(char ch) </td> 
 <td> 将指定的字符参数转为大写 </td> 
 </tr> 
 </tbody> 
</table>

#### 5.2 代码案例 ####

Character类的方法比较多，**壹哥**给大家设计了如下代码案例进行演示：

/**
 * @author 一一哥Sun
 */
 public class CharacterTest {
 	public static void main(String[] args) {
 		//构造一个Character对象，该方式已过时
 		Character character = new Character('A');
 		
 		//比较两个对象是否相同，0表示相同；正数表示前者大于后者；负数表示前者小于后者
 		int result = character.compareTo(new Character('B'));
 		System.out.println(result); // 输出 -1，表示A小于B
 		
 		//获取Character对象的第2种方式,注意参数必须是单引号括起来的字符型，
 		Character char02 = Character.valueOf('B');
 		
 		//获取Character对象的第3种方式,常用该方式
 		Character char03='C';
 		
 		//将大写字符转为小写字符
 		char lowerCase = Character.toLowerCase('Y');
 		System.out.println("lowerCase="+lowerCase); 
 		
 		String str="hello666";
 		for(int i=0;i<str.length();i++) {
 			//判断每一个字符是否是字母
 			boolean isLetter = Character.isLetter(str.charAt(i));
 			System.out.println(str.charAt(i)+", 是字母吗?="+isLetter); 
 		}
 	}
 }

### 6. Boolean简介 ###

Boolean类中内含了一个boolean类型的字段，该类提供了一些可以方便处理boolean值的常量和方法，方便了我们的操作。

#### 6.1 Boolean中的常量 ####

Boolean类包含的常量如下所示：

>  *  **TRUE**：代表值为true的常量；
>  *  **FALSE**：代表值为false的常量；
>  *  **TYPE**：表示boolean类型的Class实例对象。

#### 6.2 Boolean中的方法 ####

Boolean类中常用的方法如下表所示：

<table> 
 <tbody> 
 <tr> 
 <td> 方法 </td> 
 <td> 返回值 </td> 
 <td> 功能 </td> 
 </tr> 
 <tr> 
 <td> booleanValue() </td> 
 <td> boolean </td> 
 <td> 转为boolean类型 </td> 
 </tr> 
 <tr> 
 <td> equals(Object obj) </td> 
 <td> boolean </td> 
 <td> 判断调用该方法的对象与obj是否相等。当参数不是null，且与调用该方法的对象相同时则返回true </td> 
 </tr> 
 <tr> 
 <td> parseBoolean(String s) </td> 
 <td> boolean </td> 
 <td> 将String字符串参数转为 boolean值 </td> 
 </tr> 
 <tr> 
 <td> toString() </td> 
 <td> String </td> 
 <td> 返回表示该boolean值的String字符串 </td> 
 </tr> 
 <tr> 
 <td> valueOf(String s) </td> 
 <td> boolean </td> 
 <td> 将指定的字符串转为boolean值 </td> 
 </tr> 
 </tbody> 
</table>

### 7. 基本用法 ###

现在我们已经知道有哪些包装类了，那么这些包装类怎么用呢？接下来我们就通过一些代码，来学习常用的包装类吧。

#### 7.1 Integer的用法 ####

我们先通过一段代码，来了解一下Integer的用法，因为在实际开发中，Integer是比较常用的包装类。

/**
     * @author 一一哥Sun
     */
    public class WrapperTest {
    	public static void main(String[] args) {
    		//Integer变量的几种定义方式
    		Integer i001 = new Integer(50);
    		
            Integer i002=new Integer("100");
    		//注意：将字符串转为数值型时，也要注意待转换的类型必须匹配，我们不能将非数字的字符串转为数值型，否则会出现NumberFormatException
    		//Integer i007=new Integer("hello");
    		
            Integer i003 = 100;
    		
            //利用静态方法，返回一个指定int值的Integer对象
    		Integer i004=Integer.valueOf(200);
    		
            //利用静态方法，返回指定String值的Integer对象
    		Integer i005=Integer.valueOf("300");
    		
            //第2个参数radix，表示基数，即当前采用的进制
    		Integer i006=Integer.valueOf("400",16);
    		System.out.println("i006="+i006);
    		
    		//获取Integer的最大值与最小值
    		System.out.println(Integer.MAX_VALUE);
    		System.out.println(Integer.MIN_VALUE);
    	}
    }

valueOf()方法是一个静态方法，用于返回给定参数的原生Number对象，其参数可以是原生数据类型和String等。如果该方法带有两个参数，那么第一个是字符串，第二个则是基数，用于表明要转换成的进制。

#### 7.2 Double的用法 ####

接下来我们再来看看Double的用法。

/**
     * @author 一一哥Sun
     */
    public class WrapperTest {
    	public static void main(String[] args) {	
    		//Double类型的用法
    		//将数值型或字符串类型转为Double类型
    		Double d001 = new Double(100.1);
    		Double d002 = new Double("200.2");
    		//Double d007 = new Double("hello");
    		Double d003 = 300.3;
    		Double d004 =Double.valueOf(400.4);
    		//通过doubleValue()方法取double值
    		System.out.println("d004="+d004.doubleValue());
    		
    		Double d005 =Double.valueOf("500.5");
    		//直接使用
    		System.out.println("d005="+d005);
    
            //获取最大值和最小值
    		System.out.println(Double.MAX_VALUE);
    		System.out.println(Double.MIN_VALUE);
    	}
    }

#### 7.3 字符串转包装类 ####

有了包装类，我们就可以将字符串类型的数值转换成Integer或者是Double等类型。在下面的案例中，我们可以利用包装类提供的各个parseXXX()方法，来将字符串转为对应的包装类型。

/**
     * @author 一一哥Sun
     */
    public class WrapperTest {
    	public static void main(String[] args) {
    		//字符串转Integer或Double类型
    		String s1 = "123";
    		//方式1：
    		int i007 = Integer.parseInt(s1);
    		System.out.println("i007="+i007);
    		//方式2：
    		int i008 = Integer.valueOf(s1);
    		System.out.println("i008="+i008);
    
    		String s2 = "20.5";
    		//方式1：
    		double d006 = Double.parseDouble(s2);
    		System.out.println("d006="+d006);
    		//方式2：
    		double d007 = Double.valueOf(s2);
    		System.out.println("d007="+d007);
    
    		//java.lang.NumberFormatException,数字格式化异常
    		//String s3 = "hello";
    		String s3 = null;
    		System.out.println(Integer.parseInt(s3));
    	}
    }

在以上代码中，除了有`Integer.parseInt()、Double.parseDouble()方法之外，还有Float.parseFloat()、Byte.parseByte()、Short.parseShort()、Boolean.parseBoolean()`*等方法可以将字符串转为对应的包装类。*

但是我们要注意，在将字符串转为Integer或Double等类型时，并不是所有的字符串内容都可以转换成功，有可能会出现NumberFormatException异常，如下所示：

`Exception in thread "main" java.lang.NumberFormatException: For input string: "hello"`

![756e9f6a766ead0949a49938cf3c9466.png][]

#### 7.4 类型间转换 ####

Byte、Short、Integer、Long、Float、Double这六个类，有一个共同的父类Number。其中，Number提供了一组xxxValue()方法，可以用于将某种类型转换成其他的类型，案例如下：

/**
     * @author 一一哥Sun
     */
    public class WrapperTest {
    	@SuppressWarnings("null")
    	public static void main(String[] args) {
    		//类型间转换
    		Integer a = 100;
    		
            //将Integer转为Byte类型
    		Byte b = a.byteValue();
    		
            //将Integer转为Short类型
    		Short c = a.shortValue();
    		
            //将Integer转为Long类型
    		Long d = a.longValue();
    		
            //将Integer转为Float类型
    		Float e = a.floatValue();
    		
            //将Integer转为Double类型
    		Double f = a.doubleValue();
    		
            //取出数值的整数部分，将Integer转为int
    		int g = a.intValue();
    		System.out.println("a="+a+",b="+b+",c="+c+",d="+d+",e="+e+",f="+f+",g="+g);
    
            //包装类转字符串，默认是按照10进制进行转换
    		String intStr = Integer.toString(1000);
    		String dobuleStr = Double.toString(200.5);
    		Byte by=126;
    		String byteStr=Byte.toString(by);
    
            //将数字转换成二进制
            String str1 = Integer.toBinaryString(num); 
            // 将数字转换成八进制
            String str2 = Integer.toHexString(num); 
            // 将数字转换成十六进制
            String str3 = Integer.toOctalString(num); 
    	}
    }

每种包装类之间，都可以使用这些方法进行类型的转换。另外每种包装类都提供了对应的`toString()`或`toBinaryString()/toHexString()/toOctalString()`方法，可以将该包装类转为十进制、二进制、八进制和十六进制的String字符串，比如`Integer.toString()、Double.toString()`等，这里**壹哥**就不再一一赘述了。

\------------------------------------------------**正片已结束，来根事后烟**\----------------------------------------------

## 三. 结语 ##

至此，**壹哥**就把Java中的常用包装类给大家介绍完毕了，现在你知道包装类和基本类型有什么联系和区别了吗？本文重点总结如下：

>  *  Java提供的包装类可以把基本类型包装为class，从而可以通过面向对象的方式操作基本类型；
>  *  整数和浮点数的包装类都继承自Number类；
>  *  包装类提供了大量的实用方法和常量。

另外如果你独自学习觉得有很多困难，可以加入**壹哥**的学习互助群，大家一起交流学习。

## 四. 今日作业 ##

利用Scanner类，从命令行中读入一个字符串，用两种不同的方法，把该字符串转换成一个int类型。

> 方法一：把String直接转换为int；
> 
> 方法二：把String转换为Integer，再把Integer转换为int类型。

[GitHub - SunLtd_LearnJava]: https://github.com/SunLtd/LearnJava
[Java]: https://gitee.com/sunyiyi/LearnJava
[7deaabaadde3513725fc7eb44e8c60fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/80e2358d77474770883d5387cf671530.png
[756e9f6a766ead0949a49938cf3c9466.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/ae2728608c39494c9c303533fbbf8c72.png