算术运算符

  • +、-、*、/；基本四则运算加减乘除
  • %；取余
  • —；自减

  • ++；自增

    1. int b=1;
    2. System.out.println(b++);//先使用再自增、自减
    3. System.out.println(b);
    4. int c=1;
    5. System.out.println(++c);//先自增、自减再使用
    6. //只有自增与自减运算符才会改变变量自身的值，普通的四则运算只能改变算式本身的值
    7. System.out.println(--c-c-c--);//-1-(-1)-(-1)=-1+1+1=1
    8. System.out.println(c);//-2

    关系运算符

  • <、>、>=、<=

  • ==

  • !=

    逻辑运算符

  • &

  • &&
  • |
  • ||
  • !

  • +

    三目运算符

  • 1？2：3

    1. public class TestMaxNum {
    2.   public static void main(String[] args) {
    3.       System.out.print("请输入要比较的第一个数：");
    4.       int a = new Scanner(System.in).nextInt();
    5.       System.out.print("请输入要比较的第二个数：");
    6.       int b = new Scanner(System.in).nextInt();
    8.       //如果1号的结果是true,取2号位置的值,反之,取3号位置的值
    9.       int max = a > b ? a : b;
    10.       System.out.println("两个数的最大值是：" + max);
    11.   }

    赋值运算符

  • +=、-=

  • *=、/=

image.png

案例

自增自减测试

  1. package cn.tedu.basic;
  2. /**本类用于测试取余运算符*/
  3. public class TestOperator {
  4.     //0.创建程序的入口函数main Alt+/补全代码
  5.     public static void main(String[] args) {
  6.         /**基本的四则运算符+ - * / */
  7.         //1.测试除法与取余数
  8.         System.out.println(25/10);//int/int->int,商是2
  9.         System.out.println(25%10);//取余，余数为5
  10.         //练习：获取一个两位数的十位与个位
  11.         int x = 59;
  12.         System.out.println(59/10);//获取十位，包含几个10
  13.         System.out.println(59%10);//获取个位，除十位之外还剩多少
  14.         //练习：获取一个三位数的百位 十位 与个位
  15.         int y = 152;
  16.         System.out.println(y / 100);//获取百位，包含几个100
  17.         System.out.println(y / 10 % 10);//获取十位，15个十，取余取5
  18.         System.out.println(y % 10);//获取个位，除了15个10以外的余数2
  20.         //2.测试自增自减运算符
  21.         /**前缀式：++a --a，先改变变量的值，再使用
  22.          *    后缀式： a++ a--，先使用，再改变变量的值
  23.          * ++:表示给当前变量的值+1
  24.          * --：表示给当前变量的值-1*/
  25.         System.out.println("我是一个无情的分界线");
  26.         int a = 1;
  27.         System.out.println(a++);//1,符号在后，先使用，再自增
  28.         System.out.println(a);//2，使用过后自增成2
  30.         int b = 1;
  31.         System.out.println(++b);//2,符号在前，先自增，再使用
  33.         int c = 1;
  34.         System.out.println(--c);//0，符号在前，先自减，再打印
  36.         int d = 1;
  37.         System.out.println(d--);//1,符号在后，先打印，再自减
  38.         System.out.println(d);//0,刚刚使用过后就自减
  40.         /**之前的代码会对后面的代码产生影响*/
  41.         System.out.println(c);//c的初始值是0
  42.         /**只有自增自减运算符才会改变变量本身的值
  43.          * 普通的四则运算只能改变算式本身的值*/
  44.         System.out.println(--c-c-c--);//-1-(-1)-(-1)=1
  45.         //System.out.println(c);//-2    
  46.     }
  47. }

求最大值案例

  1. package cn.tedu.basic;
  3. import java.util.Scanner;
  5. /*
  6.  * 计算两个数的最大值
  7.  */
  9. public class TestMaxNum {
  10.     public static void main(String[] args) {
  11.         System.out.print("请输入要比较的第一个数：");
  12.         int a = new Scanner(System.in).nextInt();
  13.         System.out.print("请输入要比较的第二个数：");
  14.         int b = new Scanner(System.in).nextInt();
  16.         //如果1号的结果是true,取2号位置的值,反之,取3号位置的值
  17.         int max = a > b ? a : b;
  18.         System.out.println("两个数的最大值是：" + max);
  20.         //通过三元运算符求出三个数的最大值
  21.         System.out.print("请输入要比较的第三个数：");
  22.         int c = new Scanner(System.in).nextInt();
  23.         int max1 = (a > b ? a : b) >c ? (a > b ? a : b) : c;
  24.         System.out.println("三个数的最大值是：" + max1);
  25.     }
  27. }

求平年闰年

  1. package cn.tedu.basic;
  3. import java.util.Scanner;
  5. /*
  6.  * 计算是平年或闰年
  7.  */
  9. public class TestYear {
  10.     public static void main(String[] args) {
  11.         System.out.print("输入需要判断的年份:");
  12.         int year = new Scanner(System.in).nextInt();
  14.         /**
  15.          * 顺序结构会执行main中的所有代码
  16.          * 若需要先判断在选择性的执行语句，需要使用分支结构
  17.          * 分支结构中的if语句写法
  18.          * if(判断条件){
  19.          * 符合条件后执行的代码，不符合条件的将会跳过
  20.          * }
  21.          */
  23.         String result = "平年";
  25. //        if(year % 4==0) {
  26. //            if(year % 100 != 0) {
  27. //                result = "闰年";
  28. //            }
  29. //        }
  30. //        
  31. //        if(year % 400 == 0) {
  32. //            result = "闰年";
  33. //        }
  34. //        System.out.println(year + "年为" + result);
  36.         if((year % 4==0 && year % 100!=0) || year % 400==0) {
  37.             result = "闰年";
  38.         }
  39.         System.out.println(year + "年为" + result);
  41.     }
  43. }