【Java】带你从零到一系列1（变量与数据类型详解） 万字长文，建议收藏！

前言：
本篇我们先来学习一下变量与数据类型，对于Java来说，数据类型与运算符和C语言类似，但又有所区别，而同样是学习一门语言的开始位置。让我们进去耍耍吧！

每文一图：

开始我们的学习吧！

数据类型：

• 一.了解什么是变量与类型
• • 1.整型变量
  • 2.长整型变量
  • 3.短整型变量
  • 4.双精度浮点型变量
  • 5.单精度浮点型变量
  • 6.字符类型变量
  • 7.字节类型变量
  • 8.布尔类型变量
  • 9.字符串类型变量
• 二.带你玩转变量
• • 1.变量的作用域
  • 2.变量的命名规则
  • 3.常量
  • 4.类型转换
  • 5.强制类型转换
  • 6.其他小细节

---

一.了解什么是变量与类型

变量指的是程序运行时可变的量， 相当于开辟一块内存空间来保存一些数据。类型则是对变量的种类进行了划分， 不同的类型的变量具有不同的特性。

而我们讨论的变量主要是和我们的内存密切相关的，我们来看一个冯诺依曼体系的图：

对于图中的输入设备，比如我们的键盘，麦克风这种就是输入设备。而运算器和控制器就是去将输入设备收到的内容进行运算和识别一些语句。外存储器就是磁盘、光+盘、U盘等。对于内外存储，我们用手机来 说明就容易理解了，比如手机有8G+256G的，有6G+128G的，那么内存储器就是前面的6G和8G，而外存储器就是你们的128和256。对于内存储器，就是在你电脑或者手机等设备运行某些软件的时候，都会在内存储器中运行。输出设备就比如电脑屏幕。

在这里还要普及一下对于内存单位的介绍和换算：

计算机存储单位一般用bit、B、KB、MB、GB、TB、PB、EB、ZB、YB、BB、NB、DB……来表示。

单位	换算
bits	计算机最小的数据传输单位 bit
Byte	1 Byte = 8 bits
KB	1 KB = 1024 Bytes
MB	1MB = 1024 KB
GB	1 GB = 1024 MB
TB	1 TB = 1024 GB
PB	1 PB = 1024 TB
EB	1EB = 1024 PB
…	后面的同样是1024换算

那么变量是什么呢？类似于一个箱子，有它的类型，大小等。然后它是程序运行时可变的量， 相当于开辟一块内存空间来保存一些数据。那么它有哪些类型呢？其实对于Java中的数据类型有8大数据类型。

分别是：

其中引用类型我们后面会讲到，这里先讲8种基本类型。

---

1.整型变量

变量我们理解了，那什么是整形呢。其实整形就以整数的形态展示，整型变量也就是整数，但是我们说过变量除了类型，还有大小，所以对于整型变量，也是有大小范围的。

基本语法格式：

int 变量名 = 初始值;

这里的int的就是一种类型，然后表明这个变量是int的类型，变量名就是我们给这个变量起的名字。而量肯定是有值的，所以要给它赋一个初始值。

同时我们打开编译器，写一个这样的代码:

public static void main(String[] args) {
        int a = 10;
        System.out.println(a);
        //输出函数，代码运行起来输出a的值
    }

那么对于刚刚我们说的变量是有类型的，有大小的，在 Java 中, 一个 int 变量占 4 个字节，和操作系统没有直接关系，这里说和操作系统没有关系是因为一些语言会因为操作系统是32位/64位而对于不同的大小。

什么是字节?4个字节有多大？

字节是计算机中表示空间大小的基本单位。计算机使用二进制表示数据. 我们认为 8 个二进制位(bit) 为一个字节(Byte)。正如我们上面所换算的，4个字节就是32个bit。而对于二进制位的bit来说，32个bit其实就说明4个字节的范围在 -2^31 -> 2^31-1 , 也就大概是 -21亿 到 +21亿.

什么？你说你不相信？别急，我们可以在IDEA中输入相关命令然后进行查看，看看是不是这么大：

在IDEA输入如下命令，鼠标放在MAX_VALUE上，按住ctrl键点击查看：

 System.out.println(Integer.MAX_VALUE);  // int 的最大值
 System.out.println(Integer.MIN_VALUE);  // int 的最小值

当我们点击进去查看到的，就是代码在内存中的解释：

什么？又看不懂0x7fffffff是多少？没问题，我们可以打开我们的计算机，转到程序员专场或者进制转换，这里的0x7fffffff其实是16进制，我们换算一下：

这里换算除了就是21亿多了，而最小值这里，因为f就是15了，所以0x80000000就是比0x7fffffff多了1，所以最小值也是负的21亿多。

那么如果我想存储一个变量是22亿呢，会怎么样？如果运算的结果超出了 int 的最大范围, 就会出现溢出的情况。但对于机器中，其实变量的范围是一个圆，也就是如果你超出了，超出的那部分还是会绕回到范围内，比如：

    public static void main(String[] args) {
      
        System.out.println("最大值是:"+Integer.MAX_VALUE);  //int 的最大值
        System.out.println("最小值是:"+Integer.MIN_VALUE);  //int 的最小值

        int maxValue = Integer.MAX_VALUE;
        System.out.println("最大值+1是:"+(maxValue+1));//最大值+1是多少？
    }

答案：
最大值是 : 2147483647
最小值是 : -2147483648
最大值+1是 : -2147483648

这就是我们所说的圆，当我们的最大值之后，又会回到最小值，然后进行往前回去，简单的来说就像这个图一样：

然后小伙伴们是不是还有一些疑问呢？对于这里我们有一些注意事项和解答：

注意事项:

1. int 表示变量的类型是一个整型。
2. 变量名是变量的标识. 后续都是通过这个名字来使用变量。
3. Java 中 = 表示赋值(和数学不一样), 意思是给变量设置一个初始值。
4. 初始化操作是可选的, 但是建议创建变量的时候都显式初始化。
5. 最后不要忘记分号, 否则会编译失败。
6. // 表示注释， 注释作为代码的解释说明部分,，不参与编译运行。

那么问题又来了，21亿就这？我身家22亿(bushi)计算机算不清吗？

21亿这样的数字对于当前的大数据时代来说, 是很容易超出的. 针对这种情况, 我们就需要使用更大范围的数据类型来表示了。 Java 中提供了 long 类型。

---

2.长整型变量

同样的，长整型变量也有大小，而作为"整形变量puls"，长整型变量肯定是比整形大啦，它是8个字节的。我们还是先从它的基本语法格式说起：

基本语法格式:

long 变量名 = 初始值;

我们来写一个这样的代码：

public static void main(String[] args) {
        long num = 10L;
        // 定义一个长整型变量, 初始值写作 10l 也可以(小写的 L, 不是数字1). 
        System.out.println(num) ;
    }

在这里要注意一个点，我们同样是定义整形，这里加是L是因为它是长整型，所以要有区分，实际上这里也可以用小写的l，但是看起来是不是像一呢，这就是代码风格了，程序员不成文的规定，一般都是用大写的L。

上面说到长整型是8个字节，所以他在Java 中占 8 个字节. 表示的数据范围 -2^63 -> 2^63-1的范围了，也就是大到我也数不上来了。我们用计算机算一下吧：

这个数量级就足以面对足够绝大部分的工程场景使用了，然后就是对于long类型，基本上和int的语法一致，而我们需要注意的地方：

注意事项:

1. 基本语法格式和创建 int 变量基本一致, 只是把类型修改成 long。
2. 初始化设定的值为 10L , 表示一个长整型的数字， 10l 也可以。
3. 使用 10 初始化也可以, 10 的类型是 int, 10L 的类型是 long, 使用 10 L 或者 10 l 更好一些。

---

3.短整型变量

有长就有短，所以这里我们也有短整型。

基本语法格式:

short 变量名 = 初始值;

写一个代码：

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

    }

为什么有短整型，因为当我们存储较小的值的时候，我们申请小一点的空间就够了，避免空间的浪费。但现代计算机也几乎不在乎这一点的空间了，所以这个范围小的类型不怎么使用。

注意事项:

1. short 占用 2 个字节, 表示的数据范围是 -32768 -> +32767
2. 这个表示范围比较小, 一般不推荐使用.

---

4.双精度浮点型变量

来了来了，肯定有同学问咋都说整数，这里小数就来了，双精度浮点型变量！就是为小数量身定做的。同样先听我细细道来：

基本语法格式：

double 变量名 = 初始值;

然后我们来写一个代码：

 public static void main(String[] args) {
        double num = 1.0;
        System.out.println(num);
        //打印 1.0
    }

这里打印的就是一个小数了。

当我们学习到这里的时候，我们可以去看一下这个代码：

代码1：

    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a / b);
        // 执行结果 0
    }

什么？这里居然是0？1/2不是0.5吗？

但是在这里，这里可是计算机，那管你，我们定义的int类型，也就是整形，计算出来的肯定得是整形（整形会直接舍弃小数部分），所以当我们如果想得到 0.5, 需要使用 double 类型计算。像下面这样子就可以啦：

public static void main(String[] args) {
        double a = 1.0;
        double b = 2.0;
        System.out.println(a / b);
        // 执行结果0.5
    }

代码2：

public static void main(String[] args) {
        double num = 1.1;
        System.out.println(num * num);

    // 执行结果1.2100000000000002

    }

Java 中的 double 虽然也是 8 个字节, 但是浮点数的内存布局和整数差别很大, 不能单纯的用 2 ^ n 的形式表示数据范围，简单的来说就是会有些许误差。

原因：Java 的 double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数,势必会存在一定的精度误差。

所以当我们需要进行相关运算而且需要保留一些值，我们就要用到相关的类型。

---

5.单精度浮点型变量

对于8个字节的双精度浮点型变量，那我们也会有单精度浮点型，对于单精度浮点型，我们就了解一下就好了。

基本格式:

float 变量名 = 初始值;

然后我们继续写一个代码来看看：

public static void main(String[] args) {
        float num = 1.0f;    // 写作 1.0F 也可以
        System.out.println(num);
        //打印 1.0
    }

这里和长整型一样，为了区分精度，这里对于单精度浮点类型，这里定义的时候就在后面加上F。

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

---

6.字符类型变量

整数有了小数有了，那字符呢，没错，我们还有字符类型变量，对于字符类型变量，且听我慢慢道来：

基本格式:

char 变量名 = 初始值;

我们也写一个代码看看：

 public static void main(String[] args) {
        char ch = 'A';
        System.out.print(ch);
        //打印 A
    }

同时，也可以使用一个字符表示一个汉字:

public static void main(String[] args) {
        char ch = '好';
        System.out.print(ch);
        //打印 好 
    }

有人就好奇了，字符看起来比较小，汉字大一点，那字符类型是多少字节的呢？来看注意事项：

注意事项:

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

---

7.字节类型变量

字节类型变量，也就是byte数据类型是8位、有符号的，以二进制补码表示的整数。

基本语法格式:

byte 变量名 = 初始值;

代码我们也写一个：

 public static void main(String[] args) {
        byte value = 120;
        System.out.println(value);
        //打印 120
    }

注意事项:

1. 字节类型表示的也是整数. 只占一个字节, 表示范围较小 ( -128 -> +127 )。
2. 字节类型和字符类型互不相干。

---

8.布尔类型变量

什么？前面的整形浮点型的能理解，这布尔类型是啥？其实，布尔类型比他们都要单纯，只有两个值，true和false。

基本语法格式:

boolean 变量名 = 初始值;

我们也写一个代码：

public static void main(String[] args) {
        boolean value = true;
        System.out.println(value);
        //打印 true
    }

我们再看看这个代码：

public static void main(String[] args) {
        boolean value = true;
        System.out.println(value + 1);//EOF
    }

这里报错了，编译会出现如下错误

Test.java:4: 错误: 二元运算符 ‘+’ 的操作数类型错误 System.out.println(value + 1); 第一个类型: boolean 第二个类型: int

注意：这里布尔类型是不能运算的！因为布尔类型只有ture和false两个值。所以对于布尔类型，我们需要注意下面几点：

注意事项:

1. boolean 类型的变量只有两种取值, true 表示真, false 表示假。
2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法。
3. boolean 类型有些 JVM 的实现是占 1 个字节, 有些是占 1 个比特位, 这个没有明确规定。

---

9.字符串类型变量

一环接一环，有了字符，怎么可以少得了句子呢，这里称之为字符串，把一些字符放到一起就构成了字符串。我们来看看语法：

基本语法格式:

String 变量名 = “初始值”;

然后同样的我们写一个简单的代码：

public static void main(String[] args) {
        String name = "shuaige";
        System.out.println(name);
        //打印 shuiage
    }

那这里由于有很多字符嘛，所以我们顺便说一下转义字符，我们的输出是不是一直都在同一行，也没有什么提升换行，或者搁空等，这时候就用到转义字符。

转义字符示例:

// 创建一个字符串 My name is "张三" 
String name = "My name is "张三"";

对于" “来说，是一种引用符号，所以一般表示的含义就不是单纯的引号，所以我们需要用 来将它转义。比如上面的打印的是"张三”，而不是就打印张三，所以在输入的时候要输入"张三"，两个引号前面的 都是为它们转义。

那么除了对这种特殊符号的转义，还有哪些转义字符呢？我们来看一下：

转义字符	解释
n	换行
t	水平制表符
’	单引号
"	双引号
	反斜杠

这就是转义字符。

回到我们的字符串类型变量，对于字符串类型变量中的运算，有以下几种：

1.字符串的 + 操作, 表示字符串拼接

  public static void main(String[] args) {
        String a = "hello";
        String b = "world";
        String c = a + b;
        System.out.println(c);
        //打印结果 hello world
    }

2.用字符串和整数进行拼接

public static void main(String[] args) {
        String str = "result = ";
        int a = 10;
        int b = 20;
        String result = str + a + b;
        System.out.println(result);
       //打印result = 1020
    }

以上代码说明, 当一个 + 表达式中存在字符串的时候, 都是执行字符串拼接行为.因此我们可以很方便的使用 System.out.println 同时打印多个字符串或数字。

对于字符串类型变量，还有一些需要注意的点就是：

1. Java 使用 双引号 + 若干字符 的方式表示字符串字面值。
2. 和上面的类型不同, String 不是基本类型, 而是引用类型(后面重点解释)。
3. 字符串中的一些特定的不太方便直接表示的字符需要进行转义。

---

二.带你玩转变量
1.变量的作用域

我们发现，上面的代码，都有main函数给它框住，那么作为变量，它是不是在每一个地方都起作用呢？这就涉及到变量的作用域了。

实际上它的定义很简单：

变量的作用域也就是该变量能生效的范围, 一般是变量定义所在的代码块(大括号)。

比如说我在main函数内创建的变量，在外面打印它，那肯定是不可以的，在里面才可以打印：

class Test { 
 public static void main(String[] args) { 
   { 
      int x = 10; 
      System.out.println(x); // 编译通过
   } 
 System.out.println(x); // 编译失败, 找不到变量 x！
 } 
} 

所以对于变量的作用域一定要想好，不要让它成为"局外人"！

---

2.变量的命名规则

对于变量，我们刚刚都是在说类型，那么对于变量名，也有一定的语法，就好像你的CSDN的名字一样，都是有一些规定的，我们来看一下：

首先是硬性指标:

1. 一个变量名只能包含数字, 字母, 下划线。
2. 数字不能开头。
3. 变量名是大小写敏感的.，即 num 和 Num 是两个不同的变量。

注意: 虽然语法上也允许使用中文/美元符($)命名变量, 但是强烈不推荐这样做，比如int 钱 = 5；，会很别扭。

这些是强制要求的，不这样做会报错，但是对于代码来说肯定不仅仅是我们自己写给自己看，所以对于命名，我们还有软性指标:

1. 变量命名要具有描述性, 见名知意。
2. 变量名不宜使用拼音(但是不绝对)。
3. 变量名的词性推荐使用名词。
4. 变量命名推荐小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单词首字母都大写。

对于上面的要求，并不是强制性的，但是是默认这样子做的，我们要形成良好的代码风格。对于小驼峰命名法，也就是两边小写中间有大写，像驼峰一样：

public static void main(String[] args) {
        int maxValue = 100;//max小写，Value首字母大写
        String studentName = "张三";
    }

---

3.常量

有变就有不变，上面讨论的都是各种规则的变量, 每种类型的变量也对应着一种相同类型的常量。

常量指的是运行时类型不能发生改变。

常量主要有以下两种体现形式：

1.字面值常量

字面值常量就好像它的字面一样，就是一个字面的意思。（上一次听这么容易理解的话还是上一次。）

其实就是实实在在的数字，在下面列出了各种类型是字面值常量：

10 // int 字面值常量(十进制) 
010 // int 字面值常量(八进制) 由数字 0 开头. 010 也就是十进制的 8 
0x10 // int 字面值常量(十六进制) 由数字 0x 开头. 0x10 也就是十进制的 16 
10L // long 字面值常量. 也可以写作 10l (小写的L) 
1.0 // double 字面值常量. 也可以写作 1.0d 或者 1.0D 
1.5e2 // double 字面值常量. 科学计数法表示. 相当于 1.5 * 10^2 
1.0f // float 字面值常量, 也可以写作 1.0F 
true // boolen 字面值常量, 同样的还有 false 
'a' // char 字面值常量, 单引号中只能有一个字符
"abc" // String 字面值常量, 双引号中可以有多个字符. 

2.final 关键字修饰的常量

final修饰的这个就比较容易了，就是在创建定义变量的时候，在前面加上一个final，也就是表示最终的意思嘛。

public static void main(String[] args) {
        final int a = 10;
        a = 20; // 编译出错！提示：无法为最终变量a分配值
    }

---

4.类型转换

当我们一个不小心的整形，闯进了长整型的世界，会怎么样，它字节不够啊，能不能活下来？我们来看一下：

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

①int 和 long/double 相互赋值

我们来看一下下面两段代码：

public static void main(String[] args) {
        int a = 10;
        long b = 20;
        //把长整型赋给整形
        a = b; // 编译出错!提示可能会损失精度. 

        //把整形赋给长整型
        b = a; // 编译通过. 
    }

public static void main(String[] args) {
        int a = 10;
        double b = 1.0;
        //把双精度浮点型赋给整形
        a = b; // 编译出错!提示可能会损失精度. 
     
        //把整形赋给双精度浮点型    
        b = a; // 编译通过. 
    }

在这里我们看见的是：long 表示的范围更大, 可以将 int 赋值给 long, 但是不能将 long 赋值给 int。double 表示的范围更大, 可以将 int 赋值给 double, 但是不能将 double 赋值给 int。

所以，这两段代码说明了：

不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之则不行

② int 和 boolean 相互赋值

这两对或者说对于boolean类型来说，和其他类型都是不兼容的，在上面我们也已经说到过了。这里代码展示：

public static void main(String[] args) {
        int a = 10;
        boolean b = true;
        b = a; // 编译出错, 提示不兼容的类型
        a = b; // 编译出错, 提示不兼容的类型
    }

所以：

int 和 boolean 是毫不相干的两种类型, 不能相互赋值。

③ int字面值常量 给 byte 赋值

对于byte类型，它的取值范围是比较小的，那么当我们赋值超出的时候，或者说将int的字面值常量赋过去，会怎么样呢？

我们来看看代码：

public static void main(String[] args) {
        byte a = 100; // 编译通过
        byte b = 256; // 编译报错, 提示：从int转换到byte可能会有损失。
    }

这里显示的是编译报错了，因为从int转换到byte可能会有损失！！

使用字面值常量赋值的时候, Java 会自动进行一些检查校验, 判定赋值是否合理。

---

5.强制类型转换

看了上面的有的人就会想，为什么不能强硬一点，没错，我们也有强硬的手段，强制类型转换！

强制类型转换就是在某个变量名前面加上括号和在括号里面写上你需要强制类型转换成的类型，比如a = (int)b;就是把b强制类型转换为int赋值给a的意思。

然后我们来看一些代码：

public static void main(String[] args) {
        int a = 0;
        double b = 10.5;
        a = (int)b;//编译成功,a的值为10
        
        int c = 10;
        boolean d = false;
        b = (boolean)a; // 编译出错, 提示不兼容的类型
    }

不是说好的强硬吗，为什么这里强制类型转换还是编译错误呢，因为虽然是有强制类型转换，但是，互不相干的类型之间是无法强转的！

所以我们有以下结论：

1. 强制类型转换可能会导致精度丢失. 如刚才的例子中, 赋值之后, 10.5 就变成 10 了, 小数点后面的部分被忽略。
2. 强制类型转换不是一定能成功, 互不相干的类型之间是无法强转的。

对于类型转换的总结来说就是：

1.不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型。

2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失。

3. 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查。

---

6.其他小细节

对于这些类型来说，还有一些小细节。

1.当 int 和 long 混合运算的时候, int 会提升成 long, 得到的结果仍然是 long 类型, 需要使用 long 类型的变量来接收结果。如果非要用 int 来接收结果, 就需要使用强制类型转换。

就比如int类型的a加上long类型的b，在运算的时候会先把int变成long，加完输出的也是long。

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

比如两个byte类型相加，实际上得到的值如果赋给其他变量，赋值的是int类型的，比如byte a加上byte b得到的值赋给byte c会报错，需要写成byte c =(byte)(a+b)，也就是当它们计算完还要强制类型转换回byte才能赋值给byte的c。

这就是基本数据类型。

---

这就是本篇变量数据类型的全部内容啦，如果觉得很不错或者感觉对你有帮助，不妨点赞关注一键三连，一起学习，共同努力！也可以期待这个系列接下来的博客噢。

链接：都在这里！ Java SE 带你从零到一系列

还有一件事：