JAVA代码 运算符

 1 package ceshi2;
 2 /*
 3     布尔运算符
 4         
 5         &  逻辑与    两边都是true，结果是true
 6         |    逻辑或    一边是true,结果就是true
 7         !    逻辑非    取反  !true --> false
 8         ^    逻辑异或        两边只要是不一致就是true
 9         
10         &&    短路与    用法和 & 一样。
11         || 短路或    用法和 | 一样
12     
13     布尔运算符两边的算子必须是布尔类型，整个表达式的运算结果也是一个布尔类型。
14     例如： 5>10 | 6>5    --> true
15 */
16 
17 public class OperatorTest03{
18     
19     public static void main(String[] args){
20         
21         System.out.println(5>3 & 5>4); //true
22         System.out.println(5>3 & 5>6); //false  逻辑与只要有一个是false，结果就是false
23         
24         System.out.println(5>3 | 5>10); //true
25         
26         System.out.println(5>11 | 5>10); //false
27         
28         System.out.println(!false); //true
29         
30         
31         System.out.println(true^false); //true
32         System.out.println(false^true); // true
33         System.out.println(true^true); //false
34         System.out.println(false^false); //false
35         
36         
37         //关于短路与
38         /*
39         int a = 10;
40         int b = 10;
41         
42         System.out.println(a < b & a++ >= b);
43         
44         System.out.println(a); //11
45         */
46         
47         
48         int a = 10;
49         int b = 10;
50         
51         //短路：后边那个表达式不执行.
52         //什么时候发生短路与？第一个算子结果是false的时候。
53         //什么时候发生短路或？第一个算子结果是true的时候。
54         System.out.println(a < b && a++ >= b);
55         
56         System.out.println(a); //10
57     }
58 }

布尔运算符

 1 package ceshi2;
 2 /*
 3     关于赋值运算符
 4     
 5         基本的赋值运算符
 6             =    
 7         
 8         扩展的赋值运算符
 9         
10             +=        追加
11             -=
12             *=
13             /=
14             %=
15         
16         += 例子： 
17             int i = 10; 
18             i += 10; 等同于 i = i + 10;
19         
20 */
21 public class OperatorTest04{
22     
23     public static void main(String[] args){
24         
25         //基本的赋值运算符
26         int a = 10;
27         
28         //追加
29         a += 10; //a = a+10;
30         System.out.println(a); //20
31         
32         //a==20
33         a -= 5;
34         System.out.println(a); //15
35         
36         //a==15
37         a *= 3;
38         System.out.println(a); //45
39         
40         //a==45
41         a /= 15; // a = a/15;
42         System.out.println(a); //3
43         
44         //a==3
45         a %= 2; //a = a%2;
46         System.out.println(a); //1
47         
48         
49         //基本赋值运算符和扩展赋值运算符的区别
50         byte i = 10;
51         
52         //编译无法通过。运算结果是int类型，前边的变量是byte类型.
53         //i = i + 10;
54         
55         //语法：扩展赋值运算符不改变运算结果类型。可能损失精度。
56         i += 10; 
57         
58         
59         //虽然编译通过，精度损失严重。
60         i += 1000;
61         
62         
63         
64     }
65 }

赋值运算符

 1 package ceshi2;
 2 /*
 3     关于字符串连接运算符
 4     
 5         + 运算符可以:
 6         
 7             1.做加法运算(+两边只要都是数字类型，一定是加法运算)
 8             
 9             2.字符串连接(+两边任意一端只要是字符串类型，则一定是字符串连接)
10 */
11 public class OperatorTest05{
12     
13     public static void main(String[] args){
14         
15         //字符串连接
16         System.out.println("PI=" + 3.14);  //运算结果是字符串类型
17         
18         int a = 10;
19         int b = 12;
20         
21         System.out.println("a+b=" + (a+b)); //"a+b=22"
22         
23         System.out.println("a+b=" + a + b); //"a+b=1012"
24         
25         
26         System.out.println(a + "+" + b + "=" + (a+b)); //"10+12=22"
27         
28     }
29 }

字符串连接运算符

 1 package ceshi2;
 2 /*
 3     条件运算符(三目运算符)
 4         ?:
 5         
 6         语法：
 7             boolean表达式?表达式1:表达式2
 8             
 9             boolean表达式的结果是true,则整个表达式的结果就是表达式1的结果，相反则是表达式2的结果。
10         
11 */
12 public class OperatorTest06{
13     
14     public static void main(String[] args){
15         
16         //这个不是java语句.
17         //10; //Error
18         
19         int i = 10; //可以
20         
21         
22         //判断以下程序编译可否通过?
23         boolean sex = false;
24         
25         //不是语句
26         //sex?'男':'女';
27         
28         char c = (sex?'男':'女');
29         
30         System.out.println(c);
31         
32         
33         boolean isSuccess = true;
34         
35         //类型不兼容
36         //char c1 = isSuccess?'S':"失败";
37         
38         /*
39         System.out.println('a');
40         System.out.println("abc");
41         */
42         
43         System.out.println(isSuccess?'S':"失败");
44     }
45 }

条件运算符(三目运算符)

 1 /*
 2     关于算术运算符
 3         +    求和
 4         -    相减
 5         *    乘积
 6         /    相除
 7         ++    自加1
 8         -- 自减1
 9         %  取余、求模
10 */
11 public class OperatorTest01{
12     
13     public static void main(String[] args){
14         
15         int a = 10;
16         int b = 3;
17         
18         System.out.println(a+b); //13
19         System.out.println(a-b); //7
20         System.out.println(a*b); //30
21         System.out.println(a/b); //3
22         System.out.println(a%b); //1
23         
24         
25         //关于++
26         int k = 10;
27         k++;
28         System.out.println("k=" + k); //11
29         
30         
31         //++出现在变量的后面
32         int m = 10;
33         int e = m ++; //++如果出现在变量的后面，先赋值后自加1
34         System.out.println("e="+e); //10
35         System.out.println("m="+m); //11
36         
37         
38         //++出现在变量的前面
39         int f = 10;
40         ++f;
41         System.out.println("f=" + f); //11
42         
43         
44         int c = 10;
45         int d = ++c; //++如果出现在变量的前面，先自加1再赋值
46         System.out.println("d="+d); //11
47         System.out.println("c="+c); //11
48         
49         
50         
51         int z = 10;
52         System.out.println(z++); //10
53         System.out.println(z); //11
54         
55         int y = 10;
56         System.out.println(++y); //11
57         System.out.println(y); //11
58         
59         
60     }
61 }

算数运算符

 1 /*
 2     关系运算符
 3         >   大于
 4         >=     大于等于
 5         <   小于
 6         <=  小于等于
 7         ==  判断是否相等(基本数据类型)
 8         !=  不等于
 9         
10         关系运算符的运算结果一定是boolean类型.
11 */
12 
13 public class OperatorTest02{
14     
15     public static void main(String[] args){
16         
17         int a = 10;
18         int b = 10;
19         
20         //判断两个基本数据类型是否相等，必须使用“==”,    "="是赋值运算.
21         boolean c = (a==b); //不知道运算符的优先级就加括号.
22         
23         System.out.println(a>b); //false
24         System.out.println(a>=b); //true
25         System.out.println(a<b); //false
26         System.out.println(a<=b); //true
27         System.out.println(a==b); //true
28         System.out.println(a!=b); //false
29         
30     }
31 }

关系运算符

 

转载于:https://www.cnblogs.com/zjy954/p/5013705.html