Java中的运算符

1.算术运算符

基本四则运算符+ - * / %

规则比较简单，值得注意：

1. int类型/ int类型结果还是 int，需要使用 double 来计算。如图
   
   运行结果如下：
   

2. 0 不能作为除数
   当0做除数时，会发生运行时异常（也称非受查异常）。
   
   运行结果如下
   

3. % 表示取余
   不仅仅可以对 int 求模，也能对 double 来求模。
   
   运行结果如下
   

增量赋值运算符 += -= *= /= %=

运行结果如下

其他增量赋值运算符相类似。

自增/自减运算符 ++ –

需要注意的是前置（后置）自增/自减
前置自增/自减，如下

运行结果如下

后置自增/自减，如下

运行结果如下

我们不难发现，前置自增/自减，先进行赋值，后再进行运算；
而后置自增/自减，先进行运算，后再赋值。
与C语言不同的是如下情况

它的运行结果如下

这一点是需要我们注意的。
小结：

1. 如果不取自增运算的表达式的返回值，则前置自增和后置自增没有区别。
2. 如果取表达式的返回值，则前置自增的返回值是自增之后的值，后置自增的返回值是自增之前的值。

2.关系运算符

关系运算符主要有六个==、 !=、 < 、>、 <=、 >=。
注意，Java中，关系运算符的表达式返回值都是boolean类型（ true 或者 false ）。这是与C语言有所不同的。
例如：

运行结果如下

3.逻辑运算符

逻辑运算符主要有三个：&&、||、! 。
注意，逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean类型

逻辑与 &&

规则：两个操作数都为 true，结果为 true，否则结果为 false 。

逻辑或 ||

规则：两个操作数都为 false，结果为 false，否则结果为 true。

逻辑非 !

规则：操作数为 true，结果为 false；操作数为 false，结果为 true(这是个单目运算符，只有一个操作数)。

运行结果如下

在这里，&& 和 || 遵守短路求值的规则，对于 &&，如果左侧表达式值为 false，则表达式的整体的值一定是 false，无需计算右侧表达式。同理，对于 ||，如果左侧表达式值为 true，则表达式的整体的值一定是 true，无需计算右侧表达式。

& 和 | (不推荐使用)

& 和 | 如果操作数为 boolean 的时候，也表示逻辑运算，但是和 && 以及 || 相比，它们不支持短路求值。

4.位运算符

Java 中对数据的操作的最小单位不是字节，而是二进制位。位运算符主要有四个： & 、 | 、 ~ 、 ^

按位与 &

如果两个二进制位都是 1，则结果为 1，否则结果为 0 。

按位或 |

如果两个二进制位都是 0，则结果为 0，否则结果为 1 。

运行结果如下

其原因如下图所示

按位取反 ~

如果该位为 0 则转为 1，如果该位为 1 则转为 0 。

运行结果如下

分析如下图

注意：

1. 0x 前缀的数字为 十六进制 数字。十六进制可以看成是二进制的简化表示方式。一个十六进制数字对应 4 个二进制位。
2. 0xf 表示 10 进制的 15，也就是二进制的 1111。
3. printf 能够格式化输出内容，%x 表示按照十六进制输出。
4. \n 表示换行符。

按位异或 ^

如果两个数字的二进制位相同，则结果为 0，相异则结果为 1。

运行结果如下

其原因是，1的二进制表示为 0 1，2的二进制表示为 1 0。进行按位异或^运算，其结果二进制表示为 1 1 ，按照十六进制输出为3。

5.移位运算(了解）

移位运算符有三个： << 、 >> 、 >>> 。它们都是按照二进制位来运算的。

左移 <<

最左侧位不要了，最右侧补 0 。

右移 >>

最右侧位不要了，最左侧补符号位(正数补0，负数补1)。

无符号右移 >>>

最右侧位不要了, 最左侧补 0 。

运行结果如下

原因如下

注意:

1. 左移 1 位，相当于原数字×2。左移 N 位，相当于原数字×2 的N次方。
2. 右移 1 位，相当于原数字÷2。右移 N 位，相当于原数字÷2 的N次方。
3. 由于计算机计算移位效率高于计算乘除，当某个代码正好乘除 2 的N次方的时候可以用移位运算代替。
4. 移动负数位或者移位位数过大都没有意义。

6.条件运算符

也叫三目运算符，只有一个：
表达式1 ? 表达式2 : 表达式3
当 表达式1 的值为 true 时，整个表达式的值为 表达式2 的值；当 表达式1 的值为 false 时，整个表达式的值为 表达式3 的值。
例如，两个数中的较大的数。

运行结果如下

这样，我们很轻松地就求取了两数中的较大值。

7.运算符的优先级

运算符之间是有优先级的，具体的规则我在这里也不赘述了，也不必记忆。只要在可能存在歧义的代码中加上括号即可。

8.小结

1. % 操作再 Java 中也能针对 double 来计算。
2. 需要区分清楚前置自增和后置自增之间的区别。
3. 由于 Java 是强类型语言，因此对于类型检查较严格，因此像 && 之类的运算操作数必须是 boolean类型。
4. 要区分清楚 & 和 | 什么时候是表示按位运算，什么时候表示逻辑运算。
   整体来看，Java 的运算符的基本规则和 C 语言基本一致。

典型例题

一.交换两个整数的值。在这里为大家提供三种方法。
方法一，使用中间变量。这也是最普遍的方法。

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int temp = a;//引入中间变量
        a = b;
        b = temp;
        System.out.println(a);
        System.out.println(b);
   }
}

方法二，使用加法原理，但是不足之处是数据可能会溢出

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a = a + b;//交换两个数字，加法原理，不足是可能会溢出
        b = a - b;
        a = a - b;
        System.out.println(a);
        System.out.println(b);
   }
}

方法三，使用异或（^）位运算符

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        a = a^b;//交换两个数字，不使用中间变量,且不会溢出
        b = a^b;
        a = a^b;
        System.out.println(a);
        System.out.println(b);
   }
}

二.给定三个 int 变量，求其中的最大值和最小值。
上代码

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30；
        int max = a > b ? a : b;// 求两个整数的最大值
        max = max > c ? max :c;
        int min = a < b ? a : b;// 求两个整数的最小值
        min = min < c ? min : c;
        System.out.println(max);
        System.out.println(min);
   }
}

就是如此之简单。

Java中的关键字

用于定义访问权限修饰符的关键字

private 、protected 、public 。

用于定义类，函数，变量修饰符的关键字

abstract 、final 、static 、synchronized 。

用于定义类与类之间关系的关键字

extends 、 implements 。

用于定义建立实例及引用实例，判断实例的关键字

new 、this 、 super 、 instanceof 。

用于异常处理的关键字

try 、 catch 、 finally 、 throw 、 throws 。

用于包的关键字

package 、 import 。

其他修饰符关键字

native 、 strictfp 、transient 、 volatile 、 assert 。

随着Java学习的不断深入，会逐渐地总结到以上关键字。

程序逻辑控制

1.顺序结构

顺序结构比较简单。就像我们之前写过的代码就是顺序结构的，按照代码书写的顺序一行一行执行。

System.out.println("111");
System.out.println("222");
System.out.println("333");

它的运行结果就为
111
222
333

2.分支结构

1.if 语句

基本语法形式1

if(布尔表达式){
    //条件满足时执行代码
}

基本语法形式2

if(布尔表达式){
    //条件满足时执行代码
}else{
    //条件不满足时执行代码
}

基本语法形式3 多分支的情况

if(布尔表达式){
    //条件满足时执行代码
}else if(布尔表达式){
    //条件满足时执行代码
}else{
    //条件都不满足时执行代码
}

注意，悬垂else问题
if / else 语句中可以不加大括号，但是也可以写语句(只能写一条语句). 此时 else 是和最接近的 if 匹配（也就是就近原则），但是实际开发中不建议这么写，最好加上大括号。
三个常见编程题（多分支）
1.判断一个整型数字是奇数还是偶数

public class TestDemo {
    public static void main(String[] args) {        
        int num = 10;//判断一个数字是奇数还是偶数
        if (num % 2 == 0) {
            System.out.println("num 是偶数");
        } else {
            System.out.println("num 是奇数");
        }
   }
}

2.判定一个数字是正数还是负数

public class TestDemo {
    public static void main(String[] args) {        
        int num = 10;
        if (num > 0) {
            System.out.println("num 是正数");
        } else if (num < 0) {
            System.out.println("num 是负数");
        } else {
            System.out.println("num 是 0");
        }
   }
}

3.判断一个年份是否为闰年。

public class TestDemo {
    public static void main(String[] args) {        
        int year = 2021;
        if (year % 100 == 0) {
            // 判定世纪闰年
            if (year % 400 == 0) {
                System.out.println("是闰年");
            } else {
                System.out.println("不是闰年");
            }
        } else {
            // 普通闰年
            if (year % 4 == 0) {
                System.out.println("是闰年");
            }else {
                System.out.println("不是闰年");
            }
        }
   }
}

由运行结果可知，2021年不是闰年。

2.switch 语句

基本语法

switch(整数|枚举|字符|字符串){
     case 内容1 : {
         内容满足时执行语句;
         [break;]
         }
     case 内容2 : {
         内容满足时执行语句;
         [break;]
         }
     ...
     default:{
         内容都不满足时执行语句;
         [break;]
         }
}

根据 switch 中值的不同，会执行对应的 case 语句，遇到 break 就会结束该 case 语句。如果 switch 中的值没有匹配的 case，就会执行 default 中的语句。建议一个 switch 语句最好都要带上 default 语句。

3.循环结构

1.while 循环

基本语法格式:

while(循环条件){
    循环语句;
} 

循环条件为 true，则执行循环语句；否则结束循环。
注意事项

1. 和 if 类似, while 下面的语句可以不写 { } ，但是不写的时候只能支持一条语句。建议还是加上 { }。
2. 和 if 类似，while 后面的 { 建议和 while 写在同一行。
3. 和 if 类似，while 后面不要多写分号，否则会导致循环不能正确执行。

例，计算1！+2！+3！+4！+5！

public class TestDemo {
    public static void main(String[] args) {        
        int num = 1;
        int sum = 0;
        // 外层循环负责求阶乘的和
        while (num <= 5) {
          int factorResult = 1;
          int tmp = 1;
          // 内层循环负责完成求阶乘的细节
          while (tmp <= num) {
             factorResult *= tmp;
             tmp++;
          }
          sum += factorResult;
          num++;
       }
       System.out.println("sum= " + sum);
   }
}

2.break

break 的功能是让循环提前结束。也就是跳出循环。

3.continue

continue 的功能是跳过这次循环，立即进入下次循环。

4.for 循环

基本语法

for(表达式1;表达式2;表达式3){
    循环体;
} 

表达式1: 用于初始化循环变量。
表达式2: 循环条件。
表达式3: 更新循环变量。
与 while 循环相比，for 循环将这三个部分合并在一起, 写代码时不容易遗漏。

5.do while 循环

基本语法

do{
   循环语句;
}while(循环条件);

这个循环，最大的不同就是先执行循环语句，然后再判定循环条件。

到这里，Java入门（二）基本结束了，下面为大家提供一个通过Java编程实现的小游戏。猜数字游戏。

import java.util.Random;
import java.util.Scanner;;
public class TestDemo {
    public static void main(String[] args) {
        Random random = new Random(); // 默认随机种子是系统时间
        Scanner sc = new Scanner(System.in);
        int toGuess = random.nextInt(100);
        // System.out.println("toGuess: " + toGuess);
        while (true) {
            System.out.println("请输入要输入的数字: (1-100)");
            int num = sc.nextInt();
            if (num < toGuess) {
                System.out.println("小了");
            } else if (num > toGuess) {
                System.out.println("大了");
            } else {
                System.out.println("恭喜回答正确");
                break;
            }
        }
        sc.close();
    }
}

铁汁们，我们下期见。

转载自CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/Kaiiiiiiiiiiiiii/article/details/112258718