java运算符

运算符：

四则运算和取模运算

运算符：进行特定操作的符号，例如 +
表达式：用运算符连起来的式子叫做表达式。例如20 + 5 ,a+b 等

四则运算：就是我们小学学的加减乘除
加： +
减： -
乘： *
除： /

还有新的运算符：
取模（取余数）：%
只有对于整数的除法来说，取模运算符才有余数的意义。

加减乘都是基操，特别注意除法。
小学的除法公式：被除数/除数 = 商 … 余数
除法要进行分类讨论（两种）：
情况一：
被除数和除数全是整数的除法：除法用的是整除，整数除以整数，只看商，不看余数。
情况二：
除法表达式中有任意一个数是小数参与，则结果是小数，例如10.0/4=2.5

注意2：做运算的时候（类型不统一，先捋顺成统一的），先将变量或者常量提升为表达式中数据范围最大的那个类型；byte/short/char会自动转为int,再做其他操作。

提升规则：

byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。

整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型

​ 等级顺序：byte,short,char --> int --> long --> float --> double

代码演示：

package com.fan.pojo;
/*
运算符：进行特定操作的符号，例如 +
表达式：用运算符连起来的式子叫做表达式。例如20 + 5 ,a+b 等
四则运算：就是我们小学学的加减乘除
加： +
减： -
乘： *
除： /
*/
public class DemoVariable {
    public static void main(String[] args) {
        //1.两个常量之间可以进行数学运算
        System.out.println(20 + 30);

        //2.两个变量之间也可以进行数学运算
        int a = 20;
        int b = 30;
        System.out.println(a - b);//-10

        //3.变量和常量之间可以进行混合使用
        System.out.println(a * 10);//200

        //除法的代码演示
        int x = 10;
        int y = 3;

        int res1 = x / y;
        System.out.println(res1);//3,商3，余1，这里取商

        //取模的演示
        int res2 = x % y;
        System.out.println(res2);//取余数/取模 1

        //做运算的时候（类型不统一，先捋顺成统一的），先将变量或者常量提升为表达式中数据范围最大的那个类型；
        //int + double -->double + double-->double,自动类型转换
        double res3 = x + 2.5;
        System.out.println(res3);//12.5

        //小数除法
        System.out.println(10.0/4);
    }
}

四则运算中的加号 + 常见的三种用法：

1.对于数值来说，那就是加法
2.对于字符char类型来说，在计算之前，char会先被提升为int类型，然后在运算.（byte/short/char–>int）char类型字符，和int类型的对照表，我们参照ASCII和Unicode表。
3.当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。任何数据类型和字符串连接的时候，结果都会变成字符串（注意运算从左到右）。
总结
在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行

自增自减运算符

基本含义：让一个变量涨一个数值1,或者让一个变量降一个数字1.

使用格式：写在变量名称之前，或者写在变量名称之后，例如：++num,或者num++

使用方式：（两种情况）
1.单独使用：不和其他任何操作符混用，自己独立称为一个步骤，一般单独成为一行。
2.混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合等

使用区别：
1.在单独使用的时候，前++和后++没有任何区别，也就是：++num;和num++;是完全一样的。
2.在混合使用的时候，有【重大区别】：
A。如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。【先加后用，类似于先给钱，后干活】
B.如果是【后++】，那么首先使用变量的数值，【然后再让变量+1】。【先用后加，类似于先干活，后给钱】

注意事项：
只有变量才能使用自增，自减运算符，常量不可以发生改变，所以不能用。

代码简单演示：

int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11

int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11

int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10

int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11

赋值运算符

赋值运算符分类：（两种）
基本的赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。
int a = 30;

符合赋值运算符：
+= : a+= 3 相当于 a = a + 3;
-=: b -= 4 相当于 b = b - 4;
*=: c *= 5 相当于 c = c * 5;
/=: d /= 6 相当于 d = d / 6；
%=： e %= 7 相当于 e = e % 7;

注意：

1.复合赋值运算符隐含了强制类型转换。
2.赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的变量，不能是常量。

部分代码演示：

package com.fan.pojo;
public class DemoVariable {
    public static void main(String[] args) {
        //1.复合赋值运算符隐含了强制类型转换。
        byte num = 30;
        /*
        num = num + 5;
        num = byte + int;
        num = int + int;
        num = int
        num = (byte) int//编译器帮我们隐含的加了强制类型转换。
        * */
        num += 5;
        System.out.println(num);//35
    }
}

比较运算符/关系运算符

代码演示：

注意事项：

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

​ 千万不要把“”误写成“=”，"“是判断是否相等的关系，”="是赋值。
代码演示：

int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a >= b); // false
System.out.println(a < b); // true
System.out.println(a <= b); // true

// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag); // 输出false

逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。

//定义变量
int i = 10;
int j = 20;
int k = 30;

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
System.out.println("--------");

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
System.out.println("--------");

//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true

短路逻辑运算符

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

逻辑与&，无论左边真假，右边都要执行。

短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。

逻辑或|，无论左边真假，右边都要执行。

短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
System.out.println(x); // 4
System.out.println(y); // 5

System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算
System.out.println(x); // 4
System.out.println(y); // 4

三元运算符

一元运算符： 只需要一个数据就可以进行操作的运算符。例如：取反！，自增++，自增–
二元运算符：需要两个数据才可以进行操作的运算符，例如：加法+，赋值=
三元运算符：需要三个数据才可以进行操作的运算符。

格式：数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B ;

流程：
首先判断条件是否成立：
如果成立为true,那么将表达式A的值赋值给左侧的变量；
如果不成立为false,那么将表达式B的值赋值给左侧的变量；
二者选其一；

代码演示：

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值