从0开始学Java：运算符（Operator）与标点符号（Separators）

文章目录

• 1. 运算符的分类
• 2. 算术运算符
• 3. 赋值运算符
• 4. 关系运算符/比较运算符
• 5. 逻辑运算符
• 6. 条件运算符
• • • • 练习
• 7. 位运算符（了解）
• • • • 左移：<<
      • 右移：>>
      • 无符号右移：>>>
      • 按位与：&
      • 按位或：|
      • 按位异或：^
      • 按位取反
• 8. 运算符优先级
• 9. 标点符号

• 运算符： 是一种特殊的符号，用以表示数据的运算、赋值和比较等。
• 表达式： 用运算符连接起来的式子

在Java中，一共有38个运算符。

1. 运算符的分类

• 按照功能划分：

  分类	运算符
  算术运算符	+、-、*、/、%、++、--
  赋值运算符	=、+=、-=、*=、/=、%=等
  关系运算符	>、>=、<、<=、==、!=
  逻辑运算符	&、`
  条件运算符	(条件表达式)?结果1:结果2；
  位运算符（了解）	&、`

• 按照操作数个数划分：

  分类	运算符	例子
  一元（单目）运算符	++、–、！	i++、–i
  二元（双目）运算符	+、-、*、/、%、>、<=等	a+b、10>=9
  三元（三目）运算符	表达式1?表达式2:表达式3	age>=18?“成年”:“未成年”

2. 算术运算符

1. 加、减、乘、除、模

   public class OperatorDemo01 {public static void main(String[] args) {int a = 3;int b = 4;System.out.println(a + b);// 7System.out.println(a - b);// -1System.out.println(a * b);// 12System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？System.out.println(a % b);// 3                System.out.println(5%2);//1System.out.println(5%-2);//1System.out.println(-5%2);//-1System.out.println(-5%-2);//-1//商*除数 + 余数 = 被除数//5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5//-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5}}

2. “+”号的两种用法

   • 第一种：对于+两边都是数值的话，+就是加法的意思

   • 第二种：对于+两边至少有一边是字符串得话，+就是拼接的意思

     public class OperatorDemo02 {public static void main(String[] args) {// 字符串类型的变量基本使用// 数据类型 变量名称 = 数据值;String str1 = "Hello";System.out.println(str1); // HelloSystem.out.println("Hello" + "World"); // HelloWorldString str2 = "Java";// String + int --> StringSystem.out.println(str2 + 520); // Java520// String + int + int// String+ int// StringSystem.out.println(str2 + 5 + 20); // Java520}}

3. 自加自减运算

   理解：++ 运算，变量自己的值加1。反之，-- 运算，变量自己的值减少1，用法与++ 一致。

   • 单独使用

     • 变量在单独运算的时候，变量前++和变量后++，变量的是一样的；

     • 变量前++ ：例如 ++a 。

     • 变量后++ ：例如 a++ 。

       public class OperatorDemo3 {public static void main(String[] args) {// 定义一个int类型的变量aint a = 3;//++a;a++;        // 无论是变量前++还是变量后++，结果都是4System.out.println(a);}}

   • 复合使用

     • 和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。

     • 变量前++ ：变量先自身加1，然后再取值。

     • 变量后++ ：变量先取值，然后再自身加1。

       public class OperatorDemo03 {public static void main(String[] args) {// 其他变量放在一起使用int x = 3;//int y = ++x; // y的值是4，x的值是4，int y = x++; // y的值是3，x的值是4System.out.println(x);System.out.println(y);System.out.println("==========");        // 和输出语句一起int z = 5;//System.out.println(++z);// 输出结果是6，z的值也是6System.out.println(z++);// 输出结果是5，z的值是6System.out.println(z);                int a = 1;        a = a++;//(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1        int i = 1;        int j = i++ + ++i * i++;        } }

   • 小结：

     • ++在前，先自加，后使用；
     • ++在后，先使用，后自加。

4. 练习

   • （1）获取一个四位数的个位，十位，百位，千位

     public class Test01 {public static void main (String [] args) {//1.定义一个四位数，例如1234int num = 1234;        //2.通过运算操作求出个位，十位，百位，千位int ge = ？int shi = ？int bai = ？int qian = ？System.out.println(num + "这个四位数个位上的数字是：" + ge);System.out.println(num + "这个四位数十位上的数字是：" + shi);System.out.println(num + "这个四位数百位上的数字是：" + bai);System.out.println(num + "这个四位数千位上的数字是：" + qian);}}

   • （2）自增自减练习

     判断如下代码的运行结果

     public static void main(String[] args){int i = 1;int j = i++;int k = i++ * ++j + ++i * j++;System.out.println("i = " + i);System.out.println("j = " + j);System.out.println("k = " + k);}

     public static void main(String[] args){int i = 1;int j = i++;int k = i++ * ++j + --i * j--;System.out.println("i = " + i);System.out.println("j = " + j);System.out.println("k = " + k);}

     public static void main(String[] args){int i = 1;int j = ++i + i++ * ++i + i++;System.out.println("i = " + i);System.out.println("j = " + j);}

     public static void main(String[] args){int i = 0;int result = ++i/--i;System.out.println("result="+result);}

3. 赋值运算符

注意：所有的赋值运算符的=左边一定是一个变量

1. 基本赋值运算符课堂案例

   public class OperatorDemo04 {public static void main(String[] args) {int a = 3;int b = 4;a = a + b; System.out.println(a); // 7System.out.println(b); // 4}}

2. 扩展赋值运算符课堂案例

   public class OperatorDemo04 {public static void main(String[] args) {int a = 3;int b = 4;b += a;// 相当于 b = b + a ; System.out.println(a); // 3System.out.println(b); // 7short s = 3;// s = s + 4; 代码编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度s += 4; // 代码没有报错        //因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成shortSystem.out.println(s);                int j = 1;j += ++j * j++;//相当于  j = j + (++j * j++);System.out.println(j);//5}}

   扩展赋值运算符在将最后的结果赋值给左边的变量前，都做了一步强制类型转换。

3. 练习

   交换两个变量的值
   int m = 1;
   int n = 2;

   int temp=m;m=n;n=temp;

4. 关系运算符/比较运算符

比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值true或者false 。

• 课堂案例

  public class OperatorDemo05 {public static void main(String[] args) {int a = 3;int b = 4;System.out.println(a < b); // trueSystem.out.println(a > b); // falseSystem.out.println(a <= b); // trueSystem.out.println(a >= b); // falseSystem.out.println(a == b); // falseSystem.out.println(a != b); // true}}

• ​ 练习：判断如下程序的运行结果

  public static void main(String[] args){int a = 1;int b = 2;int c = 0;boolean flag = false;if(flag=true){c = a++ + b;}if(flag=false){c = ++a - b;}System.out.println("a = " + a);System.out.println("b = " + b);System.out.println("c = " + c);}

5. 逻辑运算符

逻辑运算符，是用来连接两个布尔类型结果的运算符（!除外），运算结果一定是boolean值true或者false

1. 课堂案例

   public class OperatorDemo06 {public static void main(String[] args) {int a = 3;int b = 4;int c = 5;// & 与，且；有false则falseSystem.out.println((a > b) & (a > c)); System.out.println((a > b) & (a < c)); System.out.println((a < b) & (a > c)); System.out.println((a < b) & (a < c)); System.out.println("===============");// | 或；有true则trueSystem.out.println((a > b) | (a > c)); System.out.println((a > b) | (a < c)); System.out.println((a < b) | (a > c));System.out.println((a < b) | (a < c));System.out.println("===============");// ^ 异或；相同为false，不同为trueSystem.out.println((a > b) ^ (a > c));System.out.println((a > b) ^ (a < c)); System.out.println((a < b) ^ (a > c)); System.out.println((a < b) ^ (a < c)); System.out.println("===============");// ! 非；非false则true，非true则falseSystem.out.println(!false);System.out.println(!true);}}

2. &&和&区别，||和|区别

   短路与，短路或运算符左边表达式结果可以确定最终结果，则运算符右边表达式不再进行运算，效率高

   • &&和& 区别：

     &&和&结果一样，&&有短路效果，左边为false，右边不执行；&左边无论是什么，右边都会执行。

   • ||和| 区别：

     ||和|结果一样，||有短路效果，左边为true，右边不执行；|左边无论是什么，右边都会执行。

   public class LogicExer1{public static void main(String[] args){int x = 1;int y = 1;//x==2 ,x++  false  x = 2 左边为false//右边继续//++y  y==2  y=2  y==2成立  右边为true//false & true 结果falseif(x++==2 & ++y==2){x =7;}System.out.println("x="+x+",y="+y);//x=2,y=2}}

   public class LogicExer2{public static void main(String[] args){int x = 1,y = 1;//x==2,x++  左边条件为false，x=2//因为短路与，右边不算//false && ? 结果是falseif(x++==2 && ++y==2){x =7;}System.out.println("x="+x+",y="+y);//x=2,y=1}}

   public class LogicExer3{public static void main(String[] args){int x = 1,y = 1;//x==1,x++  左边为true，x=2//因为是逻辑与,右边继续  //++y, y==1  y=2 右边为false//条件true | false，最终为trueif(x++==1 | ++y==1){x =7;}System.out.println("x="+x+",y="+y);//x=7,y=2}}

   public class LogicExer4{public static void main(String[] args){int x = 1,y = 1;//x==1,x++  左边为true，x=2//因为是短路或，左边为true，右边就不看了//整个条件为trueif(x++==1 || ++y==1){x =7;}System.out.println("x="+x+",y="+y);//x=7,y=1}}

   public class LogicExer5{public static void main (String []  args)  {boolean x = true;boolean y = false;short z = 42;//如果if((z++==42)&&(y==true))条件成立，执行z++，不成立，就不执行z++//左边的条件：z==42,z++  z==42成立,z++变成43//中间虽然是短路与，因为左边现在是true,右边还要看//右边 y==true   不成立//true && false 结果为falseif((z++==42)&&(y==true))z++;//左边为x=false,赋值  结果就为false//中间虽然为短路或，因为左边是false,右边继续看//++z,z==45  ++z变成44，z==45是否成立，不成立//false || false  结果为falseif((x=false) || (++z==45))  z++;System. out.println("z="+z);//44}}

   class  Test4_2  {public static void main (String []  args)  {boolean x = true;boolean y = false;short z = 42;//如果if(y=true)条件成立，接着判断if((z++==42)&&(y==true))z++;//如果不成立，if((z++==42)&&(y==true))z++;不看的//标准//y=true赋值，y就被修改为true,if(true)成立if(y=true){//左边：z==42,z++  成立,z变成43//&&短路与，不满足短路的情况，右边继续//y==true 成立//true && true，结果为trueif((z++==42)&&(y==true)){//z++变成44z++;}}//左边：x=false不成立//中间虽然是短路或，但是没满足短路的情况，右边继续//++z,z==45  ++z变成45，z==45成立if((x=false) || (++z==45)){//z++，变成46z++;}System. out.println("z="+z);//46}}

6. 条件运算符

• 条件运算符格式：

条件表达式？结果1：结果2

• 条件运算符计算方式：
  • 条件判断的结果是true，条件运算符整体结果为结果1，赋值给变量。
  • 判断条件的结果是false，条件运算符整体结果为结果2，赋值给变量。

public static void main(String[] args) {    int i = (1==2 ? 100 : 200);    System.out.println(i);//200    int j = (3<=4 ? 500 : 600);    System.out.println(j);//500}

练习

声明三个整型的变量,a,b,c,要求找出最大值
2、声明一个整型的变量，判断它是正数还是负数，还是0

7. 位运算符（了解）

• 位运算符的运算过程都是基于补码运算，但是看结果，我们得换成原码，再换成十进制看结果
• 从二进制到十进制都是基于原码
• byte,short,char在计算时按照int类型处理
• 位运算直接对二进制进行位移操作实现数值运算，所以运算效率高

如何区分&,|,^是逻辑运算符还是位运算符？

如果操作数是boolean类型，就是逻辑运算符，如果操作数是整数，那么就位运算符。

1. 左移：<<

   运算规则：左移几位就相当于乘以2的几次方

   **注意：**当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

   byte,short,char在计算时按照int类型处理

   3<<4  类似于  3*2的4次= 3*16 = 48

   -3<<4  类似于  -3*2的4次= -3*16 = -48

2. 右移：>>

   快速运算：类似于除以2的n次幂，如果不能整除，向下取整

   69>>4  类似于  69/2的4次 = 69/16 =4

   -69>>4  类似于  -69/2的4次 = -69/16 = -5

3. 无符号右移：>>>

   运算规则：往右移动后，左边空出来的位直接补0，不看符号位

   正数：和右移一样

   负数：右边移出去几位，左边补几个0，结果变为正数

   69>>>4  类似于  69/2的4次 = 69/16 =4

   -69>>>4   结果：268435451

4. 按位与：&

   运算规则：对应位都是1才为1

   1 & 1 结果为1

   1 & 0 结果为0

   0 & 1 结果为0

   0 & 0 结果为0

   9&7 = 1

   -9&7 = 7

5. 按位或：|

   运算规则：对应位只要有1即为1

   1 | 1 结果为1

   1 | 0 结果为1

   0 | 1 结果为1

   0 & 0 结果为0

   9|7  结果： 15

   -9|7 结果： -9

6. 按位异或：^

   运算规则：对应位一个为1一个为0，才为1

   1 ^ 1 结果为0

   0 ^ 1 结果为1

   0 ^ 0 结果为0

   9^7  结果为14

   -9^7 结果为-16

7. 按位取反

   运算规则：

   ​ ~0就是1

   ​ ~1就是0

   ~9  结果：-10

   ~-9  结果：8

   
   

8. 运算符优先级

提示说明：

（1）表达式不要太复杂

（2）先算的使用()

1. 大体的排序：算术 > 位 > 比较 > 逻辑 > 三元 > 赋值

9. 标点符号

在Java中一共有12个标点符号。（后面再一一学习）

• 小括号()用于强制类型转换、表示优先运算表达式、方法参数列表
• 大括号{}用于数组元素列表、类体、方法体、复合语句代码块边界符
• 中括号[]用于数组
• 分号;用于结束语句
• 逗号,用于多个赋值表达式的分隔符和方法参数列表分隔符
• 英文句号.用于成员访问和包目录结构分隔符
• 英文省略号…用于可变参数
• @用于注解
• 双冒号::用于方法引用

各个标点符号的使用在后续章节中一一揭晓。

来源地址：https://blog.csdn.net/m0_60915009/article/details/133811052