3. 运算符，表达式和语句

3.1 运算符与表达式

Java提供了丰富的运算符，如算数运算符，关系运算符，逻辑运算符，位运算符等。

3.1.1 算数运算符和算数表达式

      • \ %

加减运算符

  1. int a =10;
  2. int b =20;
  3. int c = a+b;
  4. int d = b-a;

乘除,求余运算符

  1. int a =10;
  2. int b = a*a;
  4. int c = 100%10;

3.1.2 自增减运算符

自增: ++

自减:--

这里需要注意的是: ++ — 位置不同会导致不同的结果

  1. x++; // 先读取后自增
  2. ++x; // 先自增后读取
  4. x--; // 先读取后自减
  5. --x; // 先自减后读取

示例代码

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         int x, before, after;
  5.         // 先读取后自增
  6.         x=10;
  7.         before = x++;
  8.         System.out.println("x++ before:" + before + " x:" + x);
  10.         // 先自自增后读取
  11.         x = 10;
  12.         after = ++x;
  13.         System.out.println("++x after:" + after + " x:" + x);
  16.         // 先读取后自减
  17.         x=10;
  18.         before = x--;
  19.         System.out.println("x-- before:" + before + " x:" + x);
  21.         // 先自自减后读取
  22.         x = 10;
  23.         after = --x;
  24.         System.out.println("--x after:" + after + " x:" + x);
  26.     }
  27. }
  1. x++ before:10 x:11
  2. ++x after:11 x:11
  3. x-- before:10 x:9
  4. --x after:9 x:9

3.1.3 算数混合运算精度

如果低精度数据和高精度数据参与运算那么结果一定是 高精度数据

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         short x = 2;
  4.         double PI = 3.14;
  5.         System.out.println(PI * x);
  6.     }
  8. }
  1. 6.28

3.1.4 关系运算符和关系表达式

关系运算符无非就是

  • a>b
  • a<b
  • a==b
  • a>=b
  • a<=b
  • a!=b
  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         System.out.println(1 > 2);
  4.         System.out.println(1 < 2);
  5.         System.out.println(1 >= 2);
  6.         System.out.println(1 <= 2);
  7.         System.out.println(1 == 2);
  8.         System.out.println(1 != 2);
  9.     }
  11. }
  1. false
  2. true
  3. false
  4. true
  5. false
  6. true

关系运算符产生结果是 boolean类型,要么关系成立，要么关系不成立

3.1.5 逻辑运算符与逻辑表达式

逻辑运算，有 and（&&） or（||） not（！）

  • || 和 && 为二目运算符
    • &&: 两边同为 true 结果为true
    • ||: 有一个满足 true 结果为true
  • ! 为 单目运算符
    • 取反 true->false false ->true
  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         boolean op1 = true;
  4.         boolean op2 = false;
  5.         System.out.println(op1 && op2);
  6.         System.out.println(op1 || op2);
  7.         System.out.println(!op1);
  8.     }
  9. }
  1. false
  2. true
  3. false

3.1.6 赋值运算符与赋值表达式

赋值运算符是一个耳目运算符，左边的操作元必须是变量，不能是常量或者表达式。

  1. int x =10;
  2. // 将 10 赋值 给 x

需要搞清楚 = 是复制运算符 而 ==是比较运算符，二者的寓意是完全不同的

3.1.7 位运算符

整数数据在内存中，以二进制形式表示

7的二进制表示

  1. 00000000 00000000 00000000 00000111

最左边是符号位，0表示正数，1表示负数.

按位与运算

同1为1，否则为0

按位或运算

同0位0，否则为1

按位非运算

a为1，b为0；a为0，b为1

按位异或运算

相同为0，不同为1

位异或运算有一个特性:连续两次位异或可得到初始值,那么借助这个特性我们可以写个简单的加密程序.

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         char str[] = new char[]{'晚', '上', '来', '我', '家'};
  4.         for (int i = 0; i < str.length; i++) {
  5.             str[i] = (char) (str[i] ^ 'a');
  6.         }
  7.         System.out.print("密文:");
  8.         System.out.println(str);
  9.         for (int i = 0; i < str.length; i++) {
  10.             str[i] = (char) (str[i] ^ 'a');
  11.         }
  12.         System.out.print("名文:");
  13.         System.out.println(str);
  14.     }
  15. }
  1. 密文:昻乫朄扰寗
  2. 名文:晚上来我家

上面的 a 就是秘钥,通过位异或运算我们就实现了一个简单的加密程序,快拿去试试吧！

3.1.8 instanceof运算符

这是一个二目运算符,左边操作元是一个对象,右边是一个类。当左边对象是右边类，或者子类创建的对象时，该运算符运算结果为 true,否则为 false

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         Integer a = 10;
  4.         System.out.println(a instanceof Object);
  5.     }
  6. }
  1. true

3.1.9 运算符综述

运算优先级从高到底

描述 运算符
分隔符 [] () . , ;
对象归类，自增自减，逻辑非 instanceof ++ — !
算术乘除运算 * / %
算术加减运算 + -
位移与运算 >> << >>>
大小关系运算 > >= < <=
相等关系运算 == !=
按位与与运算 &
按位异或运算 ^
按位或 |
逻辑与运算 &&
逻辑或运算 ||
三目运算符 ?:
赋值运算符 =

3.2 语句概述

方法调用语句

调用方法的语句

  1. System.out.println("Hello,World!");

表达式语句

表达式尾加上分号

  1. int a =10;

复合语句

用 { } 包裹的语句

  1. {
  2.     int a =10;
  3.     int b =20;
  4.     int temp = a;
  5.     a =b;
  6.     b=temp;
  7. }

空语句

一个分号一个空语句

  1. ；

控制语句

用来流程控制的语句

  1. int a=10;
  2. if(a%2==0){
  4. }else{
  6. }

package和import语句

package : 声明包

import: 导入包

3.3 if条件分支语句

3.3.1 if条件分支语句

Java中if语句和别的语言一致,满足条件则执行

  1. if(判断条件){
  2.     // 满足执行
  3. }

3.3.2 if-else 语句

不满足上一个分支条件，则执行else,故称之为 双分支语句

简单来进行奇数偶数判断

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         int a = 10;
  4.         if (a % 2 !=0) {
  5.             System.out.println("奇数");
  6.         } else {
  7.             System.out.println("偶数");
  8.         }
  9.     }
  10. }
  1. 偶数

如果 if 语句中只有一条语句，那么可以省略 {}

3.3.3 if-else if -else语句

多条件分支语句,根据多个条件来控制程序执行流程

  1. import java.util.Scanner;
  3. public class HelloWorld {
  4.     public static void main(String[] args) {
  5.         //  某相亲大会
  6.         Scanner scanner = new Scanner(System.in);
  7.         System.out.println("有车吗?");
  8.         boolean hasCar = scanner.nextBoolean();
  10.         System.out.println("有房吗?");
  11.         boolean hasHouse = scanner.nextBoolean();
  12.         System.out.println("月薪多少?");
  13.         double salary = scanner.nextDouble();
  15.         if (!hasCar){
  16.             System.out.println("对不起，不合适");
  17.         }else if(!hasHouse){
  18.             System.out.println("你是个好人");
  19.         }else if (salary<10*1_000){
  20.             System.out.println("要不还是算了吧");
  21.         }else{
  22.             System.out.println("你真棒,我要嫁给你");
  23.         }
  24.     }
  25. }
  1. 有车吗?
  2. true
  3. 有房吗?
  4. true
  5. 月薪多少?
  6. 1000
  7. 要不还是算了吧

3.4 switch语句

Switch 是但条件多分支的开关语句。

  1. switch(表达式){
  2.     case 常量1:break;
  3.     case 常量2:break;
  4.     case 常量3:break;
  5.     case 常量4:break;
  6.     default:
  7.         // ....
  8. }
  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         int num = new Scanner(System.in).nextInt();
  4.         switch (num){
  5.             case 1:
  6.                 System.out.println("one");
  7.                 break;
  8.             case 2:
  9.                 System.out.println("two");
  10.                 break;
  11.             case 3:
  12.                 System.out.println("three");
  13.                 break;
  14.             default:
  15.                 System.out.println("啥也不是");
  16.         }
  17.     }
  18. }
  1. 1
  2. one
  3. 2
  4. two
  5. 3
  6. three
  7. 99
  8. 啥也不是

需要强调的是 switch语句中 表达式的值可以是 byte short int char但是不可以是long类型

3.5 循环语句

循环语句是连续多次执行重复的语句

3.5.1 for循环语句

  1. for(表达式1;表达式2;表达式3){
  2.     // 循环体
  3. }
  • 表达式1：循环开始前初始
  • 表达式2: 循环判断条件
  • 表达式3:单次循环后执行

10以内数之和

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         int sum =0;
  4.         for (int i=0;i<=10;i++){
  5.             sum+=i;
  6.         }
  7.         System.out.println(sum);
  8.     }
  9. }
  1. 55

3.5.2 while循环语句

表达式成立则执行，不成立则不执行

  1. while(表达式){
  2.     语句
  3. }

用while语句改写上面语句

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         int i =0;
  4.         int sum =0;
  5.         while (i<=10){
  6.             sum+=i;
  7.             i++;
  8.         }
  9.         System.out.println(sum);
  10.     }
  11. }

3.5.3 do-while循环语句

do-while 语句和上面语句有些不同,他至少要无条件执行一次循环体

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         int sum = 0, i = 0;
  4.         do {
  5.             sum += i;
  6.             i++;
  7.         } while (i <= 10);
  8.         System.out.println(sum);
  9.     }
  10. }

3.6 break和continue语句

break用来终止循环,continue用来跳出循环

输出10以内的所有奇数

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         for (int i=0;i<10;i++){
  4.             if (i%2==0){
  5.                 continue;
  6.             }
  7.             System.out.println(i);
  8.         }
  9.     }
  10. }
  1. 1
  2. 3
  3. 5
  4. 7
  5. 9

break 来跳出循环

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         for (int i=0;i<10;i++){
  4.             if (i%2==0){
  5.                 continue;
  6.             }
  7.             if(i>=6){
  8.                 break;
  9.             }
  10.             System.out.println(i);
  11.         }
  12.     }
  13. }
  1. 1
  2. 3
  3. 5

3.7 for 语句与数组

使用 范围for 来遍历数组

  1. for(ele:数组名){
  3. }

使用 范围 for遍历数组

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         int[] ints = {1, 3, 4, 5, 6, 7, 9};
  4.         for (int ele : ints) {
  5.             System.out.println(ele);
  6.         }
  7.     }
  8. }
  1. 1
  2. 3
  3. 4
  4. 5
  5. 6
  6. 7
  7. 9

传统方式遍历数组

  1. public class HelloWorld {
  2.     public static void main(String[] args) {
  3.         int[] ints = {1, 3, 4, 5, 6, 7, 9};
  4.         for (int i = 0; i < ints.length; i++) {
  5.             System.out.println(ints[i]);
  6.         }
  7.     }
  8. }

3.8 小结

  • Java提供了丰富的运算符,算数运算符,关系运算符,逻辑运算符,位运算符等
  • Java的控制语句和C很类似
  • Java提供了遍历数组的循环语句