Java基础语法-数据类型-类型转换-变量常量-运算符

末蓝、 2023-09-28 13:34 20阅读 0赞

#### 文章目录 ####

*   *  前言
     *  1.数据类型
     *  2.类型转换
     *   *  2.1 类型转换介绍
         *  2.2 自动类型转换
         *  2.3 强制类型转换
         *  2.4 类型转换规则
         *  2.5 JKD7扩展
     *  3.变量和常量
     *   *  3.1 变量的介绍
         *  3.2 变量作用域
         *  3.3 常量的介绍
         *  3.4 变量命名规范
     *  4.运算符
     *   *  4.1 算术运算符
         *   *  4.1.1 二元运算符
             *  4.1.2 取模运算
             *  4.1.3 一元运算符
         *  4.2 赋值运算符
         *  4.3 关系运算符
         *  4.4 逻辑运算符
         *  4.5 位运算符
         *  4.6 三目条件运算符
         *  4.7 字符串连接符
         *  4.8 扩展赋值运算符
         *  4.9 运算符的优先级

### 前言 ###

什么是字节

> 为了防止一些小伙伴不清楚计算机存储单位, 我贴心的帮大家"科普"一下
> 
> 如果知道的小伙伴, 可以直接去看数据类型

*  **位(bit)** : 是**计算机内部数据储存的最小单位**, 11001100是一个八位二进制数
 *  **字节(byte)** : 是计算机中数据处理的基本单位, 习惯上用大写B来表示
 *  **字符**: 是指计算机中使用的字母、数字、字和符号

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

*  1bit表示1位
 *  1Byte表示一个字节， 1B = 8b
 *  1024B = 1KB
 *  1024KB = 1M
 *  1024M = 1G

### 1.数据类型 ###

**语言分为: 强类型语言和弱类型语言, Java属于强类型语言**

*  **强类型语言**: **要求变量的使用严格符合规定, 所有变量必须先定义后才能使用**
 *  **弱类型语言**: **也称为弱类型定义语言。与强类型定义相反。像vb，php等就属于弱类型语言**

**Java的数据类型分为两大类**:

*  基本类型
 *  引用类型

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

**基本数据类型分为三大类：数值类型、字符类型、boolean类型**

**1.数值类型**

**数值类型又分为两类**：**整数类型和浮点类型**

**1.1整数类型**

*  **byte**: 占1个字节, 范围：-128 -> 127
 *  **short**: 占2个字节, 范围: -32768 -> 32767
 *  **int**: 占4个字节, 范围: -2147483848 -> 2147483847
 *  **long**: 占8个字节, 范围: -9223372036854775808 -> -9223372036854775807
    
        byte num1 = 10;
        short num2 = 20;
        int num3 = 30; // int最常用
        long num4 = 40L; // long类型需要在数字后面加上L便于区分

**1.2浮点类型**

*  **float**: 占4个字节
 *  **double**: 占8个字节
    
        float num5 = 40.1f;// float类型要在数字后面加上f
        double num6 = 3.1415926;

**2.字符类型**

*  **char**: 占2个字节
    
        // char类型只能存放一个单独的字符
        char name1 = 'A'; // 错误写法: char name1 = 'Aa';
        char name2 = '陈'; // 错误写法: char name1 = '小陈';

**3.boolean类型**

*  **boolean**类型: **占1位, 且值只有true和false两个**
    
        // boolean类型只有两个值, 一个为true一个为false
        boolean flag1 = true;
        boolean flag2 = false;

> 总结: 共有八大基本数据类型, 4个整数类型+2个浮点类型+1个字符类型+1个boolean类型
> 
> (引用数据类型后面讲)

### 2.类型转换 ###

#### 2.1 类型转换介绍 ####

**由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。**

*  **运算中，不同类型的数据先转化为同一类型，然后进行运算。**
 *  **转换从低级到高级(根据容量来看, 且浮点型高于整型)**
    
        低 --------------------------------------------> 高
        byte, short, char -> int -> long -> float -> double

**类型转换分为**:

*  **自动类型转换:** 从低级转到高级可以使用自动类型转换
 *  **强制类型转换:** 从高级转到低级必须使用强制类型转换

#### 2.2 自动类型转换 ####

**自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型。**

【比如】

*  short数据类型的位数为16位，就可以自动转换位数为32的int类型；
 *  float数据类型的位数为32，可以自动转换为64位的double类型。

【演示】

char name = 'a';
    int num1 = name;
    System.out.println(num1); // 97
    
    int num2 = 1024;
    double num3 = num2;
    System.out.println(num3); // 1024.0

【解析：由于小写字母a，查它对应的ASCII 码表可知对应的 int 类型值为 97，所以转换完成后是97】

#### 2.3 强制类型转换 ####

**强制类型转换，又被称为造型，用于显式的转换一个数值的类型，容量大的类型转换容量小的类型，必须使用强制转换**

*  在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。
 *  强制类型转换的语法格式： **(type)var** ，运算符“()”中的**type表示将值var想要转换成的目标数据类型**。 条件是转换的数据类型必须是兼容的。

【演示】

int num1 = 120;
    byte num2 = (byte) num1;
    System.out.println(num2); // 120
    
    double num3 = 120.67;
    float num4 = (float) num3;
    System.out.println(num4); // 120.67

#### 2.4 类型转换规则 ####

**数据类型转换必须满足如下规则**：

*  **不能对boolean类型进行类型转换**。
 *  **不能把对象类型转换成不相关类的对象**。
 *  在把**容量大的类型转换为容量小的类型时必须使用强制类型转换**。
 *  **转换过程中可能导致溢出或损失精度**，例如：
    
        int a = 128;
        // 强制转换a为byte类型
        byte b = (byte) a;
        System.out.println(a); // 128
        System.out.println(b); // -128
    
    因为 byte 类型是 8 位，最大值为127，所以当 int 类型强制转换为 byte 类型时，值 128 时候就会导致溢出, 从而导致结果出现错误。
 *  **浮点数到整数的转换是通过舍弃小数得到**，而**不是四舍五入**，例如：
    
        float c = 23.9f;
        int d = (int) c;
        System.out.println(d); // 23

#### 2.5 JKD7扩展 ####

**JDK7新特性：下划线分隔符**

*  在实际开发和学习中，如果遇到特别长的数字，读懂它令人头疼！JDK7为我们提供了下划线分隔符，可以按照自己的习惯进行分割, 方便我们阅读。
    
        // 随意按照自己的习惯分隔
        int money1 = 100_000_000
        int money2 = 1_0000_0000
          
        // 对结果没有任何影响
        System.out.println(money1); // 100000000
        System.out.println(money2); // 100000000

**JDK7新特性: 二进制整数**

*  我们在开发中也经常使用二进制整数，因此JDK7为我们直接提供了二进制整数的类型, 我们只要以：0b开头即。
    
        int num = 0b0101;

### 3.变量和常量 ###

#### 3.1 变量的介绍 ####

> 变量是什么：就是可以变化的量！
> 
> 我们通过变量来操纵存储空间中的数据，变量就是指代这个存储空间！空间位置是确定的，但是里面放置什么值不确定！ 打个比方：
> 
> 这就好像我们家里有一个大衣柜，里面有十分多的小格子，我们给格子上贴上标签，放衣服，放鞋子，放手表等等，此时我们知道了哪里该放什么，而这个标签就相当于我们的变量，我们给他起了个名字，但是里面要放什么需要我们自己去放。

**Java是一种强类型语言，每个变量都必须声明其类型。**

*  Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
 *  变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：
    
        //数据类型  变量名    =值;    后面可以使用逗号隔开来声明多个同类型变量
             type varName [=value] [{
              , varName [=value]}]

【注意事项】

*  每个变量都有类型，**类型可以是基本类型**，**也可以是引用类型**。
 *  变量名**必须是合法的标识符**。
 *  变量声明是一条完整的语句，因此**每一个声明都必须以分号结束**

【演示】

int a, b, c; // 同时声明三个int类型整数: a b c
    // 声明完可以单独对变量进行赋值
    a = 10;
    b = 20;
    c = 30;
    
    byte d = 40, e = 50, f = 60; // 同时声明三个byte变量并赋值
            
    System.out.println(a); // 10
    System.out.println(b); // 20
    System.out.println(c); // 30
    System.out.println(d); // 40
    System.out.println(e); // 50
    System.out.println(f); // 60

【编码规范】

*  **虽然可以在一行声明多个变量，但是不提倡这个风格，逐一声明每一个变量可以提高程序可读性。**

#### 3.2 变量作用域 ####

**变量根据作用域可划分为三种**：

*  **类变量**（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。
 *  **实例变量**（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。
 *  **局部变量**（lacal variable）：类的方法中的变量。

【示例】: 看不懂没关系, 我们先了解一下类变量, 实例变量, 局部变量分别写在什么位置

public class Test {
        
        // 类变量
        static int num = 10;
        // 实例变量
        String str = "Hello World";
        
        public void method() {
        
            // 局部变量: 定义在方法中
            String name = "小陈";
        }
    }

**局部变量** :

*  **方法或语句块内部定义的变量**, 生命周期是从声明位置开始到”\}”为止。
 *  在**使用前必须先声明并且初始化(赋初值)**。
 *  **局部变量没有默认值**，所以局部变量被声明后，**必须经过初始化**，才可以使用。

【示例】

public static void main(String[] args) {
        
        int i = 10; // 错误写法: int i;
        int j = i + 10;
        System.out.println(j); // 20
    }

**实例变量** :

*  **方法的外部、类的内部定义的变量**。
 *  从属于对象，生命周期伴随对象始终。
 *  如果不自行初始化，他会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

【示例】

public class Test {
        
        // 实例变量: 定义在类的内部，方法的外部
        int num = 100;
        String str = "Hello World";
    
        public static void main(String[] args) {
        
          	// 需要创建实例才能使用
            Test test = new Test();
            System.out.println(test.num); // 100
            System.out.println(test.str); // Hello World
        }
    }

**静态变量** :

*  **使用static定义**。
 *  从属于类，生命周期伴随类始终，从类加载到卸载。(注：讲完内存分析后我们再深入！先放一放这个概念！)
 *  如果不自行初始化，他会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

【示例】

public class Test {
        
        // 静态变量
        static double money = 2000;
        
        public static void main(String[] args) {
        
            // 可以直接在方法中使用
            System.out.println(money); // 2000.0
        }
    }

#### 3.3 常量的介绍 ####

**常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。**

*  所谓常量可以理解成一种特殊的变量，**它的值被设定后，在程序运行过程中就不允许再被改变**。
 *  语法如下
    
        // final 数据类型 变量名 = 值;
        final double PI = 3.1415926;
        final String NAME = "小陈";

【注意事项】

*  **常量名一般使用大写字符**。
 *  程序中**使用常量可以提高代码的可维护性**。

#### 3.4 变量命名规范 ####

1.  **所有变量、方法、类名：要做到见名知意**
2.  **类成员变量**：**首字母小写和驼峰原则 : monthSalary**
3.  **局部变量**：**首字母小写和驼峰原则 : monthSalary**
4.  **常量：大写字母和下划线：MAX\_VALUE**
5.  **类名：首字母大写和驼峰原则: Man, GoodMan**
6.  **方法名：首字母小写和驼峰原则: run(), runRun()**

### 4.运算符 ###

> **运算符operator**
> 
> **Java 语言支持如下运算符**：
> 
>  *  算术运算符: +，-，\*，/，%，++，–
>  *  赋值运算符 =
>  *  关系运算符: >，<，>=，<=，==，!= instanceof
>  *  逻辑运算符: &&，||，!
>  *  位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
>  *  条件运算符 ？：
>  *  扩展赋值运算符:+=，-=，\*=，/=

#### 4.1 算术运算符 ####

##### 4.1.1 二元运算符 #####

`+、-、*、/`

两个操作数，来看看我们小时候的数学运算, 其实都属于二元运算符；

public static void main(String[] args) {
        
        int a = 20;
        int b = 10;
        System.out.println("a + b =" + (a + b)); // a + b =30
        System.out.println("a - b =" + (a - b)); // a - b =10
        System.out.println("a * b =" + (a * b)); // a * b =200
        System.out.println("a / b =" + (a / b)); // a / b =2
    }

**整数运算** :

*  如果两个操作数**有一个为Long, 则结果也为long**
 *  **没有long时，结果为int。即使操作数全为shot,byte，结果也是int**.

【示例】

public static void main(String[] args) {
        
        int a = 10;
        long b = 100L;
        short c = 20;
        byte d = 30;
        // 运算有long类型, 运算结果就是long类型
        System.out.println((a + b + c + d));
        // 运算没有long类型, 那么就是int类型, 哪怕操作数中全是short和byte类型
        System.out.println((a + c + d)); // int类型 + short类型 + byte类型 结果是 int类型
        System.out.println((c + d)); // short类型 + byte类型 结果依然是 int类型
    }

**浮点运算** ：

*  如果**两个操作数有一个为double, 则结果为double**.
 *  只有**两个操作数都是float, 则结果才为float**.

【示例】

public static void main(String[] args) {
        
        float a = 12.34F;
        float b = 56.78F;
        double c = 3.14159;
    
        // 有一个为double, 结果为double类型
        System.out.println((a + c)); // double类型
        // 全为float才是float类型
        System.out.println((a + b)); // float类型
    }

##### 4.1.2 取模运算 #####

`%`

> 取模运算:
> 
>  *  其实就是我们小学的取余运算, 得到余数
>  *  其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004

**要点**：

*  负数%负数＝负数；
 *  负数%正数＝负数；
 *  正数%负数＝正数；

public static void main(String[] args) {
        
        System.out.println((9 % 2)); // 1
        System.out.println((-9 % -2)); // -1
        System.out.println((-9 % 2)); // -1
        System.out.println((9 % -2)); // 1
    }

【注：一般都是正整数运算，进行结果的判断！】

##### 4.1.3 一元运算符 #####

`++、--`

**自增（++）自减（–）运算符**是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，

*  比如: a++, 其实相当于 a = a + 1
 *  比如: a–, 就相当于 a = a - 1

【示例】

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

**而自增自减运算符是一个操作数，分为前缀和后缀两种。**

*  a++, 是先参加运算, 再自增,
 *  \++a, 是先自增, 再参加运算

【示例】

public static void main(String[] args) {
        
        int a = 1;
        int b = a++;
        int c = ++a;
        int d = a--;
        int e = --a;
        System.out.println(b); // 执行结果: 1; a先赋值给b, 然后自增加1, 此时a = 2
        System.out.println(c); // 执行结果: 3; a先自增加1, 然后赋值给b, 此时a = 3
        System.out.println(d); // 执行结果: 3; a先赋值给d, 然后自身减1, 此时a = 2
        System.out.println(e); // 执行结果: 1; a先自身减1, 然后赋值给b, 此时a = 1
    }

**java中的乘幂的处理**: 需要使用Math类, Math类提供了很多科学和工程计算需要的方法和常数。特殊的运算都需要运用到方法!

public static void main(String[] args) {
        
        double a = Math.pow(3, 2); // 错误写法: int a = 3 ^ 2;
        System.out.println(a); // 9.0
    }

#### 4.2 赋值运算符 ####

`=`

赋值运算符顾名思义是用来给变量赋值的, 将=右边的值赋值给=左边的变量

public static void main(String[] args) {
        
        // 将80赋值给num这个变量
        int num = 80;
        // 将"小陈"赋值给name
        String name = "小陈";
    
        System.out.println(num); // 80
        System.out.println(name); // 小陈
    }

#### 4.3 关系运算符 ####

`>、>=、<、<=、==、!=`

关系运算符返回一个布尔值(boolean)

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>例子</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>检查两个操作数是否相等, 如果相等则条件为真, 返回true, 反之返回false</td> 
   <td>(10 == 20) false</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>检查两个操作数是否不相等, 如果不相等则条件为真, 返回true, 反之返回false</td> 
   <td>(10 == 20) true</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>检查左操作数是否大于右操作数, 如果大于则条件为真, 返回true, 反之返回false</td> 
   <td>(10 &gt; 20) false</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>检查左操作数是否小于右操作数, 如果小于则条件为真, 返回true, 反之返回false</td> 
   <td>(10 &lt; 20) true</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>检查左操作数是否大于等于右操作数, 如果大于等于则条件为真, 返回true, 反之false</td> 
   <td>(10 &gt;= 20) false</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>检查左操作数是否小于等于右操作数, 如果小于等于则条件为真, 返回true, 反之false</td> 
   <td>(10 &lt;= 20) true</td> 
  </tr> 
 </tbody> 
</table>

【示例】

public static void main(String[] args) {
        
        int a = 10;
        int b = 20;
        System.out.println((10 == 20)); // false
        System.out.println((10 != 20)); // true
        System.out.println((10 > 20)); // false
        System.out.println((10 < 20)); // true
        System.out.println((10 >= 20)); // false
        System.out.println((10 <= 20)); // true
    }

#### 4.4 逻辑运算符 ####

`&&、||、!`

**逻辑运算符: 包含逻辑与, 逻辑或, 逻辑非**

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>描述</th> 
   <th>例子</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>| |</td> 
   <td>称为逻辑或运算符, 如果操作数有一个为真, 那么条件为真, 返回true</td> 
   <td>(1 == 2 || 3 == 3), 为真</td> 
  </tr> 
  <tr> 
   <td>&amp;&amp;</td> 
   <td>称为逻辑与运算符, 只有操作数全为真的时候, 条件才为真, 返回true</td> 
   <td>(1 == 2 &amp;&amp; 3 == 3), 为假</td> 
  </tr> 
  <tr> 
   <td>!</td> 
   <td>称为逻辑非运算符, 用来反转操作数的逻辑状态</td> 
   <td>!(1 == 2 &amp;&amp; 3 == 3), 为真</td> 
  </tr> 
 </tbody> 
</table>

逻辑与和逻辑或采用短路的方式。从左到右计算，如果确定值则不会再计算下去。

*  逻辑与只要有一个为false, 则直接返回false.
 *  逻辑或只要有一个为true, 则直接返回true;

【示例】

public static void main(String[] args) {
        
        boolean a = false;
        boolean b = true;
        System.out.println((a || b)); // 执行结果: true; 逻辑或运算符, 一个为真则为真
        System.out.println((a && b)); // 执行结果: false; 逻辑与运算符, 一个为假则为假
        System.out.println(!a); // 执行结果: true; 逻辑非运算符取反, 对a取反为true
        System.out.println(!b); // 执行结果: false; 逻辑非运算符取反, 对b取反为false
    }

#### 4.5 位运算符 ####

**Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型**  
**(byte)等类型。位运算符作用在所有的位上，并且按位运算**。

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>如果相对应位都是1, 则结果为1, 否则为0</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>如果相对应位都是0, 则结果为0, 否则为1</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>如果相对应位的值相同, 则结果为0, 否则为1</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>按位取反, 反转操作数的每一位, 即0变成1, 1变成0</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>按位左移运算符, 左操作数按位左移右操作数指定的位数</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>按位右移运算符, 右操作数按位右移左操作数指定的位数</td> 
  </tr> 
 </tbody> 
</table>

【示例】

/*
    	int num1 = 00111100;
    	int num2 = 00001101;
    	
    	num1 & num2 = 00001100
    	num1 | num2 = 00111101
    	num1 ^ num2 = 00110001
    	~num1 = 11000011
     */

public static void main(String[] args) {
        
        int num1 = 2;
        // 左移 相当于乘2; 左移几位, 就乘几个2
        System.out.println(num1 << 2); // 8; 相当于2 * 2 * 2
    
        int num2 = 16;
        // 右移 相当于除2; 右移几位, 就除几个2
        System.out.println(num2 >> 3); // 2; 相当于16 / 2 / 2 / 2
    }

#### 4.6 三目条件运算符 ####

`？ ：`

**三目条件运算符，语法格式**：

x ? y : z

*  **其中x为结果是boolean类型表达式，先计算x的值**
 *  **若x的值为true，则整个三目运算的结果为表达式y的值**
 *  **若x的值为false, 则整个运算结果为表达式z的值**

【演示】

public static void main(String[] args) {
        
        int score1 = 80;
        int score2 = 52;
        String result1 = score1 >= 60 ? "及格了" : "不及格";
        String result2 = score2 >= 60 ? "及格了" : "不及格";
        System.out.println(result1); // 及格了
        System.out.println(result2); // 不及格
    }

**三元运算符在真实开发中十分的常见，大家可以多练习使用，之后我们会讲解分支语句，可以利用三元  
运算符做到更加精简代码！便于理解！**

#### 4.7 字符串连接符 ####

`+`

**加号还有一个作用就是连接字符串**

*  **“+” 运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。**

【示例】

public static void main(String[] args) {
        
        String str = "Hello Java";
        int num = 100;
        // 会自动将num转为字符串类型再进行拼接
        System.out.println((str + num)); // Hello Java100
    }

#### 4.8 扩展赋值运算符 ####

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>用法举例</th> 
   <th>等效表达式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+=</td> 
   <td>a += b</td> 
   <td>a = a + b</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>a -= b</td> 
   <td>a = a - b</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>a *= b</td> 
   <td>a = a * b</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>a /= b</td> 
   <td>a = a / b</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>a %= b</td> 
   <td>a = a % b</td> 
  </tr> 
 </tbody> 
</table>

**以上运算符就相当于是一种简写的方式, 这种写法非常常用**

【示例】

public static void main(String[] args) {
        
        int a = 10;
        int b = 3;
        System.out.println((a += b)); // 13; 等效于 a = 10 + 3
        System.out.println((a -= b)); // 10; 等效于 a = 13 -10
        System.out.println((a *= b)); // 30; 等效于 a = 10 * 3
        System.out.println((a /= b)); // 10; 等效于 a = 30 / 3
        System.out.println((a %= b)); // 1; 等效于 a = 10 % 3
    }

#### 4.9 运算符的优先级 ####

> 我们小学都学过：先加减，后乘除，所以优先级这个概念我们并不陌生。
> 
> 当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。
> 
> 在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

**下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部**

**大家不需要去刻意的记住，表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余  
的代码运算！**  
表的底部\*\*

**大家不需要去刻意的记住，表达式里面优先使用小括号来组织！！方便理解和使用，不建议写非常冗余  
的代码运算！**