Java基础教程

文章36 |   阅读 18659 |   点赞0

来源：https://blog.csdn.net/u010520724/category_11240199.html

Java基础系列6-Java的运算符

转x33g5p2x  于2021-12-18 转载在 其他  
字(7.2k)|赞(0)|评价(0)|浏览(523)

一.运算符概述

对常量和变量进行操作的符号称为运算符。

用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。
不同运算符连接的式子体现的是不同类型的表达式。
定义两个int类型的变量a、b，做加法(a + b)

常用运算符:

  1. 算术运算符
  2. 赋值运算符
  3. 关系运算符
  4. 逻辑运算符
  5. 三元运算符

1.1 算术运算符

算数运算符：
+、-、*、/、%、++、–

代码1:

  1. package Java_study;
  3. public class yunsuanfu {
  4. 	public static void main(String[] args) {
  5. 	//定义两个int类型的变量
  6. 	int a = 5;
  7. 	int b = 3;
  8. 	//8
  9. 	System.out.println(a + b);
  10.     //2
  11. 	System.out.println(a - b);
  12. 	//15
  13. 	System.out.println(a * b);
  14. 	//求商, 5/3=1.66(int取整数)=1
  15. 	System.out.println(a / b);
  16. 	// 求余数 5%3=2
  17. 	System.out.println(a % b);
  18. 	System.out.println("----------");
  19. 	// 整数计算，默认为整数 int类型 5/4=1
  20. 	System.out.println(5 / 4);
  21. 	//带小数计算，默认为浮点 double 类型 5 /4 = 1.25
  22. 	System.out.println(5.0 / 4);
  23. 	//带小数计算，默认为浮点 double 类型 5 /4.0 = 1.25
  24. 	System.out.println(5 / 4.0);
  25. 	}
  26. }

测试记录1:

  1. 8
  2. 2
  3. 15
  4. 1
  5. 2
  6. ----------
  7. 1
  8. 1.25
  9. 1.25

字符和字符串参与加法运算【‘a’+10=57】
字符参与运算其实是拿该字符对应的数值来操作:

  1. ‘a’ 97
  2. ‘A’ 65
  3. ‘0’ 48

字符串参与运算这里其实做的不是加法运算，而是字符串拼接。
字符串和其他类型的数据做拼接，结果是字符串类型的。

代码2:

  1. package Java_study;
  3. public class yunsuan2 {
  4. 	public static void main(String[] args) {
  5. 		//定义两个变量，一个int类型，一个char类型
  6. 		int a = 10;
  7. 		char ch = 'a';
  8. 		// 'a' + 10 = 97 + 10 = 107
  9. 		System.out.println(a + ch);
  10. 		System.out.println("----------");
  11. 		
  12. 		//字符串做加法
  13. 		//helloworld
  14. 		System.out.println("hello" + "world" );
  15. 		//hello10
  16. 		System.out.println("hello" + 10);
  17. 		//hello1020
  18. 		System.out.println("hello" + 10 +20);
  19. 		//30hello
  20. 		System.out.println(10 + 20 + "hello");
  21. 	}
  23. }

测试记录:

  1. 107
  2. ----------
  3. helloworld
  4. hello10
  5. hello1020
  6. 30hello

自增自减运算符【i++ 与 ++i】

  1. ++,–运算符：对变量做加1或者减1的操作。
  2. ++或者–既可以放在变量的后面，也可以放在变量的前面。
  3. 单独使用的时候，++或者–无论是放在变量的前面还是后面，结果是一样的。
  4. 参与操作的时候：
    1)如果 ++ 或者 - - 在变量的后面，先拿变量参与操作，后变量做或者- -
    2)如果 ++ 或者 - - 在变量的前面，先变量做    或者- -，后拿变量参与操作

代码3:

  1. package Java_study;
  3. public class yunsuan3 {
  4. 	public static void main(String[] args) {
  5. 		//定义一个int类型的变量
  6. 		int i = 10;
  7. 		System.out.println("i:" + i);
  8. 		
  9. 		// i = i +1 = 10 +1 = 11
  10. 		int b = ++i;
  11. 		System.out.println("i:" + i);
  12. 		System.out.println("b:" + b);
  13. 		
  14. 		// b = i = 11
  15. 		// (然后 i= i+ 1 = 12)
  16. 		b = i++;
  17. 		// i = 12
  18. 		System.out.println("i:" + i);
  19. 		// b = 11
  20. 		System.out.println("b:" + b);
  21. 	}
  23. }

测试记录:

  1. i:10
  2. i:11
  3. b:11
  4. i:12
  5. b:11

1.2 赋值运算符

  1. 基本的赋值运算符：=
  2. 扩展的赋值运算符：+=,-=,*=,/=,%=
    +=: a+=20;相当于a = (a的数据类型)(a + 20);

代码:

  1. package Java_study;
  3. public class yunsuan4 {
  4. 	public static void main(String[] args) {
  5. 		//定义变量
  6. 		int a = 10; // 把10赋值给int类型的变量a
  7. 		System.out.println("a:" + a);
  8. 		
  9. 		//扩展的赋值运算符: +=
  10. 		//把运算符左边的数据和右边的数据进行运算，然后把结果赋值给左边
  11. 		// a = a +20
  12. 		a +=20;
  13. 		System.out.println("a:" + a);
  14. 		
  15. 		// short s = 1;
  16. 		// s = s + 1;
  17. 		
  18. 		//扩展的赋值运算符隐含了强制类型转换
  19. 		//a += 20 等价于 a = (a的数据类型)(a+20)
  20. 		short s = 1;
  21. 		s += 1;
  22. 		System.out.println("s:" + s);
  23.  	}
  25. }

测试记录:

  1. a:10
  2. a:30
  3. s:2

1.3 关系运算符（比较运算符）

关系运算符包含以下内容:
==、!=、>、>=、<、<=

关系运算符的结果都是boolean型，也就是要么是true，要么是false。

注意事项:
关系运算符“==”不能误写成“=”。

代码:

  1. package Java_study;
  3. public class yunsuan5 {
  4. 	public static void main(String[] args) {
  5. 		//定义三个变量
  6. 		int a = 10;
  7. 		int b = 20;
  8. 		int c = 10;
  9. 		
  10. 		//==
  11. 		System.out.println("------[==]------");
  12. 		// a == b : false (10=20)
  13. 		System.out.print("a ==b:");
  14. 		System.out.println(a == b);
  15. 		// a == c : true (10=10)
  16. 		System.out.print("a == c:");
  17. 		System.out.println(a == c);
  18. 		
  19. 		//!=
  20. 		System.out.println("----[!=]------");
  21. 		// a != b : true (10!=20)
  22. 		System.out.print("a != b:");
  23. 		System.out.println(a != b);
  24. 		// a != c :false (10!=10)
  25. 		System.out.print("a != c:");
  26. 		System.out.println(a != c);
  27. 		
  28. 		//>
  29. 		System.out.println("-----[>]------");
  30. 		//a > b: false (10>20)
  31. 		System.out.print("a > b:");
  32. 		System.out.println(a > b);
  33. 		// a > c false (10>10)
  34. 		System.out.print("a > c:");
  35. 		System.out.println(a > c);
  36. 		
  37. 		//>=
  38. 		System.out.println("------[>=]------");
  39. 		// a >= b: false (10>20)
  40. 		System.out.print("a >= b:");
  41. 		System.out.println(a >= b);
  42. 		// a >= c :true (10>=10)
  43. 		System.out.print("a >= c:");
  44. 		System.out.println(a >= c);
  45. 		
  46. 		// == 与 =
  47. 		System.out.println("------[==与=]------");
  48. 	    // a == b: false (10=10)
  49. 		System.out.print("a == b:");
  50. 		System.out.println(a == b);
  51. 		// a = b : 20 (先把b的值付给了a，再吧a作为结果输出)
  52. 		System.out.print("a = b:");
  53. 		System.out.println(a = b);
  54. 	}
  56. }

测试记录:

  1. ------[==]------
  2. a ==b:false
  3. a == c:true
  4. ----[!=]------
  5. a != b:true
  6. a != c:false
  7. -----[>]------
  8. a > b:false
  9. a > c:false
  10. ------[>=]------
  11. a >= b:false
  12. a >= c:true
  13. ------[==与=]------
  14. a == b:false
  15. a = b:20

1.4 逻辑运算符

逻辑运算符用于连接关系表达式，在Java中不可以写成3<x<6，应该写成x>3 && x<6 。

逻辑运算符：
与【&】【&&】、或【||】、非【！】

结论：

  1. 与【&】【&&】：有false则false。
    1)&　不管前面的条件是否正确，后面都执行
    2)&&　前面条件正确时，才执行后面，不正确时，就不执行，就效率而言，这个更好
  2. 或【||】：有true则true。
  3. 非【！】：非false则true，非true则false。
    特点：偶数个【！】不改变本身。

代码:

  1. package Java_study;
  3. public class yunsuanfu6 {
  4. 	public static void main(String[] args) {
  5. 		//定义变量
  6. 		int a = 3;
  7. 		int b = 4;
  8. 		int c = 5;
  9. 		
  10. 		//&&逻辑与
  11. 		System.out.println("-----[&&逻辑与 满足全部条件]------");
  12. 		//(3 > 4) && (3 > 5) ==> false && false :false
  13. 		System.out.print("(3 > 4) && (3 > 5) ==> false && false :false");
  14. 		System.out.println((a > b) && (a > c));
  15. 		//(3 < 4) && (3 > 5) ==> true && false : false
  16.         System.out.print("(3 < 4) && (3 > 5) ==> true && false : ");
  17.         System.out.println((a < b) && (a > c)); //true && false
  18.         //(3 > 4) && (3 < 5) ==> false && true : false
  19.         System.out.print("(3 > 4) && (3 < 5) ==> false && true : ");
  20.         System.out.println((a > b) && (a < c)); //false && true
  21.         //(3 < 4) && (3 < 5): ==> true && true : true
  22.         System.out.print("(3 < 4) && (3 < 5): ==> true && true : ");
  23.         System.out.println((a < b) && (a < c)); //true && true
  25.         //||逻辑或
  26.         System.out.println("-----【||逻辑或 满足任一条件】-------");
  27.         //(3 > 4) || (3 > 5) ==> false || false : false
  28.         System.out.print("(3 > 4) || (3 > 5) ==> false || false : ");
  29.         System.out.println((a > b) || (a > c));
  30.         //(3 < 4) || (3 > 5) ==> true || false : true
  31.         System.out.print("(3 < 4) || (3 > 5) ==> true || false : ");
  32.         System.out.println((a < b) || (a > c));
  33.         //(3 > 4) || (3 < 5) ==> false || true : true
  34.         System.out.print("(3 > 4) || (3 < 5) ==> false || true : ");
  35.         System.out.println((a > b) || (a < c));
  36.         //(3 < 4) || (3 < 5) ==> true || true : true
  37.         System.out.print("(3 < 4) || (3 < 5) ==> true || true : ");
  38.         System.out.println((a < b) || (a < c));
  40.         //!逻辑非
  41.         System.out.println("-----【!逻辑非 取反】-------");
  42.         //(3 > 4) : false
  43.         System.out.print("(3 > 4) : ");
  44.         System.out.println((a > b));
  45.         //!(3 > 4) ==> ! false : true
  46.         System.out.print("!(3 > 4) ==> ! false : ");
  47.         System.out.println(!(a > b));
  48.         //!!(3 > 4)  ==> !! false : false
  49.         System.out.print("!!(3 > 4)  ==> !! false : ");
  50.         System.out.println(!!(a > b));
  51. 	}
  53. }

测试记录:

  1. -----[&&逻辑与 满足全部条件]------
  2. (3 > 4) && (3 > 5) ==> false && false :falsefalse
  3. (3 < 4) && (3 > 5) ==> true && false : false
  4. (3 > 4) && (3 < 5) ==> false && true : false
  5. (3 < 4) && (3 < 5): ==> true && true : true
  6. -----【||逻辑或 满足任一条件】-------
  7. (3 > 4) || (3 > 5) ==> false || false : false
  8. (3 < 4) || (3 > 5) ==> true || false : true
  9. (3 > 4) || (3 < 5) ==> false || true : true
  10. (3 < 4) || (3 < 5) ==> true || true : true
  11. -----【!逻辑非 取反】-------
  12. (3 > 4) : false
  13. !(3 > 4) ==> ! false : true
  14. !!(3 > 4)  ==> !! false : false

1.5 三元运算符

格式:
(关系表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；

代码:

  1. package Java_study;
  3. public class yunsuanfu7 {
  4. 	public static void main(String[] args) {
  5. 		// 定义两个变量
  6. 		int a = 10;
  7. 		int b = 20;
  8. 		
  9. 		// (10>20) => false => 表达式2 => b => 20
  10. 		int c = (a > b) ? a : b;
  11. 		//c:20
  12. 		System.out.println("c:" + c);
  13. 		
  14.         
  15. 		a = 10;
  16. 		b = 10;
  17. 		// ( 10 == 10) => true => 表达式1 => true
  18. 		boolean flag = ( a == b) ? true : false;
  19. 		//flag:true
  20. 		System.out.println("flag:" + flag);
  21. 		
  22. 	}
  24. }

测试记录:

  1. c:20
  2. flag:true

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/113182363

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/u010520724/article/details/119568127

内容来源于网络，如有侵权，请联系作者删除！

下一篇：键盘输入
Javajava运算符

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com