3. 运算符与流程控制语句

最新推荐文章于 2024-06-16 22:34:26 发布

靈熙雲

最新推荐文章于 2024-06-16 22:34:26 发布

阅读量272

点赞数

分类专栏： JavaSE 文章标签：流程控制三元 scanner if class

本文链接：https://blog.csdn.net/minkeyto/article/details/78567903

版权

JavaSE 专栏收录该内容

37 篇文章 2 订阅

订阅专栏

1:运算符

运算符：就是对常量和变量进行操作的符号。

分类：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三目运算符

(1)算术运算符

A:+,-,*,/,%,++,--

B:+的用法

a:加法

b:正号

c:字符串连接符

C:/和%的区别

整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型

数据做除法操作的时候，/取得是商，%取得是余数

D:++和--的用法

a:他们的作用是自增或者自减

b:使用

**单独使用

放在操作数据的前面和后面效果一样。

a++或者++a效果一样。

**参与操作使用

放在操作数的前面：先自增或者自减，再（赋值）参与操作

inta = 10;

intb = ++a;

放在操作数的后面：先（赋值）参与操作，再自增或者自减

inta = 10;

intb = a++;

(2)赋值运算符

A:=；+=；-=；*=；/=；%=等

+=加赋值

把左边和右边的结果赋值给左边。

注意：左边不能是常量

B:=叫做赋值运算符，也是最基本的赋值运算符

int x = 10; 把10赋值给int类型的变量x。

C:扩展的赋值运算符的特点（+=；-=；*=；/=；%=）等

隐含了自动强制转换。

面试题：s=(s的数据类型)(s+1);

short s = 1; s = s + 1; 有数据类型问题

short s = 1; s += 1;

请问上面的代码哪个有问题?

为什么第二个木有问题呢?

扩展的赋值运算符其实隐含了一个强制类型转换。

s += 1;

不是等价于s = s + 1;

而是等价于s = (s的数据类型)(s + 1);

(3)比较运算符

A:无论运算符两端简单还是复杂最终结果是boolean类型。

B:千万不要把==写成了=

(4)逻辑运算符

l 逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

l “&”和“&&”的区别：

• 单&时，左边无论真假，右边都进行运算；

• 双&时，具有短路效果。如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|” 和 “||” 的区别同理，双或时，左边为真，右边不参与运算。

& : 有false则false

| : 有true则true

^ : 相同false,不同true

帮助理解：情侣必须是男女或者女男

! : 非false则true,非true则false

&& , || 和 & 以及 | 的区别：结果相同，但是有短路效果，一般建议使用&&, ||

class OperatorDemo {
publicstatic void main(String[] args) {
       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 = false
       System.out.println((a < b) & (a> c));    //true & false = false
       System.out.println((a < b) & (a< c));    //true & true = true
       System.out.println("---------------");
       //|逻辑或
       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 = true
       System.out.println("---------------");
       //^逻辑异或
       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("---------------");
       //!逻辑非
       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
 }
}

l 面试题

l 异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

A: &, |, ^, !, &&, ||

B:逻辑运算符用于连接boolean类型的式子

C:结论

&: 有false则false

|: 有true则true

^: 相同则false，不同则true。情侣关系。

!: 非true则false，非false则true

&&: 结果和 & 是一样的，只不过有短路效果。左边是false，右边不执行。

||: 结果和 | 是一样的，只不过有短路效果。左边是true，右边不执行。

(5)位运算符(了解)

位运算符的细节
<<	空位补0，被移除的高位丢弃。
>>	被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，最高位补1。
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补。
&	任何二进制位和0进行&运算，结果是0；和1进行&运算结果是原值。
\|	任何二进制位和0进行 \| 运算，结果是原值；和1进行 \| 运算结果是1。
^	任何相同二进制位进行 ^ 运算，结果是0；不相同二进制位 ^ 运算结果是1。特殊用法：一个数据针对另一个数据位异或两次，该数不变

<<：就是将左边的操作数在内存中的二进制数据左移右边操作数指定的位数，右边被移空的部分补0。相当于乘与2的倍数

>>：右移稍微复杂一点，如果最高位是0，左边被移空的位就填入0；如果最高位是1，左边被移空的位就填入1。相当于除以2的倍数

>>>：无论最高位是1还是0，左边被移空的高位都填入0。

看结果：总结相当于乘以或者除以2的多少次幂。

System.out.println(3<< 2); // 12

System.out.println(24>> 2); // 6

System.out.println(24>>> 2); // 6

System.out.println(-24>> 2); // -6

System.out.println(-24>>> 2); // 1073741818

B:面试题

a:请实现两个变量的交换

**采用第三方变量

**用位异或运算符

左边a,b,a

右边a^b

class OperatorTest {

publicstatic void main(String[] args) {

int a = 10;

int b = 20;

System.out.println("a:"+a+",b:"+b);

//方式1：使用第三方变量(开发中用的)

int c = a;

a = b;

b = c;

System.out.println("a:"+a+",b:"+b);

System.out.println("------------");

//方式2：用位异或实现(面试用)

//左边：a,b,a

//右边：a ^ b

a = a ^ b;

b = a ^ b; //a ^ b ^ b = a

a = a ^ b; //a ^ b ^ a = b

System.out.println("a:"+a+",b:"+b);

//方式3：用变量相加的做法

a = a + b; //a=30

b = a - b; //b=10

a = a - b; //a=20

System.out.println("a:"+a+",b:"+b);

//方式4：一句话搞定

b = (a+b) - (a=b); //b=30-20=10,a=20

System.out.println("a:"+a+",b:"+b);

}

b:请用最有效率的方式计算出2乘以8的结果

2<<3

(6)三元运算符

A:格式

比较表达式?表达式1:表达式2;

B:执行流程：

首先计算比较表达式的值，看是true还是false。

如果是true，表达式1就是结果。

如果是false，表达式2就是结果。

C:案例：

a:比较两个数据是否相等

b:获取两个数据中的最大值

c:获取三个数据中的最大值

class OperatorTest {
    publicstatic void main(String[] args) {
           //获取两个整数中的最大值
           int x = 100;
           int y = 200;
           int max = (x > y? x: y);
           System.out.println("max:"+max);
           System.out.println("--------");
           //获取三个整数中的最大值
           int a = 10;
           int b = 30;
           int c = 20;
           //分两步：
           //A:先比较a,b的最大值
           //B:拿a,b的最大值在和c进行比较
           int temp = ((a > b)? a: b);
           //System.out.println(temp);
           int max1 = (temp > c? temp: c);
           System.out.println("max1:"+max1);
           //一步搞定
           //int max2 = (a > b)?((a > c)? a:c):((b > c)? b: c);
           //这种做法不推荐。
           //int max2 = a > b?a > c? a: c:b> c? b: c;
           //System.out.println("max2:"+max2);
           System.out.println("--------");
           //比较两个整数是否相同
           int m = 100;
           int n = 200;
           //boolean flag = (m == n)? true: false;
           boolean flag = (m == n);
           System.out.println(flag);
    }
}

2:键盘录入(掌握)

(1)实际开发中，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。

(2)如何实现呢?目前就记住

A:导包

import java.util.Scanner;

位置：在class的上边

B:创建对象

Scanner sc = new Scanner(System.in);

C:获取数据

int x = sc.nextInt();

(3)把三元运算符的案例加入键盘录入改进。

3:流程控制语句

(1)顺序结构从上往下，依次执行

(2)选择结构按照不同的选择，执行不同的代码

(3)循环结构做一些重复的代码

4:if语句(掌握)

(1)三种格式

A:格式1

if(比较表达式){

语句体;

}

执行流程：

判断比较表达式的值，看是true还是false

如果是true，就执行语句体

如果是false，就不执行语句体

B:格式2

if(比较表达式){

语句体1;

}else {

语句体2;

}

执行流程：

判断比较表达式的值，看是true还是false

如果是true，就执行语句体1

如果是false，就执行语句体2

C:格式3

if(比较表达式1){

语句体1;

}else if(比较表达式2){

语句体2;

}

...

else {

语句体n+1;

}

执行流程：

判断比较表达式1的值，看是true还是false

如果是true，就执行语句体1

如果是false，就继续判断比较表达式2的值，看是true还是false

如果是true，就执行语句体2

如果是false，就继续判断比较表达式3的值，看是true还是false

...

如果都不满足，就执行语句体n+1

(2)注意事项

A:比较表达式无论简单还是复杂，结果是boolean类型

B:if语句控制的语句体如果是一条语句，是可以省略大括号的；如果是多条，不能省略。

建议：永远不要省略。

C:一般来说，有左大括号，就没有分号，有分号，就没有左大括号。

D:else后面如果没有if，是不会出现比较表达式的。

E:三种if语句其实都是一个语句，只要有一个执行，其他的就不再执行。

(3)案例：

A:比较两个数是否相等

B:获取两个数中的最大值

C:获取三个数中的最大值(if语句的嵌套)

class IfTest4 {
publicstatic void main(String[] args) {
       int a = 10;
       int b = 30;
       int c = 20;
       //三元实现
       //int temp = (a>b)? a: b;
       //int max = (temp>c)? temp: c;
       //System.out.println("max:"+max);
       //用if语句实现
       int max;
       if(a > b) {
              if(a> c) {
                     max = a;
              }else{
                     max = c;
              }
       }else {
              if(b> c) {
                     max = b;
              }else{
                     max = c;
              }
       }
       System.out.println("max:"+max);
  }
}

D:根据成绩输出对应的等级

E:根据月份，输出对应的季节

class IfTest3 {
       publicstatic void main(String[] args) {
              //创建键盘录入对象
              Scanner sc = new Scanner(System.in);
              //录入数据
              System.out.println("请你输入一个月份:");
              int month = sc.nextInt();
              if(month<1 || month>12) {
                     System.out.println("你输入的月份有误");
              }else if(month>=3 && month<=5){
                     System.out.println("春季");
              }else if(month>=6 &&month<=8) {
                     System.out.println("夏季");
              }else if(month>=9 &&month<=11) {
                     System.out.println("秋季");
              }else {
                     System.out.println("冬季");
              }
              System.out.println("--------------");
       }
}

F:根据x计算对应y的值并输出

(4)三元运算符和if语句第二种格式的关系

三元运算符实现的，都可以采用if语句实现。反之不成立。

什么时候if语句实现不能用三元改进呢?

当if语句控制的操作是一个输出语句的时候就不能。

为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。