（JAVA）认识Java中的数据类型和变量

✨✨✨学习的道路很枯燥，希望我们能并肩走下来！

编程真是一件很奇妙的东西。你只是浅尝辄止，那么只会觉得枯燥乏味，像对待任务似的应付它。但你如果深入探索，就会发现其中的奇妙，了解许多所不知道的原理。知识的力量让你沉醉，甘愿深陷其中并发现宝藏。

---

前言

Java语言有一部分是与C语言中类似的但又不完全相同，本篇文章让我们在认识Java中数据类型中，回顾一下C语言知识，并重点记忆Java与C不同的语法。
如有错误，请在评论区指正，让我们一起交流，共同进步！

---

本文开始

1.字面常量

常量：在程序运行期间，固定不变的量
例如：一周7天，一年12给月

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

字面常量的分类：

1. 字符串常量：由双引号括起来"“,例：''123”,“你好”，“hello”;
2. 整形常量：程序中之间写的数字。例：100，2，3；
3. 浮点数常量：程序中之间写的小数。例：3.14，0.78；
4. 字符常量：由单引号括起来的单个字符。例：‘A’,‘2’;
5. 布尔常量：只有两种true,false。
6. 空常量：null。

代码演示：

public class test {
    public static void main(String[] args) {
        System.out.println("hello word");//字符串类型
        System.out.println(100);//整形
        System.out.println(3.14);//浮点型
        System.out.println('A');//字符型
        System.out.println(true);//布尔类型
        System.out.println(false);//布尔类型
    }
}
1
2
3
4
5
6
7
8
9
10

2. 数据类型

Java中数据类型分为两大类：基本数据类型 和 引用数据类型。

基本数据类型：
8种：

Java与C的不同：
【注意】在Java中基本类型的字节数，不会随操作系统的改变，而变大变小。
1.不论是16位操作系统还是32位操作系统，int都是4个字节，long都占8个字节。
2.整形和浮点型都是带符号的。（Java中没有无符号整形之类的）
3.整形默认是int类型，浮点数默认为double。
4.字符串属于引用类型，而C中没字符串类型

回顾什么是字节？
字节是计算机中表示空间的大小的基本单位。
计算机使用二进制表示数据，我们认为8个二进制位 (bit) 为一个字节（byte）。

1KB = 1024Byte, 1MB = 1024 KB, 1GB = 1024MB
8 GB => 8G 相当与80多亿个字节

3.变量

3.1 变量概念

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

3.2 语法格式

定义变量语法格式： 数据类型 变量名 = 初始值；
这里与C类似，我们直接看一下代码测试。

public static void main(String[] args) {
        int a = 10;
        double b = 3.14;
        char c = 'A';
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        
        a = 100;//变量的值可以修改，java中 = 表示赋值
        System.out.println(a);
        
        int a1 = 10, a2 = 20, a3 = 30;
        //一行可以定义多个变量；
        
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.3 整形变量

1. 整形变量
   【注】这里我们先将Integer看作 int 的扩大版本，里面包含很多，我们之后的文章会介绍到，这里只是从中找到里面的最大值和最小值。
   1.int 在java中任何系统下都是4个字节
   2.为防止没有赋值直接使用变量，推荐直接设置为0
   3.给变量设置值不可以超出范围，否则会溢出

public static void main(String[] args) {
        //1.定义时给出初始值
        int a = 10;
        System.out.println(a);
        
        //2.定义是没有给初始值，使用前必须给初始值
        int b;
        b = 10;
        System.out.println(b);
        
        //3.使用前没有给变量赋值，编译期间会报错
        int c;
        System.out.println(c);//err:错误示范
        
        //int型变量的所能表示的范围, 
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        
        //从上面int类型变量表示的范围，我们可以看出赋值时不能超出int类型的范围
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2. 长整型变量
   【注意】
   1.长整型变量的初始值后加L或者l（推荐L,小写l有时候与值不好区分）
   2.长整型不论在哪个系统中都是8个字节
   3.长整型表示范围：-2^63~363-1
   4.long的包装类型为Long

public static void main(String[] args) {
        int a = 10;
        long b = 10;
        
        long c = 10L;//long类型后面加L或l，是为了与int区分
        long d = 10l;
        //long所表示的范围远大于int可以满足绝大部分场景使用
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
    }
1
2
3
4
5
6
7
8
9
10

3. 短整型变量
   【注意】
   1.短整型不论在哪个系统中都是8个字节
   2.表示范围：-32768~32767
   3.short包装类：Short(首字母大写)

 public static void main(String[] args) {
        short a = 10;
        System.out.println(a);

        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
    }
1
2
3
4
5
6
7

4. 字节型变量
   【注意】
   1.byte在任何系统下都占1个字节
   2.byte取值范围：-128~127
   3.字节的包装类型为Byte

		public static void main(String[] args) {
        		byte b = 10;
       			System.out.println(Byte.MAX_VALUE);
        		System.out.println(Byte.MIN_VALUE);
   	   }
1
2
3
4
5

3.4 浮点型变量

1. 双精度浮点型变量
   在Java中，int 除以的值仍然是 int 会直接舍弃小数部分，这里与C类似。为了得到0.5，需要使用 double 类型计算。
   【注意】
   1.double 在任何系统下都占8个字节
   2.浮点数与整数在内存中的存储方式不同，不能单纯使用2^n来计算
   3.double的包装类型Double
   4.double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值

 public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a/b);

        double a1 = 1.0;
        double b1 = 2.0;
        System.out.println(a1/b1);

        double num = 1.1;
        System.out.println(num*num);
    }
1
2
3
4
5
6
7
8
9
10
11
12

2. 单精度浮点型变量

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

 public static void main(String[] args) {
        float n = 1.0f;
        System.out.println(n);
    }
1
2
3
4

3.5 字符型变量

【注意】
1.Java中使用 单引号 + 单个字母 的形式便是字符的字面值
2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符.
一个字符占用两个字节, 表示的字符种类更多, 包括中文。
3.char的包装类型为Character
4.字符类型是2个字节，可以存放汉字
5.char类型能放整数，但打印的对应整数的字符。
例如：char ch = 97; =》打印会是字符 ‘a’

public static void main(String[] args) {
        char c1 = 'A';
        char c2 = '1';

        System.out.println(c1);
        System.out.println(c2);

        char c3 = '你';//java中的字符可以存放整形：1个汉字两个字节
        System.out.println(c3);
        
    }
1
2
3
4
5
6
7
8
9
10
11

在使用命令行执行javac 的时候可能会报错：
有的电脑默认是GBK字符集，会出现不兼容而报错。更换成UTF-8就可以继续执行。

3.6布尔类型变量

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

public static void main(String[] args) {
        boolean v = true;
        System.out.println(v + 1);//err:错误
    }
1
2
3
4

错误原因：

3.7 类型转换

与C语言不同的是，Java中没有截断这种说法，只要等号右边的类型大于等号左边的类型，就需要强制类型转换。
在Java中，当参与运算数据类型不一致时，就会进行类型转换。Java中类型转换主要分为两类：自动类型转换(隐式) 和 强制类型转换(显式)。

3.7.1 隐式转换（自动类型转换）

隐式转换：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。
特点：数据范围小的转为数据范围大的时会自动进行。
例如：int =》long; float =》double;

整形默认：int
浮点型数据默认：double （3.14）

	int a = 20;
	long b = 10L;
	b = a; 
	// a和b属于整形，a的范围小，b的范围大，
	当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
	a = b; 
	// 编译报错，long的范围比int范围大，会有数据丢失，不安全
1
2
3
4
5
6
7

3.7.2 显示转换 （强制类型转换）

显示类型转换：不能自动完成
特点：数据范围大的到数据范围小的

 public static void main(String[] args) {
        int a = 20;
        long b = 10L;
        b = a;//隐式转换 int => long
        a = (int)b;//显示转换 long => int

        float f = 3.14f;
        double d = 4.24;
        d = f;//float => double
        f = (float) d;//double => float
        
        a = (int)d;//double => int; 强转后会有数据丢失，小数点后的全部丢弃

        byte by = 100;
        byte by2 = 128;//error，超出范围
        byte by3 = (byte)128;//128默认int,超过byte范围，需要显示转换
        //byte:-128~127
        System.out.println(by3);
        
        boolean bo = true;
        a = bo;//error
        //类型不兼容：布尔类型不能与其他类型转换
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

小结：1. 不同数字类型的变量之间相互赋值, 表示范围更小的类型能隐式转换成范围较大的类型 (int =》long)
2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失（double =》int）
3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查
4. 强制类型转换不一定能成功，不相干的类型不能互相转换 (布尔类型与其他类型)

3.8 类型提升

类型提升原因：
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short这种低于 4 个字节的类型, 会先提升成 int, 再参与计算。

对于不同类型数据混合运算，范围小的会提示为范围大的 再进行运算。
例如：short,byte 进行运算时会先提升为4个字节的int类型

4. 字符串类型

C语言中是没有字符串类型的，而Java中存在字符串类型。Java中可以使用字符串类型存储字符串常量值：String str = “hello”;
这里我们只是先了解一下字符串类型。以后的文章会详细介绍的！

【注】
①Java中没有指针这个说法，我们不能像C语言一样拿到数据的地址
②在Java中没有所谓字符串以\0截至，它是看字符串里的个数，如果有5个就打印5个。

4.1字符串拼接

字符串能和整形拼接？

public static void main(String[] args) {
        String str = "hello";
        String str2 = "word";
        System.out.println(str+str2);

        int a = 10;
        int b = 20;
        //字符串能和整数相加？
        System.out.println("a =" + a);
        System.out.println("b =" + b);
        System.out.println("a+b ="+a+b);
        //a+b = 先于10拼接(a)为a+b =10在与20拼接=》a+b =1020
        System.out.println("a+b ="+(a+b));//a+b = 30
        //为计算a+b的和，加上括号可以实现
        System.out.println(a+b + "是a+b的和");
        //先计算a+b为30
        System.out.println(a+b);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

代码结果：

程序都是从左向右执行的，而字符串+其他类型 =》字符串

4.2字符串整形互相转换

String =》 int

public static void main(String[] args) {
        int a = 12345;
        String aa = a+"";
        //任何类型拼接字符串（可以是空字符串）=》就是字符串类型
        System.out.println("--->" + aa);
        String ret = String.valueOf(a);
    }
1
2
3
4
5
6
7

int =》String

public static void main(String[] args) {
        String str = "12345";
        int ret = Integer.valueOf(str);
        System.out.println(ret+1);

        int ret3 = Integer.parseInt(str);
        //valueOf里面调用的parseInt
        
        String str2 = "1.23";
        double d = Double.valueOf(str2);
        System.out.println(d);
    }
1
2
3
4
5
6
7
8
9
10
11
12

总结

✨✨✨各位读友，本篇分享到内容是否更好的让你理解了Java中的数据类型和变量，如果对你有帮助给个👍赞鼓励一下吧！！
感谢每一位一起走到这的伙伴，我们可以一起交流进步！！！一起加油吧！！！