5. Java基本数据类型

Java基本数据类型

数据类型和变量有关，数据类型就是用来定义变量的。

变量就是内存中的一块区域，这块区域有名字，有大小，有存储的值。

比如 int x = 10; 定义了一个变量 x , 值是10

那么这块区域的名字就是 x , 值是10， 这块区域的大小是4个字节，因为 int 类型是占用4个字节

内存管理系统根据变量的类型为变量分配空间，分配的空间只能用来存储该类型的数据

如下图：

因此在内存中定义不同类型的变量，就可以在内存中存储不同类型的数据，比如整数，小数，字符

Java数据类型分为 2 大类型：

• 基本数据类型（也叫内置数据类型）

• 引用数据类型

基本数据类型

Java语言提供了 8 种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。分类如下：

基本数据类型分类

• 整数型 byte, short , int , long 用来存储整数

• 浮点型 float , double 用来存储小数

• 布尔型 boolean ，只能存储 true和false

范围和默认值

每个基数类型都有一个取值范围，在声明变量时，如果没有给定的值，会有一个默认值。具体的范围和默认值，参考下表：

下面单独的分别介绍每个基本类型

1 byte

• byte类型占用 1 个字节，也就是8个位，
• 是有符号的，表示范围 [ -128 , 127 ]
• 默认值是0

代码示例：

//定义一个 byte 的变量 b  ,并赋值为23
byte b = 23;

//此时 b1 存储的是 字母 a 的ascii码
byte b1 = 'a';

2 short

• short 类型占用 2 个字节，16位

• 有符号的，表示范围 [ -32768, 32767 ]

• 默认值是0

代码示例：

// 定义一个 short 类型的变量 x ，并赋值为 10
short x = 10;

3 int

• int 类型占用 4 个字节，32 位

• 有符号的，表示范围 [ -2147483648, 2147483647 ]

• 默认值是 0

代码示例：

// 定义一个 int 类型的变量 x ，并赋值为 100
int x = 100;

4 long

• long 类型占用 8 个字节，64 位

• 有符号的，表示范围 [ -9223372036854,9223372036854775807 ]

• 默认值是 0 L

• 定义long类型的变量，后面要加上 L ，不要用小写的l ，因为小写的容易和数字 1 混淆

代码示例：

// 定义一个 long 类型的变量 x ，并赋值为 1000
long x = 100L;

5 float

• float 类型占用 4 个字节，32位
• 有符号的，表示范围 [ 1.4 E-45 , 3.402,823,5 E+38 ]
• 默认值是 0.0F
• 定义 float 类型的变量，赋值的时候要加上 f 或者 F

代码示例：

// 定义一个 float 类型的变量 x ，并赋值为 3.14
float x = 3.14f;

6 double

• double 类型占用8个字节，64位
• 有符号的，表示范围 [ 4.9 E-324 , 1.797,693,134,862,315,7 E+308 ]
• 默认值是 0.0d
• 定义 double类型变量，赋值的时候可以省略 d或者 D

代码示例:

double d1  = 6D ;
double d2  = 6.; 
double d3  =  9.0; 
double d4  =  9.D; 
double d5  =  19.456; 

• 7 是一个 int 字面量，而 6D，6. 和 9.0 是 double 字面量。

7 boolean

• boolean 类型表示 1 位的信息

• 只有 true 和 false ，分别代表 真 和 假

• 默认值是 false

代码示例:

boolean isSmall = false;
boolean isBig = true;

8 char

• char 类型占用 2 个字节，16位
• 是一个单一的 16位的 Unicode 字符
• 取值范围 [ 0, 65535 ]
• char 类型可以存储任何字符

代码示例:

char c1 = 'a';
char c2 = '你';
char c3 = '?';

Java的char类型除了可表示标准的ASCII外，还可以表示一个Unicode字符：

比如上面的 char c2 = '你'

包装类

1. 什么是包装类？

包装类：顾名思义就是包装过的类，那么是将什么包装起来呢？答案是将内置类型经过包装

包装类的作用就是将内置类型转换成对象，将内置类型作为基本对象来处理

Java中有 8 种内置类型，就有对应的 8 种包装类

2. 为什么需要包装类？

Java是面向对象的编程语言，但是Java中的内置数据类型（也叫基本数据类型）却不是面向对象的，但是实际使用中经常需要将内置类型转换为对象，便于操作

3. 如何把一个内置类型转为包装类？

比如，想把 double 内置的类型转为对象，我们可以定义一个类 Double ，它只包含一个字段double，这样 Double 就可以视为double的包装类

示例如下：

public class Double {
    private double value;

    public Double(double value){
        this.value = value;
    }

    public double doubleValue(){
        return this.value;
    }
}

这是我们自己定义的包装类Double， 定义好了Double类，我们就可以把double和Double互相转换：

Double d = null;
Double d2 = new Double(3.14);
double d3 = d2.doubleValue();

实际上，因为包装类型非常有用，Java核心库为每种基本类型都提供了对应的包装类型

不需要我们自己去定义，而且核心库中提供的包装类，功能更强大。

3. 内置类型与包装类的对应关系

引用类型

上面讲的都是Java的基本数据类型，基本数据类型之外 ，其它的都是引用类型

最常见的引用类型就是 String字符串了，例如：

String str = "hello,world"

引用类型的变量类似 C/C++ 语言中的指针，它存储的是一个“地址”，这个地址指向对象在内存中的位置。

比如上面的变量 str 存储的就是 hello,world那块内存区域的“地址”，不是真正的存储hello,world这个字符串

打个比方，以你的身份证为例：身份证上有你家的地址，通过身份证，就可以找到你家。

身份证上并没有保存你的家，因为你的家有房子，房子里面有很多东西，身份证怎么可能装得下呢。

所以身份证上只有你家的地址就行了，通过地址能找到你的家。如下图

所以，引用类型我们总结一下：

• 对象，数组，字符串都是引用类型

• 所有引用类型的默认值都是 null

• 上面说的地址只是形象的说法，在Java里面叫做引用

Java 常量

常量就是在运行的时候，不能修改它的值

在定义变量的前面加上 final修改符，这个变量就成了常量：

final String site = "example.com";  // site 是一个常量

site = "example.com"; //编译报错，site 是一个常量，运行时不能再改变值

类型转换

类型转换是将一种数据类型转换为另一种数据类型

在 Java中，类型转换可以分为 2 大类

• **自动转换：（自动）**将较小的类型转为较大的类型，类型等级如下：

  byte --> short --> char --> int --> long --> float --> double

• 强制转换：（手动） 将较大的类型转为较小的类型

  double --> float --> long --> int --> char --> short --> byte

1. 自动转换

将较小数据的类型传给较大数据的类型时，将自动完成转换：

例如：

public static void main(String[] args){
    int a = 10;
    long b = a; //将 a 赋值给 b ， int 就会自动转换为 long
    
    System.out.println(b); //输出： 10
}

2. 强制转换

强制数据类型转换是手动将较大范围数据转换较小数据类型，格式是在需要转型的数据前加上“( )”，然后在括号内加入需要转化的数据类型。

有的数据经过转型运算后，精度会丢失，而有的会更加精确。

例如：

public static void main(String[] args){
    double a = 100.37;
    int b = (int) a; //手动转换：将 double 转为 int

    System.out.println(b); //输出： 100 , 丢失精度
}

3. 几个常用的转换的例子

String 转 StringBuilder

String s = "example.com";
StringBuilder sb = new StringBuilder(s);

StringBuilder 转 String

StringBuilder sb = new StringBuilder("example.com");
String s = sb.toString();

int 转 String

int value = 10;
String s = "" + value;  			//字符符和数字相加，自动转成字符串
String s1 = String.valueOf(value); 	//String的方法

System.out.println(s);	//输出 “10”
System.out.println(s1);	//输出 “10”

String 转 int

String s = "123";
int a = Integer.parseInt(s);    //调用包装类 Integer.parseInt() 方法转换
System.out.println(a);

小结

本小节我们学习了Java的基本数据类型，包装类，引用，常量，类型转换的知识 ，简单总结一下：

• Java有 8 种基本数据类型 byte,char,short,int,long,float,double,boolean

• 每种基本类型都有对应的包装类 Byte,Character,Short,Integer,Long,Float,Double,Boolean

• 引用可以理解为“地址”，通过引用能找到变量指向的那块区域

• 常量就是在定义变量的前面加 final 关键字，而且运行时变量的值不能修改。比如 final int a = 10

• 类型转换分为 2 种，大转小，需要强制在前面加 （）, 小转大，自动转换

本节关于基本数据类型的内容就到这了，随着后面的学习，会进一步加深对数据类型的理解