java中的运算符

算数运算符

符号	说明
+	加法
-	减法
*	乘法
/	除法 如果符号前后都是整数,结果取整数部分 如果符号前后有一个为小数,结果就是正常小数
%	模,取余数部分

package Main.java;

public class HelloWorld {
    public static void main(String[] args) {
        int i = 10;
        int j = 3;
        int add = i+j;//推荐使用
        System.out.println(add);//13
        System.out.println(i+j);//13

        int sub = i-j;
        System.out.println(sub);//7

        int mul = i*j;
        System.out.println(mul);//30

        int div = i/j;
        System.out.println(div);//3

        int mo = i%j;
        System.out.println(mo);//1
    }
}

+ 加号

1. 运算
2. 字符串拼接:任何类型的数据遇到字符串都会变成字符串,此时+就不再是运算了,而是字符串拼接,将内容直接往后拼接
   示例代码如下

package Main.java;

public class HelloWorld {
    public static void main(String[] args) {
        int i = 10;
        int j = 3;
        System.out.println(i+j+"");//13
        System.out.println(i+j+""+1);//131
        System.out.println(i+""+j);//103

        System.out.println("i和j相加只和为:"+(i+j));
    }
}

输出如下

自增自减运算符(也算算数运算符的一种)

1. 格式:
   变量++ -> 后自加
   ++变量 -> 前自加
   变量-- -> 后自减
   –变量 -> 前自减

自增和自减只变化1

2. 使用:
   a.单独使用: ++ – 单独为一句,没有和其他的语句掺和使用
   i++;

   符号前在在后都是先运算
   b.混合使用: ++ – 和其他的语句掺和使用了(比如:输出语句,赋值语句)
   符号在前:先运算,在使用运算后的值
   符号在后:先使用原值,使用完毕之后,自身再运算

public class HelloWorld {
    public static void main(String[] args) {
        int i = 10;
        ++i;
        System.out.println("i = " + i);
        System.out.println("==================");
        int j = 100;
        int result01 = ++j;
        System.out.println("result01 = " + result01);//101
        System.out.println(j);//101
        System.out.println("==================");
        int k = 10;
        int result02 = k++;
        System.out.println("result02 = " + result02);
        System.out.println(k);
        System.out.println("==================");
        int z = 100;
        System.out.println(z++);
        System.out.println(z);
        System.out.println("==================");
        int x = 10;
        int y = 20;
        /*
           10+19 = 29
           29+12 = 41

           以后开发肯定不会这么写
         */
        int result03 = x++ + --y + ++x;
        System.out.println("result03 = " + result03);
        System.out.println("=======================");
        int c = 10;
        c = c++;
        System.out.println(c);//10
        System.out.println(c);//10
    }
}

输出如下

赋值运算符

1. 基本赋值运算符:
   = -> 先看等号右边的,再将右边的数据赋值给等号左边的变量

2. 复合赋值运算符:
   +=:
   int i = 10;
   i+=2 -> i = i+2

-=
*=
/= : 取整数部分
%= : 取余数部分

3. 注意:byte short 遇到复合赋值运算符,jvm会自动转型

public class HelloWorld {
    public static void main(String[] args) {
        int i = 10;
        i+=2;//i = i+2
        System.out.println(i);
        byte b = 10;
        //b = (byte)(b + 1);
        b+=1;//b = b+1
        System.out.println(b);
    }
}

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

1. 结果:boolean型 -> 要么是true,要么是false
2. 作用:做条件判断使用

符号	说明
==	如果符号前后相等为true;否则为false
>	如果符号前的数据大于符号后的数据为true,否则为false
<	如果符号前的数据小于符号后的数据为true,否则为false
>=	如果符号前的数据大于或者等于符号后的数据为true,否则为false
<=	如果符号前的数据小于或者等于符号后的数据为true,否则为false
!=	如果符号前后不相等为true;否则为false

public class HelloWorld {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        boolean result01 = i == j;
        System.out.println("result01 = " + result01);//false
        System.out.println(i>j);//false
        System.out.println(i<j);//true
        System.out.println(i>=j);//false
        System.out.println(i<=j);//true
        System.out.println(i!=j);//true
    }
}

输出如下

逻辑运算符

1. 作用:连接多个boolean结果的
2. 结果:boolean型结果

符号	说明
&&(与,并且)	有假则假,符号前后有一个结果为false,整体就是false
||(或者)	有真则真,符号前后有一个结果为true,整体就是true
!(非,取反)	不是true,就是false;不是false,就是true
^(异或)	符号前后结果一样为false;不一样为true true^true -> false true^false -> true false^true -> true false^false -> false

public class HelloWorld {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        int k = 10;
        boolean result01 = (i>j) && (i==k);
        System.out.println("result01 = " + result01);//false
        boolean result02 = (i>j) || (i==k);
        System.out.println("result02 = " + result02);//true
        boolean result03 = (i>j) ^ (i==k);//false ^ true
        System.out.println("result03 = " + result03);//true
        boolean result04 = !(i>j) ;
        System.out.println("result04 = " + result04);//true
    }
}

输出如下

符号	说明
&	1.单与,如果前后都是布尔型,有假则假,但是如果符号前为false,符号后的判断会继续执行 2.如果该符号前后都是数字,看做是位运算符
&&	1.双与,有假则假,但是有短路效果,如果符号前为false,符号后的判断就不会执行了
|	1.单或,如果前后都是布尔型,有真则真,但是如果符号前为true,符号后的判断会继续执行 2.如果该符号前后都是数字,看做是位运算符
||	1.双或,有真则真,但是有短路效果,如果符号前为true,符号后的判断就不会执行了

public class HelloWorld {
    public static void main(String[] args) {
        // 位运算符
        int a = 5; // 二进制: 0101
        int b = 3; // 二进制: 0011
        int c = a & b; // 结果: 0001, 十进制为 1
        int d = a | b; // 结果: 0111, 十进制为 7
        System.out.println("a & b = " + c); // 输出: a & b = 1
        System.out.println("a | b = " + d); // 输出: a | b = 7
        // 逻辑运算符
        boolean p = true;
        boolean q = false;
        boolean r = p && q; // 结果: false
        boolean s = p || q; // 结果: true
        System.out.println("p && q = " + r); // 输出: p && q = false
        System.out.println("p || q = " + s); // 输出: p || q = true
        // 短路效果
        boolean x = false;
        boolean y = true;
        boolean z = false;
        boolean w = false;
        boolean result1 = x && z; // z 不会被评估
        boolean result2 = y || w; // w 不会被评估
        System.out.println("x && z = " + result1); // 输出: x && z = false
        System.out.println("y || w = " + result2); // 输出: y || w = true
    }
}

输出如下

三元运算符

1. 格式:
   boolean表达式?表达式1:表达式2

2. 执行流程:
   先判断,如果是true,就走?后面的表达式1,否则就走:后面的表达式2

public class HelloWorld {
    public static void main(String[] args) {
        //定义一个变量,表示小明的分数
        int score = 60;
        String result = score>=60?"及格":"不及格";
        System.out.println("result = " + result);
    }
}

输出 及格