Java教程

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语言基础--运算符的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!