算术运算符

  1. 运算符和表达式+,a+b

  2. +（加）-（减）*（乘） /（除）%（取余）

    /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
    整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/*
    ``算术运算符
*/
public class suanshu {
    public static void main(String[] arge){
        //定义两个变量
        int a = 6;
        int b = 4;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(a % b);

        //除法得到的是商，取余得到的是余数

        //整数相除只能得到整数，要想得到小数，必须有浮点数的参与
        System.out.println(6.0 / 4);
    }
}
结果-------------
	10
	2
	24
	1
	2
	1.5

  1. 字符的“+”操作

    拿字符在计算机底层对应的数值来进行计算的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class jiahao {
    public static void main(String[] arge){
        //定义两个变量
        int i = 10;
        char c = 'A'; //字符“A”的值是65
        c = 'a'; //字符‘a’的值是95
        c = '0'; //‘0’的值是48
        System.out.println(i + c);

        //char ch = 1 + c;
        //char类型会被自动提升为int类型
        int j = 1 + c;
        System.out.println(j);
    }
}
结果-----------
    58
    49

算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升

提升规则：

byte类型，short类型和char类型将被提升到int类型

整个表达式的类型自动提升到表达式中最高等级操作数同样的类型

等级顺序：byte，short，char→int→long→float→double

  1. 字符串+数字

    当“+”操作中出现字符串时，这个“+”是字符串连接符，而不是算术运算。

    “ityinzhuang”+666

    在“+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class jiashuzi {
    public static void main(String[] args) {
        System.out.println("pen"+"apple");
        System.out.println("pen"+"8");
        System.out.println("8"+"pen");

        System.out.println("apple"+5+5);
        System.out.println(5+5+"apple");
    }
}
结果------------
    penapple
	pen8
	8pen
	apple55
	10apple

赋值运算符

运算符 含义 实例 结果
+= 将该运算符左边的数值加上右边的数值， 其结果赋值给左边变量本身 int a=5; a+=2等价于a=a+2 a=7
-= 将该运算符左边的数值减去右边的数值， 其结果赋值给左边变量本身 int a=5; a-=2等价于a=a-2 a=3
*= 将该运算符左边的数值乘以右边的数值， 其结果赋值给左边变量本身 int a=5; a*=2等价于a=a*2 a=10
/= 将该运算符左边的数值整除右边的数值， 其结果赋值给左边变量本身 int a=5; a/=2等价于a=a/2 a=2
%= 将该运算符左边的数值除以右边的数值后取余，其结果赋值给左边变量本身 int a=5; a%=2等价于a=a%2 a=1 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class fuzhi {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int c;
        c = a;
        System.out.println(c);
        c += a;
        System.out.println(c);
        c += 50;
        System.out.println(c);
    }
}
结果-------------------
	5
	10
	60
  • 隐含了强制的类型转换

自增自减运算符

  • ++和–运算符可以放在变量之前，也可以放在变量之后，当运算符放在变量之前时(前缀)，先自增/减，再赋值；当运算符放在变量之后时(后缀)，先赋值，再自增/减
  • 例如，当 b = ++a 时，先自增（自己增加 1），再赋值（赋值给 b）；当 b = a++ 时，先赋值(赋值给 b)，再自增（自己增加 1）。也就是，++a 输出的是 a+1 的值，a++输出的是 a 本身值
1
2
3
4
5
6
7
8
9
10
11
12
   public static void main(String[] args) {
       int a = 10;
       int b,c;
       b = a++;
       System.out.println(b); //此时a已经加1
       c = ++a;
       System.out.println(c);
   }
}
结果------------
   10
   12

关系运算符

运算符 描述
== 检查如果两个操作数的值是否相等，如果相等则条件为true。
!= 检查如果两个操作数的值是否相等，如果值不相等则条件为true。
> 检查左操作数的值是否大于右操作数的值，如果是那么条件为true。
< 检查左操作数的值是否小于右操作数的值，如果是那么条件为true。
>= 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为true。
<= 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为true。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class guanxi {
    public static void main(String[] args) {
        System.out.println(5==6);
        System.out.println(5!=6);
        System.out.println(5>6);
        System.out.println(5>=6);
        System.out.println(5<6);
        System.out.println(5<=6);

    }
}
结果----------------
    false
	true
	false
	false
	true
	true

逻辑运算符

  • &、|、^、!、&&、||

    image.png
    image.png

    1. &&:与，前后两个操作数必须都是true才返回true，否则返回false。

    2. &:不短路与，作用与&&相同，但不会短路。

    3. ||：或，只要两个操作数中有一个是true，就可以返回true，否则返回false。

    4. |不短路或，作用与||相同，但不会短路。

    5. !:非，只需要一个操作数，如果操作数为true,则返回false;如果操作数为false，则返回true。

    6. ^:异或，当两个操作数不同时才返回true,如果两个操作数相同则返false.

  • &&与&，||与｜的区别

    1. &&和&都是表示与，区别是&&只要有一个条件不一样就是不满足，如果第一个条件就是不满足就不判断后面的条件。而&要对所有的条件都进行判断。
    2. ||和|都是表示“或”，区别是||只要满足第一个条件，后面的条件就不再判断，而|要对所有的条件进行判断。

代码演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class test {
  public static void main(String[] args) {
    // 定义变量
    int i = 10;
    int j = 20;
    int k = 30;

    // &：有 false 则为 false
    System.out.println((i > j) & (i > k)); // false & false = false
    System.out.println((i < j) & (i > k)); // true & false = false
    System.out.println((i > j) & (i < k)); // false & ture = false
    System.out.println((i < j) & (i < k)); // ture & ture = ture
    
    // |：有 true 则为 true
    System.out.println((i > j) | (i > k)); // false | false = false
    System.out.println((i < j) | (i > k)); // true | false = ture
    System.out.println((i > j) | (i < k)); // false | ture = ture
    System.out.println((i < j) | (i < k)); // ture | ture = ture
    
    // ^：结果相同为 false，不同为 true
    System.out.println((i > j) ^ (i > k)); // false ^ false = true
    System.out.println((i < j) ^ (i > k)); // true ^ false = ture
    System.out.println((i > j) ^ (i < k)); // false ^ ture = ture
    System.out.println((i < j) ^ (i < k)); // ture ^ ture = false
    
    // !：结果相同为 false，不同为 true
    System.out.println((i > j)); // false = false
    System.out.println(!(i < j)); // !false = true
    System.out.println(!!(i > j)); // !!false = false
    System.out.println(!!!(i < j)); // !!!false = ture
  }  
}
1
2
3
4
5
6
7
8
9
10
11
12
boolean boo1 = true;
boolean boo2 = false;

System.out.println("a && b = " + (boo1 && boo2));
System.out.println("a & b = " + (boo1 && boo2));
		
System.out.println("a || b = " + (boo1 || boo2));
System.out.println("a | b = " + (boo1 | boo2));
		
System.out.println("!(a && b) = " + !(boo1 &&boo2));		
		
System.out.println("^(a && b) = " + (boo1 ^ boo2));	

1
2
3
4
5
6
7
8
9
10
11
12
13
14
算法说明：

首先第一题的结果是false,是因为前后的操作数必须都是true才返回true，否则返回false，所以返回false。

第二题的意思和第一题的也是一样。

第三题的结果是true，是因为boo1是true，boo2是false,在看看逻辑运算符的意思就知道结果，必须两个操作数中有一个是true，就可以返回true，否则返回false。

第四题的意思和第三题的也是一样。

第五题的结果是true,是因为题目写的是 !(boo1 && boo2)，括号里面是等于false，然后外面又加了“!”运算符，所以结果是true。
意思是操作数为true,则返回false;如果操作数为false，则返回true，简单的意思就是反着来，是true为false，是false为true。

第六题的结果也是true，是因为题目写的是boo1 ^ boo2，所以两个值不同才返回true，相同的就返回false。

三元运算符

  • 语法：条件表达式？表达式1：表达式2；

  • 运算规则：

    1. 如果条件表达式为true，运算后的结果是表达式1；

    2. 如果条件表达式为false，运算后的结果是表达式2；

1
2
3
4
5
6
7
8
9
10
public class sanyuan {
   public static void main(String[] args) {
       int a = 10;
       int b = 20;
       int c = 2;
       int max = a > b ? a : b;
       int max1 = max > c ? max : c;
       System.out.println("最大值为"+max1);
   }
}