【Java 基础语法】数据类型和运算符

缺乏、安全感 2021-09-13 19:32 507阅读 0赞

### 文章目录 ###

*   *  一、变量和类型
     *   *  1. 整型变量
         *  2. 长整型变量
         *  3. 双精度浮点型
         *  4. 单精度浮点型
         *  5. 字符类型变量
         *  6. 字节类型变量
         *  7. 短整型变量
         *  8. 布尔类型变量
         *  9. 字符串类型变量
         *  10. 变量的作用域
         *  11. 变量的命名规则
         *  12. 常量
         *  13. 理解数值提升
         *  14. int 和 String 之间的相互转换
     *  二、运算符
     *  三、 注释
     *  四、 关键字
     *  五、 总结

## 一、变量和类型 ##

在介绍下面各种类型之前我们先总的浏览一下有哪些类型（图中类型，以下并没有全部介绍，一些引用类型会在后面章节再介绍）![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center]

### 1. 整型变量 ###

1.  语法格式
    
    > int 变量名 = 初始值;
2.  代码示例
    
        int num = 10;
        System.out.println(num);
3.  注意事项
    
    >  *  在 Java 中，一个 int 变量占4个字节，和操作系统没有直接关系
    >  *  int 类型数据范围是 -231 ~ 231\-1，也就大概是 -21亿 ~ 21亿
    >  *  可以使用以下代码查看 Java 中的整形数据范围
    >     
    >         System.out.println(Integer.MAX_VALUE);	// int 的最大值
    >         System.out.println(Integer.MIN_VALUE);	// int 的最小值
    >  *  如果尝试将最大值加1的话，你会发现结果是最小值，如
    >     
    >         System.out.println(Integer.MAX_VALUE+1);	// 结果为-2147483648
    >     
    >     这其实和我在 [【剖析C语言数据在内存中的存储】][C] 这章画的 char 类型的圆形图很像，最小值减1就变成了最大值，最大值加1就变成了最小值
    >  *  如果你定义一个整型，初始化的值超过了 int 范围，如2147483648，你会发现报错，因为这是已经超出了 int 的最大范围。但是由于编译器不同，如果你将代码写成这样，也是可能通过的
    >     
    >         int a =2147483647 + 1;	// 2147483647为 int 的最大值

### 2. 长整型变量 ###

1.  语法格式
    
    > long 变量名 = 初始值;
2.  代码示例
    
        long num = 10L;
        System.out.println(num);
3.  注意事项
    
    >  *  定义一个长整形变量，初始值后面要加 L 或 l 会更好一些
    >  *  long 类型数据范围是 -263 ~ 263\-1
    >  *  可以使用以下代码查看 Java 中的长整形数据范围
    >     
    >         System.out.println(Long.MAX_VALUE);	// long 的最大值
    >         System.out.println(Long.MIN_VALUE);	// long 的最小值

### 3. 双精度浮点型 ###

1.  语法格式
    
    > double 变量名 = 初始值;
2.  代码示例
    
        double num = 1.0;
        System.out.println(num);
3.  注意事项
    
    >  *  在 Java 中，int 除以 int 的值任然是 int（会直接舍弃掉小数部分），如
    >     
    >         int a = 1;
    >         int b = 2;
    >         System.out.println(a/b);	// 结果为0
    >     
    >     将 int 改为 double 才能得到结果0.5
    >  *  Java 的 double 类型的内存布局遵守 IEEE 754 标准(和 C 语言一样)，尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差。我们看一段代码
    >     
    >         double num = 1.1;
    >         System.ou.println(num * num);
    >         // 结果为1.2100000000000002
    >     
    >     ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center 1]
    
    > 因为 double 可以精确表示11位，而之后的数都不是精确值，总结就是，小数没有精确值
    > 
    >  *  虽然 Java 中的 double 是8个字节，但是浮点数的内存布局和整数的差别很大，不能单纯的用 2n 的形式表示数据范围
    >  *  可以使用以下代码查看 Java 中的双精度浮点类型数据范围
    >     
    >         System.out.println(Double.MAX_VALUE);	// double 的最大值
    >         System.out.println(Double.MIN_VALUE);	// double 的最小值

### 4. 单精度浮点型 ###

1.  语法格式
    
    > float 变量名 = 初始值;
2.  代码示例
    
        float num = 1.0f;    // 也可以写作 1.0F
        System.out.println(num);
3.  注意事项
    
    >  *  float 类型的数值后有后缀 F 或 f，没有后缀的浮点数默认为 double 类型，也可后缀 D 或 d
    >  *  如果上述代码数值后没有 f，则会报错。因为 Java 是强类型语言，1.0 默认是 double 型，等号左右类型不匹配
    >  *  可以使用以下代码查看 Java 中的双精度浮点类型数据范围
    > 
    >     System.out.println(Double.MAX_VALUE);	// double 的最大值
    >     System.out.println(Double.MIN_VALUE);	// double 的最小值

### 5. 字符类型变量 ###

1.  语法格式
    
    > char 变量名 = 初始值;
2.  代码示例
    
        char ch = 'C';
        System.out.println(ch);
3.  注意事项
    
    >  *  在 Java 中的 char 是一个无符号的整数。为什么这么说呢，我们可以看一个代码
    >     
    >         char ch1 = 97;
    >         char ch2 = -7;
    >         System.out.println(ch1);	// 结果为 A
    >         System.out.println(ch2);	// 报错
    >     
    >     也因此 char 类型的范围在 0 ~ 216
    >  *  可以使用以下代码查看 Java 中的字符类型数据范围
    >     
    >         System.out.println(Character.MAX_VALUE);	// char 的最大值
    >         System.out.println(Character.MIN_VALUE);	// char 的最小值
    >     
    >     而最小值对应的字符是 `'\u0000'` ，最大值对应的字符是 `'\uFFFF'`。
    >  *  在 C 语言中 char 是一个字节，而在 Java 中 char 是两个字节，其表示的字符种类也更多，如有中文
    >  *  在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符
    >  *  执行 `javac` 编译含有中文的代码时可能报错，因为 Java 中使用 Unicode 编码字符，而编译时使用的是 `GBK` 解码，所以不能正确的将中文给编译出来。如果编译代码改成这样就可以了
    >     
    >         javac -encoding utf-8 文件名.java

### 6. 字节类型变量 ###

1.  语法格式
    
    > byte 变量名 = 初始值;
2.  代码示例
    
        byte value = 0;
        System.out.println(value);
3.  注意事项
    
    >  *  在 Java 中 byte 是一个字节，故其范围为 -128 ~ 127
    >  *  可以使用以下代码查看 Java 中的字节类型数据范围
    >     
    >         System.out.println(Byte.MAX_VALUE);	// byte 的最大值
    >         System.out.println(Byte.MIN_VALUE);	// byte 的最小值
    >  *  大家可以判断一下这段代码的结果是多少
    >     
    >         byte a = Byte.MAX_VALUE + 1;
    >         System.out.println(a);
    >     
    >     答案会像 int 类型一样变成该类型的最小值吗？不会，因为1是整形，占4个字节，两种类型计算的话都会先转化成 int 类型，然后又被转换为 byte 类型而丢失精度，故结果报错

### 7. 短整型变量 ###

1.  语法格式
    
    > short 变量名 = 初始值;
2.  代码示例
    
        short a = 0;
        System.out.println(a);
3.  注意事项
    
    >  *  可以使用以下代码查看 Java 中的短整型型数据范围
    >     
    >         System.out.println(Short.MAX_VALUE);	// short 的最大值
    >         System.out.println(Short.MIN_VALUE);	// short 的最小值

### 8. 布尔类型变量 ###

1.  语法格式
    
    > boolean 变量名 = 初始值;
2.  代码示例
    
        boolean value = true;
        System.out.println(value);
3.  注意事项
    
    >  *  boolean 类型的变量只有两种取值，true 表示真，false 表示假
    >  *  Java 的 boolean 类型和 int 不能相互转换，不存在 非0 表示 true, 0 表示 false 这样的用法
    >  *  JVM 规则下，没有明确 boolean 类型的大小，有些书里表明是占1个字节, 有些表明是占1个比特位

### 9. 字符串类型变量 ###

1.  语法格式
    
    > String 变量名 = “初始值”；
2.  代码示例
    
        String name = "LiXiaoBo";
        System.out.println(name);
3.  拼接用法
    
    > 1.  拼接：字符串和任意类型的数据，使用 “+” 号拼接后，其结果也是字符串，如
    > 
    >     int a = 10;
    >     System.out.println("a = " + a);
    > 
    > 再看一个代码
    > 
    >     int a = 10;
    >     int b = 20;
    >     System.out.println("ab = " + a + b);
    > 
    >     这个结果为 `ab = 1020` ，但是我再将代码改一下是多少呢？
    > 
    >     int a = 10;
    >     int b = 20;
    >     System.out.println(a + b + "= ab");
    > 
    > 结果为 `30 = ab` 。所以要注意，只有字符串在前面时，才能直接拼接，不然可能会先进行其他运算（但是如果字符串在前面后面有运算但是加了括号，还是先计算括号内的值）
    > 
    > 1.  如果字符串里有特殊字符，则需要加上转义符号，如
    > 
    >     String str = "hello \"吞吞吐吐大魔王\"";
    >     System.out.println(str);
    > 
    > 大家可以看一下特殊的转义字符有哪些
    > 
    > <table> 
    >  <thead> 
    >   <tr> 
    >    <th align="left"></th> 
    >    <th>特殊字符的转义序列</th> 
    >    <th></th> 
    >   </tr> 
    >  </thead> 
    >  <tbody> 
    >   <tr> 
    >    <td align="left">转义序列</td> 
    >    <td>名称</td> 
    >    <td>Unicode 值</td> 
    >   </tr> 
    >   <tr> 
    >    <td align="left">\b</td> 
    >    <td>退格</td> 
    >    <td>\u0008</td> 
    >   </tr> 
    >   <tr> 
    >    <td align="left">\t</td> 
    >    <td>制表</td> 
    >    <td>\u0009</td> 
    >   </tr> 
    >   <tr> 
    >    <td align="left">\n</td> 
    >    <td>换行</td> 
    >    <td>\u000a</td> 
    >   </tr> 
    >   <tr> 
    >    <td align="left">\r</td> 
    >    <td>回车</td> 
    >    <td>\u000d</td> 
    >   </tr> 
    >   <tr> 
    >    <td align="left">\ ‘’</td> 
    >    <td>双引号</td> 
    >    <td>\u0022</td> 
    >   </tr> 
    >   <tr> 
    >    <td align="left">\ ’</td> 
    >    <td>单引号</td> 
    >    <td>\u0027</td> 
    >   </tr> 
    >   <tr> 
    >    <td align="left">\ \</td> 
    >    <td>反斜杠</td> 
    >    <td>\u005c</td> 
    >   </tr> 
    >  </tbody> 
    > </table>
4.  注意事项
    
    > String 的类型其实与上面的内置类型不一样，它其实是**引用类型**。因为它所定义的变量叫做**引用变量**。按照示例代码，引用变量 name 里面存放的不是字符串`"LiXiaoBo"` ，而是将字符串所占的那片空间的地址存放在 name 里面

### 10. 变量的作用域 ###

和 C 语言类似，在 java 中，变量的作用域就是该变量能生效的范围，一般时变量定义所在的代码块内（相邻大括号中）

### 11. 变量的命名规则 ###

1.  硬性指标
    
    >  *  一个变量名只能包含数字、字母、下划线
    >  *  数字不能开头
    >  *  虽然语法上允许使用中文/美元符（$）命名变量，但是不推荐
2.  推荐
    
    >  *  变量名使用小驼峰命名法
    >  *  类名使用大驼峰命名法

以上简介了简单的、实用的命名规则，如果想知道在 java 中具体命名的一些规则，可以浏览 [第三章 Java的基本程序设计结构（1）][Java_1] 我写的这篇《Java 核心技术卷I》的阅读笔记里的内容

### 12. 常量 ###

概念

> 常量指的是运行时类型不能发生改变，主要有一下两种体现形式

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 关键字修饰的常量
    
    >  *  在 Java 中，利用关键字 final 指示常量，如
    > 
    >     final double CM_PER_INCH=2.54;
    > 
    >  *  关键字 final 表示这个常量只能被赋值一次，不可更改
    >  *  习惯上，常量名使用全大写
    >  *  final 还可以修饰函数（密封方法），还可以修饰类（密封类）。后期会详细的介绍

### 13. 理解数值提升 ###

如果大家对于类型转换与强制类型的使用有疑惑，可以直接去浏览 [第三章 Java的基本程序设计结构（1）][Java_1] 我写的这篇《Java 核心技术卷I》的阅读笔记里的内容。而这里我则举一些例子有助你更好的理解，如

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

这个如果编译其实会报错，为什么呢？因为 a 和 b 虽然都是 byte 类型，但是计算时会先将 a 和 b 都提升成 int 类型再进行计算，得到的结果也是 int 类型，然后赋值给 c 当然会报错。修改成这样就可以

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

由于计算机的 CPU通常是按照4个字节为单位从内存中读写数据，所以对于 byte 和 short 这种低于4个字节的类型，计算时我们要格外注意。因为他们会通常先提升为 int 类型

### 14. int 和 String 之间的相互转换 ###

1.  int 转换成 String
    
    >  *  法一
    >     
    >         int num = 10;
    >         String str1 = num + "";
    >  *  法二
    >     
    >         int num = 10;
    >         String str2 = String.valueOf(num);
2.  String 转换成 int
    
    >  *  法一
    >     
    >         String str = "100";
    >         int num = Integer.parseInt(str);
    >  *  法二
    >     
    >         String str = "100";
    >         int num = Integer.valueOf(str);

## 二、运算符 ##

在 java 中基本运算都和 C 语言中差不多，以下介绍一些不一样或者是特殊的情况

1.  % 表示取余，不仅可以对 int 求模，也能对浮点类型求模，如
    
        System.out.println(1.4%2);
        // 结果为 1.4
2.  对于复合运算符，如 +=、-=、\*=、/=、%= 等等，使用它们时，对于 byte 和 short 这种低于4个字节的类型，就不需要担心类型的问题。因为它会帮你自动进行类型的转换。如
    
        short a = 10;
        a = a + 20;
        System.out.println(a);
    
    这种情况编译就会报错，因为计算时 short 类型会先提升为 int 类型。但是如果使用增量运算符，就没有这种情况
    
        short a = 10;
        a += 20;
        System.out.println(a);
3.  & 和 | 如果操作数为 boolean 的时候，也表示逻辑运算。但是它们不支持短路运算
4.  在使用位运算符时，我们不仅要知道十进制与二进制的快速转化，还要知道八进制、十六进制和二进制的快速转换
    
    >  *  十六进制转二进制：一个十六进制数字对应4个二进制位，如
    > 
    >     int a = 0xf1;
    >     // f 转换成4个二进制位为 1111
    >     // 1 转换成4个二进制位为 0001
    >     // 0xf1 的二进制位为 11110001
    > 
    >  *  八进制转二进制：一个八进制数字对应3个二进制位，如
    > 
    >     int a = 072;
    >     // 7 转换成3个二进制位为 111
    >     // 2 转换成4个二进制位为 010
    >     // 072 的二进制位为 111010
5.  在 Java 中，移位运算符多了一个 >>> 符号，它叫做无符号右移。它与 >> 右移运算符不同的是，它右移时，高位补0。而 >> 运算符右移时，高位补符号位
    
    > 并且移位运算符我们需要知道下面的规律
    > 
    >  *  左移 n 位，相当于原数字乘以 2n
    >  *  右移 n 位，相当于原数字除以 2n

## 三、 注释 ##

Java 中的注释主要分以下三种

> 1.  单行注释：// 注释内容
> 2.  多行注释：/\* 注释内容 \*/ （不推荐）
> 3.  文档注释：/\*\* 文档内容 \*/ （常见于方法和类之上描述方法和类的作用，可用来自动生成文档）

注意

> 在使用注释时，如果注释内容里包括转义字符可能会出现错误，如
> 
>     // /u000a is a newline
> 
> 这是由于
> 
> 1.  Unicode 转义序列会在解析代码之前得到处理
> 2.  `\u000a` 的含义是换行符，故该语句后面的内容都换到下一行了。
> 
> 如果转义字符超过自己的数值范围，也会报错。

快捷键（注释和取消注释一样）

> 行注释：Ctrl + /
> 
> 块注释：Ctrl + Shift + /

## 四、 关键字 ##

关键字是 Java 中一些具有特定含义的单词。并且我们定义的变量名不能和关键字冲突。

我们先简单浏览 Java 中有哪些关键字吧！

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th></th> 
   <th></th> 
   <th></th> 
   <th></th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>用于定义访问权限修饰符的关键字</strong></td> 
   <td>private</td> 
   <td>protected</td> 
   <td>public</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><strong>用于定义类、函数、变量修饰符的关键字</strong></td> 
   <td>abstract</td> 
   <td>final</td> 
   <td>static</td> 
   <td>synchronized</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><strong>用于定义类与类之间关系的关键字</strong></td> 
   <td>new</td> 
   <td>this</td> 
   <td>super</td> 
   <td>instanceof</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><strong>用于异常处理的关键字</strong></td> 
   <td>try</td> 
   <td>catch</td> 
   <td>finally</td> 
   <td>throw</td> 
   <td>throws</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><strong>用于包的关键字</strong></td> 
   <td>package</td> 
   <td>import</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><strong>其他修饰符关键字</strong></td> 
   <td>native</td> 
   <td>strictfp</td> 
   <td>transient</td> 
   <td>volatile</td> 
   <td>assert</td> 
  </tr> 
 </tbody> 
</table>

## 五、 总结 ##

我的 Java 学习之旅已经开始啦！果然 C 语言学好了，再开始学习其他语言时会很舒服。希望自己继续努力，并且可以在学习的时候找到一种更加高效、专注的学习状态。也希望我的学习记录能给大家带来收获。奥里给！![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20210913/58658d6678fb41bda2f75f6730ae8e0d.png
[C]: https://blog.csdn.net/weixin_51367845/article/details/117343338
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20210913/e9fea88aae8d429697d22d2f7d226f7b.png
[Java_1]: https://blog.csdn.net/weixin_51367845/article/details/119301596
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTM2Nzg0NQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20210913/53f757b77d414b59ab10028f7d4c227e.png