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

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

一.运算符概述

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

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

常用运算符:

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

1.1 算术运算符

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

代码1:

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

测试记录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;
  2. public class yunsuan2 {
  3. public static void main(String[] args) {
  4. //定义两个变量,一个int类型,一个char类型
  5. int a = 10;
  6. char ch = 'a';
  7. // 'a' + 10 = 97 + 10 = 107
  8. System.out.println(a + ch);
  9. System.out.println("----------");
  10. //字符串做加法
  11. //helloworld
  12. System.out.println("hello" + "world" );
  13. //hello10
  14. System.out.println("hello" + 10);
  15. //hello1020
  16. System.out.println("hello" + 10 +20);
  17. //30hello
  18. System.out.println(10 + 20 + "hello");
  19. }
  20. }

测试记录:

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

测试记录:

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

测试记录:

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

1.3 关系运算符(比较运算符)

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

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

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

代码:

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

测试记录:

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

测试记录:

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

测试记录:

  1. c:20
  2. flag:true

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/113182363
下一篇:键盘输入

相关文章