java语言基础--运算符

本文主要是介绍java语言基础--运算符，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一、算术运算符：

       +、-、*、/、%、++（自加）、--（自减）

       对于++运算符来说：

可以出现在变量前，也可以出现在变量后

不管++出现在变量前还是后，总之++执行结束后，变量的值一定会自加1

 1 public class OperatorTest{
 2     public static void main(String[] args) {
 3         
 4         int a = 10;
 5         int b = 3;
 6         System.out.println(a + b);
 7         System.out.println(a - b);
 8         System.out.println(a * b);
 9         System.out.println(a / b);
10         System.out.println(a % b);
11         
12         //重点掌握++和--
13         //++可以出现在变量前，也可以出现在变量后
14         int i = 10;
15         //i变量自加1
16         i++;
17         System.out.println(i);//11
18         
19         int k = 10;
20         //k变量自加1
21         ++k;
22         System.out.println(k);//11
23         
24         //语法：当++出现在变量后，会先做赋值运算，再自加1
25         int m = 20;
26         int n =m++;
27         System.out.println(n);//20
28         System.out.println(m);//21
29         
30         //语法规则：当++出现在变量前时，会先进行自加1的运算，然后再赋值
31         int x = 100;
32         int y = ++x;
33         System.out.println(x);//101
34         System.out.println(y);//101
35     }
36 }

练习：

 1 public class Test {
 2     public static void main(String[] args) {
 3         //题目
 4         int c = 90;
 5         System.out.println(c++);//90
 6         //分解上面程序：先赋值后运算
 7         //int temp = c++;
 8         //System.out.println(temp);
 9         System.out.println(c);//91
10         
11         int d = 80;
12         System.out.println(++d);//81
13         System.out.println(d);//81
14     }
15 }

二、关系运算符：

>、>=、<、<=、==、!=

规则：所有的关系运算符的运算结果都是布尔类型，不是true就是false

在java语言中：

=：赋值运算符

==：关系运算符，判断是否相等

注意：关系运算符中如果有两个符号的话，两个符号之间不能有空格

 1 public class Test {
 2     public static void main(String[] args) {
 3         
 4         int a = 10;
 5         int b = 10;
 6         System.out.println(a > b);//false
 7         System.out.println(a >= b);//true
 8         System.out.println(a < b);//false
 9         System.out.println(a <= b);//true
10         System.out.println(a == b);//true
11         System.out.println(a != b);//false
12     }
13 }

三、逻辑运算符：

&（逻辑与）、|（逻辑或）、！（逻辑非）、&&（短路与）、||（短路或）

      并且                 或者               取反

特点：逻辑运算符要求两边都是布尔类型，并且最终的运算结果也是布尔类型

1、&（逻辑与）、|（逻辑或）、！（逻辑非）

 1 public class Test {
 2     public static void main(String[] args) {
 3         
 4         //对逻辑&来说，只要有一边是false，结果就是false
 5         //只有两边同时为true结果才为true
 6         System.out.println(true & true);//true
 7         System.out.println(true & false);//false
 8         System.out.println(false & false);//false
 9         
10         //逻辑或是只要有一边是true，结果就是true
11         System.out.println(true | true);//true
12         System.out.println(true | false);//true
13         System.out.println(false | false);//false
14         
15         //逻辑非：取反
16         System.out.println(!true);//false
17     }
18 }

2、&&（短路与）、||（短路或）

短路与 和 逻辑与 有什么区别？

• 这两个运算符的运算结果没有任何区别，完全相同。
• 只不过 短路与 会发生短路现象

短路现象：右边表达式不执行

什么时候使用&&，什么时候使用&

• 从效率方面，&&比&的效率高一些
• 因为逻辑与&不管第一个表达式结果是什么，第二个表达式一定会执行。
• 以后的开发中，短路与&&和逻辑与&还是同时并存的
• 大部分情况下都建议使用短路与&&，只有当既需要左边表达式执行，又需要右边表达式执行的时候，才会选择逻辑与&

什么时候发生短路或||现象？

• 只要有一边true，结果就是true
• 所以当左边的表达式结果是true的时候，右边的表达式不要执行，此时会短路

 1 public class Test {
 2     public static void main(String[] args) {
 3         //&，&&运行结果一样
 4         System.out.println(true & true);//true
 5         System.out.println(true & false);//false
 6         System.out.println(false & false);//false
 7         
 8         System.out.println(true && true);//true
 9         System.out.println(true && false);//false
10         System.out.println(false && false);//false
11         
12         //短路现象，什么会发生短路现象
13         int x = 10;
14         int y = 11;
15         //逻辑与什么时候为true(两边都为true，结果才是true)
16         //左边 x>y表达式结果是false了，整个表达式的结果都是false
17         //按理来说右边的表达式不应该执行
18         System.out.println(x>y & x>y++);
19         //通过这个测试得出：x>y++这个表达式执行了
20         System.out.println(y);//12
21         
22         //测试短路与&&
23         int m = 10;
24         int n =11;
25         //使用短路与的时候，当左边的表达式为false的时候，右边表达式不执行，
26         //这种现象被称为短路现象
27         System.out.println(m>n && m>n++);
28         System.out.println(n);//11
29         
30     }
31 }

四、赋值运算符：

1、赋值运算符包括：基本赋值运算符 和 扩展赋值运算符

2、基本赋值运算符：=

3、扩展赋值运算符：+=、-=、*=、/=、%=

注意：扩展赋值运算符在编写的时候，两个符号之间不能有空格

4、很重要的语法机制：

• 使用扩展赋值运算符的时候，永远都不会改变运算结果类型

byte x = 100；

x += 1；

x自诞生以来是byte类型，那么x变量的类型永远都是byte类型。不管后面是多大的数字

 1 public class Test{
 2     public static void main(String[] args) {
 3         //赋值运算符“=”右边优先级比较高，先执行右边的表达式
 4         //然后将表达式执行结果放到左边“盒子”中（赋值）
 5         int i = 10;
 6         //重新赋值
 7         i = 20;
 8         byte b = 10;
 9         b = 20;
10         
11         /*
12            以 +=运算符作为代表，学习扩展赋值运算符
13          其他运算符原理相似
14          */
15         int k = 10;
16         k += 20;//k变量追加20
17         System.out.println(k);//30
18         
19         int m = 10;
20         //+=运算符类似于下面表达式
21         m = m + 20;
22         System.out.println(m);//30
23         
24         //研究：i += 10 和 i = i + 10真的完全一样吗？
25         //答案：不一样，只能说相似，其实本质上并不是完全相同
26         byte x = 100;
27         System.out.println(x);
28         
29         //分析：这个代码是否能编译通过
30         //错误：不兼容的类型：从int转换到byte可能有损失
31         //x=x+1;//编译器检测到x+1是int类型，int类型可以直接赋值给byte类型的变量吗？
32         
33         //使用扩展赋值运算符可以吗？
34         //可以，所以得出结论：x += 1;和 x = x+1;不一样
35         //其实：x += 1 等同于：x = (byte)(x+1);
36         x += 1; 
37         System.out.println(x);//101
38         
39         //早就超出byte的取值范围了
40         x += 199;//x = (byte)(x+199);
41         System.out.println(x);//44(自动损失精度)
42         
43         
44         int a = 100;
45         a +=100;
46         System.out.println(a);//200
47         
48         a -=100;
49         System.out.println(a);//100
50         
51         a *= 10;
52         System.out.println(a);//1000
53         
54         a /= 30;
55         System.out.println(a);//33
56         
57         a %= 10;
58         System.out.println(a);//3
59         
60     }
61 }

五、条件运算符：（三目运算符）

语法格式：

• 布尔表达式 ？表达式1 ：表达式2

执行原理：

• 布尔表达式的结果为true时，表达式1的执行结果作为整个表达式的结果。
• 布尔表达式的结果为false时，表达式2的执行结果作为整个表达式的结果。

 1 public class Test {
 2     public static void main(String[] args) {
 3         
 4         //合法的java语句
 5         //表示声明一个变量，起名i
 6         int  i = 100;
 7         
 8         //错误：不是语句
 9         //The left-hand side of an assignment must be a variable
10         //100;
11         
12         boolean sex = false;
13         
14         //分析以下代码是否存在语法错误？
15         //错误：不是语句
16         //Void methods cannot return a value
17         //sex ? '男' : '女';
18         
19         //前面的变量的类型不能随意编写
20         //最终的计算结果是字符型，所以变量也需要使用char类型
21         char  c = sex ? '男' : '女';
22         System.out.println(c);
23         
24         //错误：不兼容的类型：条件表达式中的类型错误
25         //char x = sex ? '男' : "女";
26         //System.out.println(x);
27         
28         //这样可以吗
29         System.out.println(sex ? '男' : "女");//这里很牛，什么类型数据都可以放
30         
31         
32     }
33 }

六、字符串连接运算符：

 1 /*
 2    +运算符：
 3    1、+运算符在java语言中有两个作用
 4                作用1：求和
 5                作用2：字符串拼接
 6    2、什么时候求和？什么时候进行字符串拼接？
 7                当+运算符两边都是数字类型的时候，求和
 8                当+运算符两边的任意一边是字符串类型，那么这个+会进行字符串拼接操作。
 9    3、一定要记住：：字符串拼接完之后结果还是一个字符串。
10  */
11 public class Test1 {
12     public static void main(String[] args) {
13         //定义一个年龄的变量
14         int age = 35;
15         //+在这里会进行字符串的拼接操作
16         System.out.println("年龄=" + age);//年龄=35
17         
18         int a = 100;
19         int b = 200;
20         //+ 加法运算
21         int c = a + b;
22         System.out.println(c);//300
23         
24         //注意：当一个表达式中有多个加号的时候
25         //遵循自左向右的顺序依次执行（除非加小括号，小括号优先级高）
26         //先求和后拼接
27         System.out.println(a + b + "110");//300110
28         System.out.println(a + (b + "110"));//100200110
29         
30         //在控制台上输出“100+200=300”
31         //以下有效的运算符+一共有4个，均为字符串拼接操作
32         System.out.println(a + "+" + b + "=" + c);
33         
34         //分析这个结果是多少
35         //拼接后的结果是 100+200=100200；
36         System.out.println(a + "+" + b + "=" + a + b);
37         //小括号里的+是求和操作
38         System.out.println(a + "+" + b + "=" + (a + b));//100+200=300
39         
40         //在java语言中怎么定义字符串类型的变量
41         //String是字符串类型，String是引用数据类型
42         //name是变量名，合法标识符
43         //“jack”是字符串型字面量
44         String name = "jack";
45         
46         //错误：类型不兼容
47         //String = 100;
48         
49         //口诀：加一个双引号""，双引号之间加两个加号++，两个加号中间加变量名："+变量名+"
50         System.out.println("登陆成功欢迎"+name+"回来");
51     }
52 }

这篇关于java语言基础--运算符的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！