007.运算符与条件语句

本篇和上篇数据类型，都十分基础，我就直接列出它们的用法。记住格式和用法就行。

算术运算符

本篇代码位于目录：src\main\java\github\brad\easy\a007

加法

符号为 ‘+’

public class A01_Add {

    public static void main(String[] args) {
        int a = 3,b = 5;
        int c = a + b;
        System.out.println(c);
        a = a + 3;
        System.out.println(a);
        b = b + 5;
        System.out.println(b);
        System.out.println(c);
    }
}

减法

符号为 ‘-’

public class A02_Subtract {
    public static void main(String[] args) {
        int a = 10, b = 3;
        int c = a - b;
        System.out.println(a-b);
        c = c - 4;
        System.out.println(c);
    }
}

乘法

符号为 ‘*’

public class A03_Multiply {

    public static void main(String[] args) {
        int a = 3, b = 5;
        int c = a * b;
        System.out.println(c);
        a = a * 6;
        System.out.println(a);
    }
}

除法

符号为 ‘/’

public class A04_Divide {
    public static void main(String[] args) {
        int a = 10;
        a = a/2;
        System.out.println(a);
        int b = a;
        b = b/2; //这里是取整数部分。
        System.out.println(b);
    }
}

取余

符号为 ‘%’

public class A05_Remain {

    public static void main(String[] args) {
        int a = 25;
        int b = a % 7; //取余数
        System.out.println(b);
        b = a % 4;
        System.out.println(b);
    }
}

自增

符号为‘++’ , 自增可以用1代替，比如 a = a + 1;只是为了少写一行代码，看起来流畅一些。下面的自减也是一样。

public class A06_AddSelf {

    public static void main(String[] args) {
        int a = 3;
        a++; //后缀自增，先获取a的值，a再自增1。
        ++a; //前缀自增，a先自增1，再获取a的值。
        int b = a++; //先获取a的值赋给b，a再自增1.
        System.out.println(b);
        int c = ++a; a先自增1，再获取a的值给c。
        System.out.println(c);
        int x = 5*++a;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        int y = 5*a++;
        System.out.println("自增运算符后缀运算后a="+a+",y="+y);
    }
}

自减

符号为‘–’

public class A07_SubstractSelf {

    public static void main(String[] args) {
        int a = 10;
        a--; //后缀自减，先获取a的值，a再自减1。
        --a; //前缀自减，a先自减1，再获取a的值。
        int b = a--; //先获取a的值赋给b，a再自减1.
        System.out.println(b);
        int c = --a; a先自减1，再获取a的值给c。
        System.out.println(c);
        int x = 5*--a;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        int y = 5*a--;
        System.out.println("自增运算符后缀运算后a="+a+",y="+y);
    }
}

以上是算数运算符，没啥特别的东西，小学就学过了吧？

关系运算符

假设A的值为20，B的值为30.

那么如下的运算结果：

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

public class A08_RelationalOperator {

    public static void main(String[] args) {
        int a = 20;
        int b = 30;
        System.out.println("a == b 运算结果： " + (a == b) );
        System.out.println("a != b 运算结果： " + (a != b) );
        System.out.println("a > b 运算结果： " + (a > b) );
        System.out.println("a < b 运算结果： " + (a < b) );
        System.out.println("b >= a 运算结果： " + (b >= a) );
        System.out.println("b <= a 运算结果： " + (b <= a) );
        //举例子
        int account = 100;
        int shoppingPrice = 2000;
        if(account >= shoppingPrice){ //if-else 条件语句后面会学。关系运算符一般都是和if-else结合。
            System.out.println("do something.购买商品。");
        }else{
            System.out.println("提示：卡里钱不够。");
        }
    }
}

逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	(A&&B)为假。
||	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	(A||B)为真。
!	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	!B 为真。

public class A09_LogicalOperator {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b 运算结果： " + (a&&b));
        System.out.println("a || b 运算结果： " + (a||b));
        System.out.println("!a 运算结果： " + !a);
        System.out.println("!b 运算结果： " + !b);
        System.out.println("!(a && b) 运算结果： " + !(a && b));
        //例子,此处注意，如果下面的第一个条件为false，就会不执行后面的条件判断。这称作短路
        int c = 3;
        boolean d = (c < 1)&&(++c<10);
        System.out.println(c);
        System.out.println(d);
    }
}

条件语句if-else

if语句

语法如下：

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

public class A10_If {

    public static void main(String args[]){
        int grade = 59;
        if( grade < 60 ){
            System.out.print("判断为true,进入到if语句的逻辑,成绩判断为不及格。");
        }
        grade = 99;
        if( grade < 60 ){
            System.out.print("判断为false,不会进入到这里。");
        }
    }
}

if…else语句

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值 false 时，else 语句块会被执行。

语法如下：

if(布尔表达式){
   //如果布尔表达式的值为true
}else{
   //如果布尔表达式的值为false
}

public class A10_IfElse {

    public static void main(String args[]){
        int grade = 99;
        if( grade < 60 ){
            System.out.print("判断为true,进入到if语句的逻辑");
        }else{
            System.out.print("判断为false,进入到这里。成绩及格。");
        }
    }
}

if…else if…else 语句

这种语句可以检测到多种可能的情况。

该语法就是在if…else的中间插入else if判断，else if只能在if和else中间。

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}

public class A11_IfElseIfElse {

    public static void main(String args[]){
        int grade = 70;
        if( grade < 60 ){
            System.out.print("不及格");
        }else if(grade>=60 && grade <75){
            System.out.println("及格。");
        }else if(grade>=75 && grade <85){
            System.out.println("良好。");
        }else if(grade>=85 && grade <99){
            System.out.println("优秀。");
        }else{
            System.out.print("满分。");
        }
    }
}

嵌套的 if…else 语句

以上的三种用法if,if…else,if…else if…else，可以基于需要，互相嵌套。

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
   if(布尔表达式 2){
      //如果布尔表达式 2的值为true执行代码
   }
}else{
    if(布尔表达式 3){
      //如果布尔表达式3的值为true执行代码
   }else{
        //其它代码
    }
    //其它代码
}

public class A12_IfElses {
    public static void main(String args[]){
        int grade = 99;
        if( grade < 60 ){
            System.out.print("判断为true,进入到if语句的逻辑");
            if(grade<40){
                System.out.println("学渣。");
            }else{
                System.out.println("继续努力。");
            }
        }else{
            System.out.print("判断为false,进入到这里。成绩及格。");
            if(grade<85){
                System.out.println("良好。");
            }else{
                System.out.println("优秀。");
            }
        }
    }
}

条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符是决定哪个值应该赋值给变量。

 variable x = (expression result) ? valueA if true : valueB if false

public class A13_TernaryOperator {
    public static void main(String[] args) {
        int appleBag1 = 5, appleBag2 = 10; //两袋苹果
        int appleBag3;
        if(appleBag1<appleBag2){ //一般方式的代码，判断哪个多的，就选哪个。
            appleBag3 = appleBag2;
        }else{
            appleBag3 = appleBag1;
        }
        //三元运算符的方式
        appleBag3 = appleBag1<appleBag2 ? appleBag2 : appleBag1;
        System.out.println(appleBag3);
    }
}

位运算符（了解概念）

位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。

下表列出了位运算符的基本运算，假设整数变量 A 的值为 44和变量 B 的值为 22，代码如下方所示：

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B）
|	如果相对应位都是 0，则结果为 0，否则为 1	（A | B）
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2

public class A14_BitOperator {

    public static void main(String[] args) {
        // 0&0 = 0
        System.out.println("0 & 0 = " + (0 & 0));
        // 0 & 1 = 0
        System.out.println("0 & 1 = " + (0 & 1));
        // 1 & 0 = 0
        System.out.println("1 & 0 = " + (1 & 0));
        // 1&1 = 1
        System.out.println("1 & 1 = " + (1 & 1));
        // 0|0 = 0
        System.out.println("0 | 0 = " + (0 | 0));
        // 0 | 1 = 0
        System.out.println("0 | 1 = " + (0 | 1));
        // 1 | 0 = 0
        System.out.println("1 | 0 = " + (1 | 0));
        // 1|1 = 1
        System.out.println("1 | 1 = " + (1 | 1));
        // 0^0 = 0
        System.out.println("0 ^ 0 = " + (0 ^ 0));
        // 0 ^ 1 = 1
        System.out.println("0 ^ 1 = " + (0 ^ 1));
        // 1 ^ 0 = 1
        System.out.println("1 ^ 0 = " + (1 ^ 0));
        // 1^1 = 0
        System.out.println("1 ^ 1 = " + (1 ^ 1));

        int a = 44; // 44 = 0010 1100
        int b = 22; // 22 = 0001 0110
        int c = 0;
        c = a & b;  //  4 = 0000 0100
        System.out.println("a & b = " + c);

        c = a | b;  // 62 = 0011 1110
        System.out.println("a | b = " + c);

        c = a ^ b;  // 58 = 0011 1010
        System.out.println("a ^ b = " + c);

        c = ~a;     //-45 = 1101 0011  (这里是补码，不是原码) //int类型实际上是4个字节的，
        System.out.println("~a = " + c);

        c = a << 2; //176 = 1011 0000 //int类型实际上是4个字节的，此处左移实际上不是负数。
        System.out.println("a << 2 = " + c);

        c = a >> 2; // 11 = 0000 1011
        System.out.println("a >> 2  = " + c);

        c = a >>> 2; // 11 = 0000 1011
        System.out.println("a >>> 2 = " + c);

    }
}

赋值运算符

下面是Java语言支持的赋值运算符：

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
％=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 3等价于C = C << 3
>> =	右移位赋值运算符	C >> = 1等价于C = C >> 1
＆=	按位与赋值运算符	C＆= 3等价于C = C＆3
^ =	按位异或赋值操作符	C ^ = 3等价于C = C ^ 3
| =	按位或赋值操作符	C |= 3等价于C = C | 3

public class A15_AssignmentOperator {
    public static void main(String[] args) {
        int a = 11;
        int b = 22;
        int c = 0;
        c += a ;
        System.out.println("c += a 结果： " + c );
        c -= a ;
        System.out.println("c -= a 结果： " + c );
        c *= a ;
        System.out.println("c *= a 结果： " + c );
        a = 10;
        c = 25;
        c /= a ;
        System.out.println("c /= a 结果：" + c );
        a = 10;
        c = 25;
        c %= a ;
        System.out.println("c %= a 结果： " + c );
        c <<= 3 ;
        System.out.println("c <<= 3 结果：" + c );
        c >>= 1 ;
        System.out.println("c >>= 1 结果： " + c );
        c >>= 1 ;
        System.out.println("c >>= 1 结果： " + c );
        c &= a ;
        System.out.println("c &= a  结果： " + c );
        c ^= a ;
        System.out.println("c ^= a  结果： " + c );
        c |= a ;
        System.out.println("c |= a  结果： " + c );
    }
}

Java运算符优先级（记住常用的）

数学中，我们知道加减的优先级是在乘除之后的。那么在计算机语言中也是一样，当表达式复杂的时候，一样需要注意优先级问题。

如果记不清的时候，就用英文输入法的括号()。

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

优先级	运算符	结合性
1	()、[]、{}	从左向右
2	!、+、-、~、++、–	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	«、»、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	|	从左向右
11	&&	从左向右
12	||	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>=	从右向左

public class A16_Priority {

    public static void main(String[] args) {
        //单目>算数运算符>移位>比较>按位>逻辑>三目>赋值
        boolean result;
        int a = 4;
        int b = 5;
        result = b>~a?new int[]{10,20}[1]*b + ++a >>2 * b--> 10||(4+a&~b*3)>2: (4*a&~b+a*3)>=2;
        System.out.println(result);
    }
}

---

​ 扫码关注小程序,进群讨论提问,获取源代码.获得最新更新,关注下方公众号.

​

本文版权归作者所有，欢迎转载，但未经作者同意, 必须保留小程序和二维码,且在文章首行位置标注如下转载说明:

文章转载自 “原文链接URL”, 作者: 柳五苏世_Brad