Java 从入门到进阶之路（十九）

在之前的文章我们介绍了一下 Java 中的Object，本章我们来看一下 Java 中的包装类。

在 Java 中有八个基本类型：byte,short,int,long,float,double,char,boolean，是以值的形式存在的，所以他们并没有面向对象的特征，自然也不继承自 Object，所以不能使用多台，用 Object 的角度去接受基本类型。

假设现在我们有一个计算 1+1 的值，代码如下：

 1 public class Main {
 2     public static void main(String[] args) {
 3         int i = 1 + 1;
 4         System.out.println(i); // 2
 5
 6         Integer integer1 = new Integer(1);
 7         Integer integer2 = new Integer(1);
 8         int integer = integer1.intValue() + integer2.intValue();
 9         System.out.println(integer); // 2
10
11
12     }
13 }
14
15 class Integer {
16     private int i;
17
18     public Integer(int i) {
19         this.i = i;
20     }
21
22     public int intValue() {
23         return i;
24     }
25 }

在上面的代码中，如果我们想要计算出 1+1 的值，按照之前所学的我们直接利用 int 类型数据 1+1 即可获取，但是我们在上面说了基本类型并不具备面向对象特征，那我们在某些情况下又需要怎么办呢，这就是上面代码中我们自己所写的 integer 类，但是如果我们仅仅是为了计算一个 1+1 ，每次都需要实例化一些 Integer 又太小题大做了。

所以 Java 就很贴心的为八个基本类型封装了一下，并且内置在了 lang 包内，即包装类，所以我们的代码如下也是可以正常运行的：

 1 public class Main {
 2     public static void main(String[] args) {
 3         int i = 1 + 1;
 4         System.out.println(i); // 2
 5
 6         Integer integer1 = new Integer(1);
 7         Integer integer2 = new Integer(1);
 8         int integer = integer1.intValue() + integer2.intValue();
 9         System.out.println(integer); // 2
10     }
11 }

包装类是不可变类，在构造了包装类对象后，不允许更改包装在其中的值，包装类是 final 的，不能定义他们的子类。

在上面的图片中，我们可以看出，数字类型的包装类继承自 Number，char 和 boolean 类型的包装类继承自 Object，接下来我们就举例看一下，如下代码：

 1 /**
 2  * 数字类型的包装类继承自 Number
 3  * 其提供了入：intValue，doubleValue 这样的方法，
 4  * 其作用是将当前包装类表示的数字以其他数字类型的形式返回
 5  * */
 6 public class Main {
 7     public static void main(String[] args) {
 8         /**
 9          * 将基本类型转换成包装类有两种方法：
10          * 1、调用构造方法
11          * 2、调用静态方法 valueOf(推荐)
12          * */
13         Integer integer1 = new Integer(1);
14         Integer integer2 = new Integer(1);
15         System.out.println(integer1 == integer2); // false
16         System.out.println(integer1.equals(integer2)); // true
17
18         Integer integer3 = Integer.valueOf(1);
19         Integer integer4 = Integer.valueOf(1);
20         System.out.println(integer3 == integer4); // true
21         System.out.println(integer3.equals(integer4)); // true
22
23         Integer integer5 = Integer.valueOf(128);
24         Integer integer6 = Integer.valueOf(128);
25         System.out.println(integer5 == integer6); // false
26         System.out.println(integer5.equals(integer6)); // true
27     }
28 }

在上面的代码中，我们先使用实例化的方法，结果跟之前文章所讲的 equals 方法时所得的结果一样，当我们使用 valueOf() 方法时，发现 == 也变为了 true，这是因为 valueOf 会重用对象，并不会重新分配地址，但是仅限于 -128 -- 127 之间的整数。一旦超过会去 new 一个新对象。相比较而言，在 -128 -- 127 之间时，valueOf 会帮我们节省一部分内存空间，所以推荐使用 valueOf。

当然包装类也为我们提供了转为基本类型的方法，如下：

 1 public class Main {
 2     public static void main(String[] args) {
 3         Integer integer = Integer.valueOf(128);
 4
 5         int int1 = integer.intValue();
 6         System.out.println(int1); // 128
 7
 8         float float1 = integer.floatValue();
 9         System.out.println(float1); // 128.0
10
11         // byte 类型为 -128 -- 127，超出会重新计算
12         byte byte1 = integer.byteValue();
13         System.out.println(byte1); // -128
14     }
15 }

那我们怎么知道各个基本类型的最大值和最小值呢？包装类其实已经很贴心的为我们提供了方法，如下：

 1 /**
 2  * 数字类型包装类都支持两个常量
 3  * MAX_VALUE , MIN_VALUE
 4  * 分别保存了对应基本类型的最大值和最小值
 5  * */
 6 public class Main {
 7     public static void main(String[] args) {
 8         int intMax = Integer.MAX_VALUE;
 9         int intMin = Integer.MIN_VALUE;
10         System.out.println(intMax); // 2147483647
11         System.out.println(intMin); // -2147483648
12
13         byte byteMax = Byte.MAX_VALUE;
14         byte byteMin = Byte.MIN_VALUE;
15         System.out.println(byteMax); // 127
16         System.out.println(byteMin); // -128
17     }
18 }

通过上面的代码我们了解了包装类的一些基本特征和使用方法，那我们使用包装类的常用方法时什么呢？如下：

 1 /**
 2  * 包装类提供了一个静态方法 parseXXX(String str)
 3  * 可以将给定的字符串转换为对应的基本类型
 4  * 前提是该字符串必须正确的描述基本类型可以保存的值
 5  */
 6 public class Main {
 7     public static void main(String[] args) {
 8         String str = "123";
 9         int i = Integer.parseInt(str);
10         System.out.println(i); // 123
11
12         double d = Double.parseDouble(str);
13         System.out.println(d); // 123.0
14
15         float f = Float.parseFloat(str);
16         System.out.println(f); // 123.0
17
18         String str1 = "123.123";
19         int i1 = Integer.parseInt(str1);
20         System.out.println(i1); // 编译错误，Integer 并不能识别小数位
21
22         double d1 = Double.parseDouble(str1);
23         System.out.println(d1); // 123.123
24     }
25 }

在上面的代码中，我们分别定义了 "123" 和 "123.123" 两个字符串，从上面的输出结果可以看出，只有字符串能正确额描述基本类型可以保存的值才能运行成功。

接下来我们再来看一个包装类的自动拆装箱

 1 /**
 2  * JDK1.5 以后推出的新特性
 3  * 自动拆装箱
 4  */
 5 public class Main {
 6     public static void main(String[] args) {
 7         /**
 8          * 自动拆装箱是编译器认可，而不是虚拟机认可
 9          * 编译器在将源程序编译时自动补充代码来完成基本类型与包装类的转换
10          * */
11         int i = new Integer(1); // 编译器会默认在后面加 .intValue()
12         Integer ii = 123; // 编译器会默认变为 Integer.valueOf(123)
13     }
14 }

在上面的代码中，我们可以看到 int 类型可以直接接受一个是实例化的包装类，包装类也可以直接接受一个基本类型的值，这就是自动拆装箱，避免了我们在编写程序时的转换，减少了代码量。

原文地址：https://www.cnblogs.com/weijiutao/p/12017226.html

时间： 2024-10-08 05:54:03

Java 从入门到进阶之路（十九）的相关文章

Java 从入门到进阶之路（十四）

在之前的文章我们介绍了一下 Java 中的抽象类和抽象方法,本章我们来看一下 Java 中的接口. 在日常生活中,我们会接触到很多类似接口的问题,比如 USB 接口,我们在电脑上插鼠标,键盘,U盘的时候不用去考虑它到底能不能插进去,只要型号对了就肯定能插进去,接口就相当于一个标准,你要想把鼠标插到我的电脑上,在出厂时就必须遵守该电脑定义的接口标准. 在 Java 中同样有接口的概念,当然也会有接口的定义标准. 1.有 interface 定义: 2.只能包含常量和抽象方法: 3.接口不能被实例化

Java 从入门到进阶之路（十五）

在之前的文章我们介绍了一下 Java 中的接口,本章我们来看一下 Java 中类的多态. 在日常生活中,很多意思并不是我们想要的意思,如下: 1.领导:“你这是什么意思?” 小明:“没什么意思,意思意思.” 领导:“你这就不够意思了.” 小明:“小意思,小意思.” 领导:“你这人真有意思.” 小明:“其实也没有别的意思.” 领导:“那我就不好意思了.” 小明:“是我不好意思.” 2.电视剧<快把我哥带走> 妹:“你根本就不懂我.” 哥:“你不说我怎么懂你啊,” 妹:“真的懂不需要说出来,” 哥

Java 从入门到进阶之路（十八）

在之前的文章我们介绍了一下 Java 中的正则表达式,本章我们来看一下 Java 中的 Object. 在日常生活中,任何事物我们都可以看做是一个对象,在编程中是同样的道理,在 Java 编程中其实更突出,因为 Java 就是一门面向对象的编程语言. 我们先来看下面的代码: 1 public class Main { 2 public static void main(String[] args) { 3 Person person = new Person(); 4 // person.age

Java 从入门到进阶之路（三）

之前的文章我们介绍了 Java 中的变量和基本数据类型,本章我们来看一下 Java 的运算符和表达式. 计算机的最基本用途之一就是执行数学运算,作为一门计算机语言,Java也提供了一套丰富的运算符来操纵变量.我们可以把运算符分成以下几组: 算术运算符 关系运算符 位运算符 逻辑运算符 赋值运算符 其他运算符 算术运算符 算术运算符用在数学表达式中,它们的作用和在数学中的作用一样.下表列出了所有的算术运算符. 表格中的实例假设整数变量A的值为10,变量B的值为20: 操作符 描述 例子 + 加法

Java 从入门到进阶之路（四）

之前的文章我们介绍了 Java 的运算符和表达式,本章我们来看一下 Java 的循环结构. 循环是程序设计语言中反复执行某些代码的一种计算机处理过程,是一组相同或相似语句被有规律的重复性进行. 循环的要素: - 循环变量的初始化 - 循环条件(以循环变量为基础) - 循环变量的改变(向着循环的结束进行改变) Java中有三种主要的循环结构: while 循环 do…while 循环 for 循环 while 循环 while是最基本的循环,它的结构为: while(布尔表达式){ //循环内容

Java 从入门到进阶之路（八）

在之前的文章我们介绍了一下 Java 中的重载,接下来我们看一下 Java 中的构造方法. 我们之前说过,我们在定义一个变量的时候,java 会为我们提供一个默认的值,字符串为 null,数字为 0.如下: 1 public class HelloWorld { 2 public static void main(String[] args) { 3 User e = new User(); // 创建一个 User 对象 4 e.print(); // 姓名:null 年龄:0 性别:null

Java 从入门到进阶之路（十一）

之前的文章我们介绍了一下 Java 中的继承,接下来我们继续看一下 Java 中的继承. 在有些时候,我们通过类继承的方式可以获取父类的方法,但是有些时候父类为我们提供的方法并不完全符合我们的需求,这时候我们就要对类方法进行重写,如下: 1 public class HelloWorld { 2 public static void main(String[] args) { 3 Student student = new Student(); 4 student.name = "张三"

我的编程之路(十九) 开发中一些细节与启发

1.js的命名空间           如果写后台代码,分层是潜意识中的基本常识,但是一到了前台,却没了这种意识,归根结底还是js用的不多,也一直没有在意js的地位,直到现在富客户端的趋势与要求,使得很多代码都要在前台用js或其框架完成,所以对于js代码的管理就要像后台java代码一样有其规范了,而命名空间就是package,也是为了管理不同层次的代码. 2.闭包          闭包就是能够读取其他函数内部变量的函数.它的最大用处有两个,一个是可以读取函数内部的变量,另一个就是让这些变量的值

Python 爬虫从入门到进阶之路（十四）

之前的文章我们已经可以根据 re 模块,Xpath 模块和 BeautifulSoup4 模块来爬取网站上我们想要的数据并且存储在本地,但是我们并没有对存储数据的格式有要求,本章我们就来看数据的存储格式 JSON 及 Python 中的 json 模块. JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,它使得人们很容易的进行阅读和编写.同时也方便了机器进行解析和生成.适用于进行数据交互的场景,比如网站前台与后台之间的数据交互. JSON和XML的比较