Java的数据类型和变量

素颜马尾好姑娘i 2023-10-04 22:05 61阅读 0赞

## ![24d6732d4be649abb4c5b869a2f904b9.jpeg][] ##

**目录**

编辑

一、字面常量

1、字面常量的定义

2、字面常量的分类

二、数据类型

三、变量

1、变量的概念

2、语法格式

3、整型变量

（1）整型变量

（2）长整型变量

（3）短整型变量

（4）字节型变量

4、浮点型变量

（1）双精度浮点型

（2）单精度浮点型

5、字符型变量

6、布尔型变量

7、类型转换

（1）自动类型转换(隐式)

（2）强制类型转换(显式)

8、类型提升

（1）int与long之间：int会被提升为long

例如：

（2）byte与byte的运算

四、字符串类型

1、int 转成 String

--------------------

## **一、字面常量** ##

### 1、字面常量的定义 ###

在了解字面常量的概念前，我们先举个例子：

在上篇博客的HelloWorld程序中， System.Out.println("Hello World")； 语句，不论程序何时运行，输出的都是Hello World，其实"Hello World"就是字面常量。

**定义：常量即程序运行期间，固定不变的量称为常量**，比如：一个礼拜七天，一年12个月等。

为了更好地理解字面常量的意思，我们来看下面这个程序：

public class Demo{
    public static void main(String[] args){
    System.Out.println("hello world!");
    System.Out.println(100);
    System.Out.println(3.14);
    System.Out.println('A');
    System.Out.println(true);
    System.Out.println(false);
    }
    }

在这段代码中，100、3.14、‘A’、true/false都是常量，将其称为字面常量。

### 2、字面常量的分类 ###

字面常量主要有以下几类构成：

> 字面常量的分类：
> 
> 1. 字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。
> 
> 2. 整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000
> 
> 3. 浮点数常量：程序中直接写的小数，比如：3.14、0.49
> 
> 4. 字符常量：由 单引号 括起来的当个字符，比如：‘A’、‘1’
> 
> 5. 布尔常量： **只有两种true和false** 
> 
> 6. 空常量：null

**注意：字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型。**

在这里，我们要重点关注一下布尔常量，这是因为它和我们在c语言中的认知有所差异，在c语言中，我们将0看作为真，将非0看作为假，但是在Java中，我们不能用0和1来表示真假，这个时候我们就要运用到布尔常量，**Java语言规定，true为真，false为假**

## **二、数据类型** ##

在Java中数据类型主要分为两类： **基本数据类型**和 **引用数据类型。**

其中，基本数据类型主要分为四类八种。

1. **四类：整型、浮点型、字符型以及布尔型**

2、 **八种：**

![028e4cfdca6d41d28acba250a17b1b0e.png][]

那么这个表格中关于数据类型所能表示的数的范围是怎么得出的呢？

我们先来用字节型的数据类型来举例：

> 字节型的数据类型大小为一个字节，也就是八个比特位，我们用二进制来表示：0000 0000
> 
> 那么当它有最大值时，表示为0111 1111 也就是127
> 
> 当它有最小值的时候，表示为1000 0000 也就是-128
> 
> 其它的数据类型所能表示的数据的大小我们也可以用相同的方法进行计算

现在，我们用一段代码来验证一下int类型数据的范围：

public class Test {
        public static void main(String[] args) {
            System.out.println(Integer.MIN_VALUE);
            System.out.println(Integer.MAX_VALUE);
        }
    }

这段代码的运行结果是：

![e9bc9f41dc3943058353b6fe7de7755a.png][]

**注意：**

> Interger 是一个类型，学名：包装类
> 
> 当前的Integer类型可以当成int类型的plus版，功能比简单的int类型多
> 
> 也就是说，int类型的最小值为-2147483648，最大值为2147483647，与表中数据相符

那么我们再来计算一下long类型数据的范围：

public class Test {
        public static void main(String[] args) {
            System.out.println(Long.MAX_VALUE);
            System.out.println(Long.MIN_VALUE);
        }
    }

最大值为：9223372036854775807 最小值为：-9223372036854775808

> **注意**：
> 
> 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
> 
> 整形和浮点型都是带有符号的
> 
> 整型默认为int型，浮点型默认为double
> 
> **如果想表示长整型则需在数据后面加上L，若想要表述单精度浮点型则需在数据后面加上F**
> 
> 字符串属于引用类型

虽然我们在学c语言的时候，已经学了什么是字节，但是在学Java的时候我们可以对这个知识点进行再一次的巩固

那么什么是字节呢？

> **字节是计算机中表示空间大小的基本单位.** 
> 
> 计算机使用二进制表示数据. **我们认为 8 个二进制位(bit) 为一个字节(Byte).** 
> 
> 我们平时的计算机为 8GB 内存, 意思是 8G 个字节.
> 
> 其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.
> 
> 所以 8GB 相当于 80 多亿个字节

## 三、变量 ##

### 1、变量的概念 ###

在程序中，除了有始终不变的常量外，有些内容可能会经常改变，比如：人的年龄、身高、成绩分数、数学函数的 计算结果等， **对于这些经常改变的内容，在Java程序中，称为变量。而数据类型就是用来定义不同种类变量的。**

### 2、语法格式 ###

在Java语言中的语法格式与C语言中的类似，我们定义变量的语法格式为：

> 数据类型 变量名 = 初始值;

同样的，我们使用代码来进行理解：

int a = 10; // 定义整形变量a，a是变量名也称为标识符，该变量中放置的值为10
    double d = 3.14;
    char c = 'A';
    boolean b = true;
    System.Out.println(a);
    System.Out.println(d);
    System.Out.println(c);
    System.Out.println(b);
    a = 100; // a是变量，a中的值是可以修改的，注意：= 在java中表示赋值，即将100交给a，a中保存的值就是100
    System.Out.println(a);
    // 注意：在一行可以定义多个相同类型的变量
    int a1 = 10, a2 = 20, a3 = 30;
    System.Out.println(a1);
    System.Out.println(a2);
    System.Out.println(a3);

### 3、整型变量 ###

#### （1）整型变量 ####

在进行整型变量的定义的时候，我们可以使用不同的方法来进行变量的定义：

**方式一：在定义时给出初始值**

int a = 10;
    System.Out.println(a);

**方式二：在定义时没有给初始值，但使用前必须设置初值**

int b;
    b = 10;
    System.Out.println(b);

**注意：Java当一个变量没有被赋予初值的时候，是不能通过编译的，也就是说Java当中局部变量必须初始化才能使用**

**如：**

int c;
    System.Out.println(c);
    c = 100;

这段代码中整型变量c并没有被赋予初值，在Java的编译器中，这段代码不能正常通过编译，会进行报错！

**注意：Java中整型变量的赋值不能超过int类型的范围**

**如：**

int d = 12345678901234; // 编译时报错，初值超过了int的范围

在前面我们已经学到，int类型的赋值范围是 -![gif.latex?x%5E%7B31%7D][gif.latex_x_5E_7B31_7D]\-![gif.latex?x%5E%7B31%7D][gif.latex_x_5E_7B31_7D]\-1 而这段代码中对d的赋值远超过int的范围，因此在编译时会进行报错

**注意事项：**

> 1. int不论在何种系统下都是4个字节（这点与C语言有所不同）
> 
> 2. 推荐使用方式一定义，如果没有合适的初始值，可以设置为0
> 
> 3. 在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
> 
> 4. 变量在使用之前必须要赋初值，否则编译报错
> 
> 5. int的包装类型为 Integer

#### （2）长整型变量 ####

在Java中，我们和C语言一样，用long来表示长整型变量，但是在Java中使用长整型变量的时候，我们必须在数据的最后加上L，这是因为在Java中，整型默认为int类型，只有加上L计算机才会将数据识别为long类型

> int a = 10;
> 
> long b = 10; // long定义的长整型变量
> 
> long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
> 
> long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分

此外，我们在对long类型计算数据的存储范围的时候，使用以下的代码来实现：

System.out.println(Long.MAX_VALUE);
            System.out.println(Long.MIN_VALUE);

**注意事项：**

> 1. 长整型变量的初始值后加L或者l，推荐加L
> 
> 2. 长整型不论在那个系统下都占8个字节
> 
> 3. 长整型的表示范围为： - ![gif.latex?2%5E%7B63%7D][gif.latex_2_5E_7B63_7D] ~ ![gif.latex?2%5E%7B63%7D][gif.latex_2_5E_7B63_7D] \-1
> 
> 4. long的包装类型为Long

#### （3）短整型变量 ####

short a = 10;
    System.Out.println(a);

那么如何计算short类型表示的变量的范围呢？

System.Out.println(Short.MIN_VALUE);
    System.Out.println(Short.MAX_VALUE);

**注意事项：**

> 1. short在任何系统下都占2个字节
> 
> 2. short的表示范围为：-32768 ~ 32767
> 
> 3. 使用时注意不要超过范围
> 
> 4. short的包装类型为Short

#### （4）字节型变量 ####

byte b = 10;
    System.Out.println(b);

那么如何计算字节型类型表示的变量的范围呢？

System.Out.println(Byte.MIN_VALUE);
    System.Out.println(Byte.MAX_VALUE);

**注意事项：**

> 1. byte在任何系统下都占1个字节
> 
> 2. byte的范围是：-128 ~ 127
> 
> 3. 字节的包装类型为Byte

### 4、浮点型变量 ###

#### （1）双精度浮点型 ####

double d = 3.14;
    System.Out.println(d);

那么我们来看一下下面这段代码，输出结果会不会是0.5呢？

int a = 1;
    int b = 2;
    System.out.println(a / b);

**答案是：不会**

这是因为a是int类型的变量，而b也为int类型，当a/b后得到的结果仍然为int类型，将小数点省略，**因此如果想要得到0.5，那么我们应该使用double类型来进行计算**

double a = 1.0;
    double b = 2.0;
    System.out.println(a / b); // 输出0.5

我们来看第二段代码：

double num = 1.1;
    System.out.println(num * num); // 输出1.21吗？

![4f2c5e0ed1eb4aa691b0c49c0321192c.png][]

那么为什么会出现这样的结果呢？

**double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值**

**注意事项：**

> 1. double在任何系统下都占8个字节
> 
> 2. 浮点数与整数在内存中的存储方式不同，不能单纯使用 的形式来计算
> 
> 3. double的包装类型为Double
> 
> 4. double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

#### （2）单精度浮点型 ####

float num = 1.0F; 
    System.out.println(num);

**float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float. float的包装类型为Float.**

### 5、字符型变量 ###

char c1 = 'A'; // 大写字母
    char c2 = '1'; // 数字字符
    char c3 = '帅';//中文字符
    System.out.println(c3);
    System.out.println(c1);
    System.out.println(c2);

**注意：java中的字符可以存放整形**

**注意事项：**

> 1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
> 
> 2. **计算机中的字符本质上是一个整数** **.** 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文。
> 
> **3.char的包装类型为Character**

有时候，我们在执行Javac的时候可能会出现以下错误：

> Test.java:3: 错误: 未结束的字符文字
> 
> char ch = '鍛?';
> 
> ^

这个时候，我们只需要在执行 javac 时加上 -encoding UTF-8 选项即可

javac -encoding UTF-8 Test.java

### **6、布尔型变量** ###

布尔类型常用来表示真假，在现实生活中也是经常出现的，比如：听说xxx同学买彩票中了一个亿...，听到后估计 大部分人第一反应就是：woc，真的假的？

那么布尔型变量在Java中如何使用呢？我们来用代码实现

ystem.out.println(b);
    b = false;
    System.out.println(b);

**注意事项;**

> 1. boolean 类型的变量只有两种取值, true 表示真, false 表示假.
> 
> 2. Java 的 boolean 类型和 int 不能相互转换, **不存在** 1 表示 true, 0 表示 false 这样的用法.
> 
> 3. Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在 Oracle公司的虚拟机实现中，boolean占1个字节。
> 
> **4. boolean的包装类型为Boolean**

那么我们来看下这段代码是否正确呢?

boolean value = true;
    System.out.println(value + 1);

**答案是：错误！**

这是因为变量value是布尔型变量，而数字1为int类型，两者无法相加，所以会导致编译错误

### **7、类型转换** ###

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验

在Java中，当参与运算数据类型不一致时，就会进行类型转换。 **Java中类型转换主要分为两类：自动类型转换(隐式) 和 强制类型转换(显式)。**

有时我们会碰到下面这种代码：

int a = 10;
    long b = 100L;
    b = a; // 可以通过编译
    a = b; // 编译失败

那么为什么第二个式子无法通过编译呢？

这是因为a是int类型的变量，而b是long类型的变量，long类型比int类型的范围要大，当long转化成int类型的时候，容易导致四个字节的数据的缺失，Java编译器会认为这不安全从而进行报错。

#### （1）**自动类型转换****(****隐式****)**  ####

自动类型转换即： **代码不需要经过任何处理，在代码编译时，编译器会自动进行处理**。 **特点：数据范围小的转为数据范围大的时会自动进行。**

例如：

System.Out.println(1024); // 整型默认情况下是int
    System.Out.println(3.14); // 浮点型默认情况下是double
    int a = 100;
    long b = 10L;
    b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
    a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
    float f = 3.14F;
    double d = 5.12;
    d = f; // 编译器会将f转换为double，然后进行赋值
    f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
    byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
    byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失

#### **（2）****强制类型转换****(****显式****)** ####

强制类型转换： **当进行操作时，代码需要经过一定的格式处理，不能自动完成**。特点： **数据范围大的到数据范围小的。**

**例如:**

int a = 10;
    long b = 100L;
    b = a; // int-->long，数据范围由小到大，隐式转换
    a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败
    float f = 3.14F;
    double d = 5.12;
    d = f; // float-->double，数据范围由小到大，隐式转换
    f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
    a = d; // 报错，类型不兼容
    a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
    byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
    byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
    boolean flag = true;
    a = flag; // 编译失败：类型不兼容
    flag = a; // 编译失败：类型不兼容

**注意事项：**

> 1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
> 
> 2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是 **可能精度丢失** 
> 
> 3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
> 
> 4. 强制类型转换不一定能成功，不相干的类型不能互相转换

### **8、类型提升** ###

#### **（1）****int****与****long****之间：****int****会被提升为****long** ####

#### 例如： ####

int a = 10;
    long b = 20;
    int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
    long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long

#### （**2）****byte****与****byte****的运算**  ####

我们来看如下代码：

byte a = 10;
    byte b = 20;
    byte c = a + b;
    System.out.println(c);
    // 编译报错
    Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
    byte c = a + b;

**总结：**

> byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.
> 
> 由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于 4 个字节的类型, 会先提升成 int, 再参与计算

那么我们该如何正确书写呢？

byte a = 10;
    byte b = 20;
    byte c = (byte)(a + b);
    System.out.println(c);

通过上面，我们可以对类型提升做出一个小结

> 1. 不同类型的数据混合运算, 范围小的会提升成范围大的.
> 
> 2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.

## 四、字符串类型 ##

在Java中使用String类定义字符串类型，比如：

public static void main(String[] args) {
    String s1 = "hello";
    String s2 = " world";
    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接
    }

在有些情况下，需要将字符串和整形数字之间进行转换：

#### **1、****int** **转成** **String**  ####

int num = 10;
    // 方法1
    String str1 = num + ""; 
    // 方法2
    String str2 = String.valueOf(num);

我们来看一下下面这个神奇的代码：

public class Test {
        public static void main(String[] args) {
            int c = 10;
            int d = 20;
            System.out.println(c+d + "hello");
            System.out.println("hello" + c+d);
        }
    }

这段代码的运行结果将会超出你的意料

![0cef3e4583594953966180f22b2d3446.png][]

这是因为在第一个式子中，c和d先进行计算得到结果30再和字符串进行结合进行输出，但是在第二个式子中，hello作为字符串先出现在前面，与后面的c和d结合，一起作为字符串输出，那么如果我们想输出Hello30该如何编写代码呢？

System.out.println("hello" + (c+d));

#### 2. **String** **转成** **int**  ####

String str = "100";
    int num = Integer.parseInt(str);

## **OVER ！** ##

[24d6732d4be649abb4c5b869a2f904b9.jpeg]: https://img-blog.csdnimg.cn/24d6732d4be649abb4c5b869a2f904b9.jpeg
[028e4cfdca6d41d28acba250a17b1b0e.png]: https://img-blog.csdnimg.cn/028e4cfdca6d41d28acba250a17b1b0e.png
[e9bc9f41dc3943058353b6fe7de7755a.png]: https://img-blog.csdnimg.cn/e9bc9f41dc3943058353b6fe7de7755a.png
[gif.latex_x_5E_7B31_7D]: https://latex.csdn.net/eq?x%5E%7B31%7D
[gif.latex_2_5E_7B63_7D]: https://latex.csdn.net/eq?2%5E%7B63%7D
[4f2c5e0ed1eb4aa691b0c49c0321192c.png]: https://img-blog.csdnimg.cn/4f2c5e0ed1eb4aa691b0c49c0321192c.png
[0cef3e4583594953966180f22b2d3446.png]: https://img-blog.csdnimg.cn/0cef3e4583594953966180f22b2d3446.png