第四章、运算符和Boolean

**

第四章、运算符和boolean

**

摘要

如果你看了我前面两篇文章，那么你就正式入门了，那么我们接下来的学习就是按照一个系统性学习的步骤以及讲解来给大家进行学习。
还想说的一句就是：如果你感兴趣，想跟着一直学，那么你就可以关注并且点赞了。我后面的章节会一步步的讲述Java，直到可以拿到8k薪资左右的程度。
1.赋值运算符

1. 语法：变量名 = 表达式;（前提必须先声明一个变量才可以使用声明的变量名）。

2. 表达式：表达式就是运算符（如加号、减号）与操作数（如b，3等）的组合。

3. 举例：

   int a;
   int b = 10;
   a = (b + 3) + (b - 1);
   解释：其中，a、b为声明的两个int类型的变量，(b + 3)、(b - 1)、(b + 3) + (b - 1)都叫表达式，这里的“=”为赋值符号。

4. 例题：学员王浩的Java成绩是80分，学员张萌的Java成绩与王浩的相同，输出张萌的成绩。

   int wangScore = 80;//王浩成绩
   int zhangScore;//张萌成绩
   zhangScore = wangScore;
   System.out.println(“张萌成绩是" +zhangScore);

2.如何从控制台输入内容

1. 创建一个main方法：

   public static void main(String[] args){

   }

2. 获取扫描工具：在main方法中创建一个扫描器对象(Scanner)：Scanner input = new Scanner(System.in);（其中，Scanner为类名，input为对象名，与变量名的意义一样，System.in代表手动输入，此为面向对象，以后再讲）

   public static void main(String[] args){
   Scanner input = new Scanner(System.in);
   }

3. 识别扫描工具：因为不认识Scanner,所有需要介绍Scanner，在代码第一行介绍（来自java.util(工具))：import java.util.Scanner;

   import java.util.Scanner;
   public static void main(String[] args){
   Scanner input = new Scanner(System.in);
   }

4. 通过扫描器对象输入对应的值类型：

   • 获取输入的int类型的数据：int a = input.nextInt();(常用)
   • 获取输入的long类型的数据：long b = input.nextLong();
   • 获取输入的byte类型的数据：byte c = input.nextByte();
   • 获取输入的short类型的数据：short d = input.nextShort();
   • 获取输入的float类型的数据：float e = input.nextFloat();
   • 获取输入的double类型的数据：double f = input.nextDouble();(常用)
   • 获取输入的字符串类型的数据（注意：没有直接获取char类型的数据，只能获取字符串类型）：String g = input.next();(常用)

3.算数运算符

• 基本的算术运算符

• 基本运算符种类：+(加)、-(减)、*(乘)、/(除)、%(模，即取余数的意思)、++(加1)、–(减1)、+=(本身加某个数等于本身)、-=(本身减某个数等于本身)。

• 算术运算的语法：操作数 运算符 操作数。

• 加、减、乘、除、模举例：

  1. 从控制台输入学员王浩Java、SQL、html3门课程成绩，编写程序实现输出：（1）打印出输入的三门课成绩；（2）Java课和SQL课的分数之差；（3）3门课的平均分。

     //源代码
     Scanner input = new Scanner(System.in);
     System.out.println(“请输入Java的成绩：”);
     double java = input.nextDouble();
     System.out.println(“请输入SQL的成绩：”);
     double sql = input.nextDouble();
     System.out.println(“请输入html的成绩：”);
     double html = input.nextDouble();
     //定义差与平均数的变量用来存储结果
     double differ;//差
     douhle avg;//平均数

     System.out.println(“三门课的成绩分别为：Java=”+java+“分,SQL=”+sql+“分,html=”+html+“分”);
     differ = java-sql;//计算Java课和SQL课的成绩差
     System.out.println(“Java课和SQL课的分数之差为：”+differ+“分”);
     avg = (java+sql+html)/3;//计算平均分
     System.out.println(“3门课的平均分为：”+avg+“分”);

     //执行结果
     请输入Java的成绩：
     88
     请输入SQL的成绩：
     67
     请输入html的成绩：
     99
     三门课的成绩分别为：Java=88.0分,SQL=67.0分,html=99.0分
     Java课和SQL课的分数之差为：21.0分
     3门课的平均分为：84.66666666666667分

  2. 求163除以5的商与余数并打印。

     //源代码
     int num1 = 5;
     int num2 = 2;
     int a = num1 % num2;
     int b = num1 / num2;
     System.out.println(num1 + " % " + num2 + "= " + a);
     System.out.println(num1 + " / " + num2 + " = " + b);
     //执行结果
     5 % 2= 1
     5 / 2 = 2

• 4.3.2 ++、–、+=、-=的使用

  1. ++：某个变量的本身加上1。（–同理）。

     • 例1：定义一个变量int a = 10;执行++之后的结果。

       //源代码
       int a = 10;
       a++;//a++相当于a = a + 1
       System.out.println("a="a);

       //最后a的结果
       a = 11

     • 例2：定义一个变量int a = 10;执行打印**a++**之后的结果。

       //源代码
       int a = 10;
       System.out.println(“a=”+(a++));
       System.out.println(“a2=”+a);

       //执行结果
       a = 10;//原因：在打印语句System.out.println(“a=”+(a++))中，是先打印a然后再将a加上1。
       a2 = 11;

     • 例3：定义一个变量int a = 10;执行打印**++a**之后的结果。

       //Java代码
       int a = 10;
       System.out.println(“a=”+(++a));

       //执行结果
       a = 11;//原因：在打印语句System.out.println(“a=”+(++a))中，是先将a加上1然后再将打印a。

     • 注意：++的位置不同，执行先后顺序不同

       • a++，先对a进行操作，再执行加1。
       • ++a，先加上1，再对a进行操作。

  2. +=：本身加某个数等于本身(-=同理)。

     //Java代码
     int a = 10;
     a += 5;//相当与a = a +5;程序术语：把a的值加上5再赋值给a
     System.out.println("a="a);

     //执行结果
     a = 15

• 4.3.3 算术运算符综合练习

  1. 根据天数（46）计算周数和剩余的天数。

     //Java代码
     int days = 46; //天数
     int week = days / 7; //周数
     int leftDay = days % 7;//剩余的天数
     System.out.println(“周数=”+week);
     System.out.println(“剩余天数=”+leftDay);

     //执行结果
     周数=6
     剩余天数=4

  2. 定义一个整形变量比如:int a = 98765;然后依次输出各个位上的数字。

     //Java代码
     int a = 98765;
     int w=a/10000%10
     int q=a/1000%10
     int b=a/100%10;
     int s=a/10%10;
     int g=a/1%10
     System.out.println(“个位=”+g+"，十位="+s+"，百位="+b+"，千位="+q+"，万位="+w);

     //执行结果
     个位=5，十位=6，百位=7，千位=8，万位=9

• 4.3.4 注释的快捷键

  • 选中要注释的内容，按Ctrl+/。选中已经被注释的内容按Ctrl+/还原。
  • 选中要注释的内容，按Ctrl+shift+/。但是这种不能还原。只能Ctrl+z撤回。

4.基本数据类型转换
- 概念：数据类型在声明变量时就已经确定，所以当数据类型需要发生改变时要就要进行数据类型之间的转换，比如int类型需要转换成long类型的数据时等等。

• 4.4.2 基本数据类型排序

  • 按照字节排序：byte 1字节 < char 2字节 = short 2字节 < int 4字节 < float 四字节 < long 八字节 < double 八字节;boolean 不参与排序。
  • 按照转换排序：byte < short < char < int < long < float < double。boolean 不参与排序。

• 4.4.3 数据类型转换的两种形式

  • 自动转换：

    1. 符合条件：

       • 当转化后的数据类型大于需要转换的数据类型时(目标类型大于源类型，例如double型大于int型)
       • 两种类型要兼容(例如：数值类型（整型和浮点型）互相兼容，而字符类型与数字类型就不兼容)。

    2. 语法：目标类型 = 源类型表达式。

    3. 例1： 将一个int类型的数据转换成double类型的数据。

       //Java代码
       double a;
       int b = 20;
       a = b;//将b的值赋给a，因为b是int类型，a是double类型，double>int，所以自动转换
       System.out.println(“a=”+a+",b="+b);

       //执行结果
       a=20.0,b=20 //a为20.0证明a是已经是double类型的数据

    4. 例2： 一个int类型的数据加上一个double类型的数据。

       //Java代码
       int a = 10;
       double b = 2.3;
       System.out.println(“a=”+a+",b="+b+",c="+(a + b));
       //执行结果
       a=10,b=2.3,c=12.3

    5. 结论：一个表达式中，如果数据类型不一致，其结果为大的数据类型。这个称为隐式转换。

  • 强制转换：

    1. 符合条件：

       • 当转化后的数据类型小于需要转换的数据类型时。
       • 两种类型要兼容。

    2. 语法：目标类型 = （目标类型名）源类型表达式。

    3. 例1：将double类型的数据转换为int类型的数据。

       //Java代码
       int b = (int)10.2;
       double a = 10;
       int c = (int)a;

       //执行结果
       a=5.66,10,c=5

       结论：强制转换会失真，即会丢失一些数据。

    4. 例2：表达式进行转换。

       //Java代码
       int a = 10;
       double b = 20.55;
       int c1 = (int)(a+b)*3;
       int c2 = (int)((a+b)*3);
       System.out.println(“c1=”+c1+",c2="+c2);

       //执行结果
       c1=90,c2=91

       结论：强制转换只会与最近的数有关系，有括号则先运行括号。没有括号之后运行强制转换，再运行先乘除，后加减。

    5. 例3：将char类型与byte、short、int、long之间进行比较。

       //byte与char相互转
       byte a = 100;
       char aa = (char) a;
       char bb = ‘a’;
       byte b = (byte) bb;

       //byte与char相互转
       short c = 100;
       char cc = (char) c;
       char dd = ‘a’;
       short d = (short) dd;

       int e = 100;
       char ee = (char) e;
       char ff = ‘a’;
       int f = ff;//int比char大，直接转

       结论：char与byte、short之间的关系为相互转换的关系，与int以上的数据为大小转换关系。原因：中文对应的ASCII为127之后，一般是几万。

• 4.4.4 +=与写全的区别：short a = 10，a += 11与a = a + 11有区别吗？

  short a = 10;
  a += 11;//不报错
  a = a + 11;//a + 11会报红线，原因：a是short类型的数据，11是int类型的数据，所以a+11的结果是int的类型的数据，所以正确的写法是：
  a = (short) (a + 11);
  a += 11不报错是因为系统自动做了强制转换a = (short) (a + 11);过程。

• 4.4.5 类型转换总结：小转大，自动转。大转小，须强转。

4.5、boolean类型的使用

1. 为什么要用boolean类型的数据：在生活中我们经常会以下这些问题：

   • 一件艺术品是真货还是假货
   • 地铁2号线的首发车时间是5：00吗
   • 这次考试成绩在90分之上吗

2. boolean（布尔）类型的值(java中真用true或flase表示)

   • 真：true
   • 假：false

3. 例1：从控制台输入张三同学的成绩，与李四的成绩（80分）比较，输出“张三的成绩比李四的成绩高吗?” 的判断结果

   int liSi = 80; //学员李四成绩
   boolean isBig ; //声明一个boolean类型的变量

   Scanner input = new Scanner(System.in);
   System.out.print("输入学员张三成绩: "); //提示要输入学员张三的成绩
   int zhangSan = input.nextInt(); //输入张三的成绩

   isBig = zhangSan > liSi ; //将比较结果保存在boolean变量中
   System.out.println( “张三成绩比李四高吗?”+isBig ); //输出比较结果

---

4.6 关系运算符

1. 为什么使用关系运算符：当事物之间需要进行比较时，就要用到关系运算符。

   • 张三的考试成绩是否比李四高
   • 大象是否比乌龟更长寿
   • 篮球跟地球一样大吗

2. 常用的关系运算符有哪些：>(大于)、<(小于)、==(等于)、!=(不等于)、>=(大于等于)、<=(小于等于)、比较字符串是否相等（字符串之间只会比较是否相等）

   • 比较字符串语法：字符串.equals(需要比较的字符串)，例如：“abc”.equals(“abcd”)，这里代表：abc字符串与abcd字符串相等吗？显然是不想等的，所以结果为假。
   • 数学中符号的差异：≠不等于 ≥大于等于 ≤小于等于

3. 生活中的关系举例：

   张三的成绩80 > 李四的成绩90 假
   大象的寿命 < 乌龟的寿命 真
   篮球的大小 == 地球的大小 假
   “张三”.equals(“李四”) 假
   结论：关系运算符的作用：用来做比较运算。比较的结果：boolean类型

---

4.7 基本if选择结构

1. 为什么需要if选择结构：比如，张浩的Java考试成绩大于98分，张浩就能获得一个MP4作为奖励。

2. 基本的if选择结构：

   • 语法：

     if ( 条件 ) {//条件的结果：必须是boolean值
     //代码块（如果代码块只有一条语句时，可以省略{}达到相同效果，但是不建议省略，会导致代码修改起来很麻烦）
     }
     //或者
     if()
     //代码块，此代码块与if有关的只能有一行

   • 例：张浩的Java考试成绩大于98分，张浩就能获得一个MP4作为奖励。

     Scanner input = new Scanner(System.in);
     System.out.print("输入张浩的Java成绩: "); //提示输入Java成绩
     int score = input.nextInt(); //从控制台获取张浩的Java成绩
     if ( score > 98 ) { //判断是否大于90分
     System.out.println(“老师说:不错，奖励一个MP4！”);
     }

---

4.8 if-else选择结构

• 4.8.1 if-else选择结构：为什么使用if-else选择结构。如果张浩Java考试成绩大于98分，老师就奖励他一个MP4，否则老师就罚他进行编码。

  • 语法：

    if ( 条件 ) {
    //代码块1
    }else { //else不能单独使用，当只有一条语句时，也可以省略花括号{}
    //代码块2
    }

    if (张浩Java成绩 > 98 ) {
    	奖励一个MP4；
    }else {
           惩罚进行编码；
    }
    

  • 例：如果张浩Java考试成绩大于98分，老师就奖励他一个MP4，否则老师就罚他进行编码。

    int score = 91; // 张浩的Java成绩
    if (score > 98) {
    System.out.println(“老师说:不错，奖励一个MP4！”);
    } else {
    System.out.println(“老师说:惩罚进行编码！”);
    }

• 4.8.2 三目运算符(? 😃，也叫：三元表达式，三元运算符

  • 语法：条件表达式?值1:值2

  • 运算规则：若条件表达式的值为true，则整个表达式取“值1”，否则取“值2”

  • 例：定义三个int变量int a=1;int b=2;int c，如果a>b则输出c=1，否则输出c=0。

    int a=1;
    int b=2;
    int c= a>b?1:0;
    结果c 为0
    //a>b 为条件，后面当条件为true时返回":“前面的结果，反之返回”:"后面的结果
    //等价于if…else语句：
    int a = 1;
    int b = 2;
    int c;
    if(a>b){
    c = 1;
    } else {
    c = 0;
    }

---

4.9 逻辑运算符

• 4.9.1 为什么使用逻辑运算符

  • 10个人中大于35岁并且小于55岁的人有多少
  • 买房是本地户口、或者本科学历或者在长沙本地交一年以上的社保
  • 去银行办理银行卡必须本人，并且本人身份证

• 4.9.2 有哪些逻辑运算符：&(逻辑与)、&&(短路与)、|(逻辑或)、||(短路或) 、!（逻辑非）、^（逻辑异或）

  • • 逻辑&与短路&&的区别：

  • 与的作用(包括&&和&)：整个表达式中，只要有一个条件为假，则整个表达式为假。当整个表达式所有条件为真时，整个表达式才为真。

  • 逻辑&的运算

    boolean b = false;
    int i = 10;
    if(b&(i++)>0){
    System.out.print(“为真，进来：”+i);
    }else {
    System.out.print(“为假，进来：”+i);
    }
    //执行结果：输出11，&右边进行了运算
    为假，进来：11

  • 短路&&的运算

    boolean b = false;
    int i = 10;
    if(b&&(i++)>0){
    System.out.print(“为真，进来：”+i);
    }else{
    System.out.print(“为假，进来：”+i);
    }
    //执行结果：输出10，&&右边没有进行运算
    为假，进来：10

  • 总结：

    • &：不管&的左边是true还是false，右边都会进行运算
    • &&： 只要左边是false，右边就不会进行运算
    • 大多数情况下都会选择&&，因为这样可以提高效率，也可以进行异常处理，当右边产生异常的时候，同样可以跳过。

  • 逻辑| 与短路||的区别：

    • 或的作用（包括|和||）：整个表达式中只要有一个条件为真，整个表达式就为真。否则如果整个表达式所有的条件都为假，则整个表达式为假。

    • 逻辑 | 的的运算

      boolean a = true;
      int i = 10;
      if(a|(i++)>0){
      System.out.println(“为真，进来：”+i);
      }else{
      System.out.println(“为假，进来：”+i);
      }
      //执行结果：输出11，|的右边进行了运算
      为真，进来：11

    • 短路 || 的运算

      boolean a = true;
      int i = 10;
      if(a||(i++)>0){
      System.out.println(“为真，进来：”+i);
      }else{
      System.out.println(“为假，进来：”+i);
      }
      //执行结果：输出10,即||的右边没有运算
      为真，进来：10

    • 总结：

      • | ： 当左边为true时，右边同样进行运算
      • || ： 当左边为true时，右边不再进行运算，只有左边为false会继续往后运算。
      • 大多数情况会选择||，理由同&与&&。

  • !（逻辑非）：放到一个结果为boolean类型表达式的前面。表示非false则true，非true则false。

    int a = 3;
    int b = 4;
    int c = 5;
    System.out.println(!(a > b)); //!false = true
    System.out.println(!(a < b)); //!true = false
    System.out.println(!!(a > b)); //!!false = false
    System.out.println(!!!(a > b)); //!!!false = true
    //执行结果
    true
    false
    false
    true

  • ^（逻辑异或）：放在两个结果为boolean类型表达式的中间。表示相同为false，不同为true。

    int a = 3;
    int b = 4;
    int c = 5;
    System.out.println((a > b) ^ (a > c)); //false ^ false = false
    System.out.println((a > b) ^ (a < c)); //false ^ true = true
    System.out.println((a < b) ^ (a > c)); //true ^ false = true
    System.out.println((a < b) ^ (a < c)); //true ^ true = false
    System.out.println((a > b) ^ (a > c) ^ (a != b));//(false ^ false)^ true = true
    //执行结果
    false
    true
    true
    false
    true

• 4.9.3 使用复杂条件下的if选择结构：张浩Java成绩大于98分，而且音乐成绩大于80分，老师奖励他；或者Java成绩等于100分，音乐成绩大于70分，老师也可以奖励他。

  int score1 = 100; // 张浩的Java成绩
  int score2 = 72; // 张浩的音乐成绩
  if ( ( score1 >98&& score2 > 80 ) || ( score1 == 100 && score2 > 70 ) ){
  System.out.println(“老师说:不错，奖励一个MP4！”);
  }

---

4.10 位运算符

• 4.10.1 什么是位运算：程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算说穿了，就是直接对整数在内存中的二进制位进行操作。所位运算是所有运算中速度最快的。

• 4.10.2 Java提供的位运算符：左移( << )、右移( >> ) 、无符号右移( >>> ) 、位与( & ) 、位或( | )、位非( ~ )、位异或( ^ )，除了位非( ~ )是一元操作符外，其它的都是二元操作符。位运算符的优势：运行速度是计算中最快的。

  1. 左移( << )

     System.out.println(“5左移2位的值：”+(5<<2));//运行结果是20
     运行结果是20，但是程序是怎样执行的呢？
     首先会将5转为2进制表示形式(java中，整数默认就是int类型,也就是32位):
     0000 0000 0000 0000 0000 0000 0000 0101
     然后左移2位后，低位补0：
     0000 0000 0000 0000 0000 0000 0001 0100
     换算成10进制为20（算法：12^4+0*23+12^2+0*21+02^0）任何数的0次幂（方）的结果是1。
     小结:类似于：52^2。第一个2是固定的，第二个2是<<后中的2。

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CsL1F9li-1615804726531)(课上图片/1二进制转十进制.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sj6hRCqi-1615804726536)(课上图片/1十进制转二进制.png)]

  2. 右移( >> )

     System.out.println(5>>2);//运行结果是1
     还是先将5转为2进制表示形式：
     0000 0000 0000 0000 0000 0000 0000 0101
     然后右移2位，高位补0：
     0000 0000 0000 0000 0000 0000 0000 0001
     小结：类似于：5/(2^2)。最后得到的是商。

  3. 无符号右移( >>> )：忽略符号位，空位都以0补齐。（有符号右移中：正数高位用0补位，负数高位用1补位）

     System.out.println(5>>3);//结果是0
     System.out.println(-5>>3);//结果是-1
     System.out.println(-5>>>3);//结果是536870911

     我们来看看它的移位过程(可以通过其结果换算成二进制进行对比)：
     5换算成二进制： 0000 0000 0000 0000 0000 0000 0000 0101
     5右移3位后结果为0，0的二进制为： 0000 0000 0000 0000 0000 0000 0000 0000 // (用0进行补位)
     -5换算成二进制： 1111 1111 1111 1111 1111 1111 1111 1011
     //-5转化成二进制过程：
     //第一步：将5转化成二进制
     //0000 0000 0000 0000 0000 0000 0000 0101
     //第二步：取反
     //1111 1111 1111 1111 1111 1111 1111 1010
     //第三步：将二进制数加上1（如果加的位上位1，则进位）
     //1111 1111 1111 1111 1111 1111 1111 1011
     -5右移3位后结果为-1，-1的二进制为：1111 1111 1111 1111 1111 1111 1111 1111 // (用1进行补位)
     //负数计算：取反，然后计算结果后加上1，最后在前面加个负号。
     -5无符号右移3位后的结果 536870911 换算成二进制：0001 1111 1111 1111 1111 1111 1111 1111 // (用0进行补位)

     结论：通过其结果转换成二进制后，我们可以发现，正数右移，高位用0补，负数右移，高位用1补，当负数使用无符号右移时，用0进行部位(自然而然的，就由负数变成了正数了)

  4. 位与( & )

     System.out.println(5 & 3);//结果为1
     将2个操作数和结果都转换为二进制进行比较：
     5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101
     3转换为二进制：0000 0000 0000 0000 0000 0000 0000 0011

     1转换为二进制：0000 0000 0000 0000 0000 0000 0000 0001

     位与：第一个操作数的的第n位于第二个操作数的第n位如果都是1，那么结果的第n为也为1，否则为0。可以理解为：相同位上的数相乘的结果。

  5. 位或( | )

     System.out.println(5 | 3);//结果为7
     5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101
     3转换为二进制：0000 0000 0000 0000 0000 0000 0000 0011

     7转换为二进制：0000 0000 0000 0000 0000 0000 0000 0111

     位或操作：第一个操作数的的第n位于第二个操作数的第n位 只要有一个是1，那么结果的第n为也为1，否则为0

  6. 位异或( ^ )

     System.out.println(5 ^ 3);//结果为6
     5转换为二进制：0000 0000 0000 0000 0000 0000 0000 0101
     3转换为二进制：0000 0000 0000 0000 0000 0000 0000 0011

     6转换为二进制：0000 0000 0000 0000 0000 0000 0000 0110

     位异或：第一个操作数的的第n位于第二个操作数的第n位 相反，那么结果的第n为也为1，否则为0

  7. 位非( ~ )：位非是一元操作符

     System.out.println(~5);//结果为-6
     5转换为二进制： 0000 0000 0000 0000 0000 0000 0000 0101
     //负数转换过程
     -6转换为二进制：1111 1111 1111 1111 1111 1111 1111 1010
     位非：操作数的第n位为1，那么结果的第n位为0，反之。

  8. 由位运算操作符衍生而来的有：&= 按位与赋值、|= 按位或赋值、^= 按位非赋值、>>= 右移赋值、>>>= 无符号右移赋值、<<= 赋值左移
     和 += 一个概念而已。例如：

     int a = 10;
     a += 10;//相当于a = a + 10;
     a &= 2;//相当于a = a & 2;

---

4.11 运算符的优先级

• 4.11.1 优先级举例：

  • 举例：( score1 >98&& score2 > 80 ) || ( score1 == 100 && score2 > 70 )

  • 最高的优先级：小括号，即( )

  • 最低的优先级：赋值运算符，即=

  • 优先级顺序：括号 > 正负号 > 增量减量运算 > 算术运算 > 比较运算 > 逻辑运算 > 赋值运算。

  • 优先级表：

    优先级 描述 运算符
    1 括号 ()
    2 正负号 +、-
    3 一元运算符 ++、–、！
    4 乘除模（二元运算符） *、/、%
    5 加减 +、-
    6 移位运算 >>、>>>、<<
    7 比较大小 <、>、<=、>=
    8 比较是否相等 ==、!=
    9 位与运算 &
    10 位异或运算 |
    11 逻辑与运算 &&
    12 逻辑或运算 ||
    13 三元运算符 ?:
    14 赋值运算符 =

• 4.11.2 快速导包

  1. 方法1：ctrl+shift+o，选择要导入的包。例如，java.util.Scanner
  2. 方法2：将鼠标移动至报红线的地方，会出现一个框，点击：例如，import’Scanner’(java.util)
  3. 方法3：写好要导包的英文名，按alt+/，出现：例如,Scanner -java.util。选择。

• 4.11.3 输出语句的快捷键：直接输入syso，再点击alt+/，回车。

下一篇

这是开始Java代码之前必须要掌握的最最最基础的部分。如果你全部都掌握了，那么恭喜你，可以正式开始JavaSE的学习之路了。并且我的下一章节你想要的跟着学习可以私信我，因为我后面的章节要开始收money了哦。