运算符

最新推荐文章于 2024-11-12 10:03:29 发布

原创最新推荐文章于 2024-11-12 10:03:29 发布 · 558 阅读

1 ·

CC 4.0 BY-SA版权

本文介绍了运算符的概念，它是对常量和变量进行运算的符号。详细阐述了算术、赋值、比较、逻辑和三元运算符的分类及用法，如算术运算符的自增自减规则、赋值运算符的扩展公式等，还给出了运算符的练习题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.什么是运算符：

运算符是对常量和变量进行运算的符号。
运算符在表达式中经常使用。

运算符的分类：

1.1 算术运算符

 +		加法运算符 ，字符串连接运算
 -		减法运算
 *		乘法运算
 /		除法运算
 %		取余运算，两个数字相除取余
 ++		自增运算
 --		自减运算

基本的算术运算符： + - * / %

public class OperatorDemo1 {
    public static void main(String[] args) {
        //基本的算术运算符： + - * / %

        int a = 10 ;
        int b = 20 ;
        System.out.println(a + b); //30
        System.out.println(a - b); //-10
        System.out.println(a * b); //200
        System.out.println(a / b); //注意： 0.5 ->转成int -> 会截断小数，直接保留整数=》0
        System.out.println(a % b); // 10

        int a1 = 10;
        int b1 = 3;
        System.out.println(a1 + b1); //13
        System.out.println(a1 - b1); //7
        System.out.println(a1 * b1); //30
        System.out.println(a1 / b1); //除法：3.333333=》转成int ->截断小数，直接保留整数=》3
        System.out.println(a1 * 1.0 / b1); //3.33333333
        System.out.println(a1 % b1); //求余数：结果是1
    }
}

自增自减运算符 ++、 –
1.++ ， – 用在变量的运算上的，可以对变量进行+1 ， -1
2. ++ ， – 在变量单独运算的时候，放在变量的前后是没有区别的都是对变量进行+1 和 -1操作。
3. ++ ， --在表达式中与变量进行运算的时候，放在变量的前后是有差别的。
在表达式中，++ ， --如果放在变量的前面，会先对变量进行+1或者-1然后在拿变量的值进行运算。
在表达式中， ++ ， --如果放在变量的后面，会先拿变量的值进行运算，然后在变量的值进行+ 1 或者-1。

public class OperatorDemo02 {
    public static void main(String[] args) {
        int a = 10;
        a++; //原理： a = a + 1;
        System.out.println(a); // 11

        int b = 10;
        ++b; //原理：b = b + 1;
        System.out.println(b); // 11

        int c = 10 ;
        c--; //原理: c = c - 1 ;
        System.out.println(c); //9

        int d = 10 ;
        --d; //原理：d = d - 1 ;
        System.out.println(d); //9

        System.out.println("------------------------------");
        /*
         ++ ， --在表达式中与变量进行运算的时候，放在变量的前后是有差别的。
在表达式中，++ ， --如果放在变量的前面，会先对变量进行+1或者-1然后在拿变量的值进行运算。
在表达式中， ++ ， --如果放在变量的后面，会先拿变量的值进行运算，然后在变量的值进行+ 1 或者-1。
        */

        int i = 10;
        int rs = i++;
        System.out.println(rs); // 10
        System.out.println(i); // 11

        //在表达式中， ++ --如果放在变量的前面，会对变量进行+1或者-1然后再拿变量的值进行运算。
        int j = 10;
        int rs1 = ++j;
        System.out.println(rs1); // 11
        System.out.println(j); //11

        //面试题：
        int m = 3;
        int n = 2;
        /*
        jvm运算过程：
             m++ + ++n - --n + ++n - --m + 1;
             m  3   4   5   4
             n  2   1   2
             rs2    3 + 5 - 1 + 2 - 4 + 1 = 5
        */
        int rs2 = m++ + ++m - --n + ++n - --m + 1;
        System.out.println(m);
        System.out.println(n);
        System.out.println(rs2);
    }
}

+符号在字符和字符串中的作用
总规则：
+符号与字符串运算的时候是用作连接符的。
+符号与任何字符串连接的结果依然是一个字符串。
整数与字符做运算符的直接拿值运算。不会做连接

public class OperatorDemo03 {
    public static void main(String[] args) {
        /*
        +符号在字符和字符串中的作用。
        总规则：
        +符好与字符串运算的时候是用作连接符的。
        +符号与任何字符串连接的结果依然是一个字符串。
        整数与字符做运算符的直接拿值运算。不会做连接

        */
        int a = 5 ;
        // + 遇到字符串表示连接
        System.out.println("abc" + 'a'); //abca
        System.out.println("abc" + a); //abc5
        System.out.println("abc" + 5 + 'a'); //abc5a
        System.out.println(15 + "abc" + 15); //15abc15
        System.out.println(a + 'a' ); //5 + 97 =102
        System.out.println(a + 'a' + "abc"); //102abc
    }
}

1.2 赋值运算符

= ：赋值
+= ：加后赋值
-= ：减后赋值
*= ：乘后赋值
/= ：除后赋值
%= ：取余后赋值

基本运算符： =
扩展运算符： += -= *= /= %=
注意：扩张运算符自带强制类型转换。
a += b; // 公式： a = (a的数据类型)（a + b）;
a -= b; // 公式： a = (a的数据类型)（a - b）;
a *= b; // 公式： a = (a的数据类型)（a * b）;
a /= b; // 公式： a = (a的数据类型)（a / b）;
a %= b; // 公式： a = (a的数据类型)（a % b）;

public class OperatorDemo04 {
    /*
        基本运算符： =
        扩展运算符： += -= *= /= %=
        注意：扩张运算符自带强制类型转换。
        a += b; // 公式： a = (a的数据类型)（a + b）;
        a -= b; // 公式： a = (a的数据类型)（a - b）;
        a *= b; // 公式： a = (a的数据类型)（a * b）;
        a /= b; // 公式： a = (a的数据类型)（a / b）;
        a %= b; // 公式： a = (a的数据类型)（a % b）;
    */


    public static void main(String[] args) {
        //基本运算符 =
        //从右往左执行的， 把23赋值给int类型的变量age;
        int age = 23;

        //2.扩展的赋值运算符： += -= *= /= %=
        int a = 12 ;
        int b = 12 ;

        a += b; // 原理： a = (a的数据类型)（a + b）;
        System.out.println(a);//24
        
        int i = 4;
        int j = 3 ;
        i *= j; // 原理： a = (a的数据类型)（a * b）;
        System.out.println(i);//12
        
        byte b1 = 12;
        byte b2 = 12;
        
        b1 += b2; //// 原理： a = (byte)（b1 + b2）;
        //注意：扩张运算符自带强制类型转换。
        System.out.println(b1);
    }

}

1.3 比较运算符

比较运算符又叫关系运算符，是两个数据之间进行比较的运算。运算结果是布尔值true 或者 false。
== :比较符号两边数据是否相等，相等结果是true。

< :比较符号左边的数据是否小于右边的数据，如果小于结果是true。

> :`比较符号左边的数据是否大于右边的数据，如果大于结果是true。

<= :比较符号左边的数据是否小于或者等于右边的数据，如果小于或等于结果是true。

>=:比较符号左边的数据是否大于或者等于右边的数据，如果小于或等于结果是true。

!= :`不等于符号，如果符号两边的数据不相等，结果是true。

public class OperatorDemo05 {
    public static void main(String[] args) {
        int a = 10 ;
        int b = 9 ;
        System.out.println(a > b); //true
        System.out.println(a >= b); //true
        System.out.println(a < b); //false
        System.out.println(a <= b); //false
        System.out.println(a == b); //false
        System.out.println(a != b); //true

        int c = 10;
        int d = 10;
        System.out.println(c > d); //false
        System.out.println(c >= d); //true
        System.out.println(c < d); //false
        System.out.println(c <= d); //true
        System.out.println(c == d); //true
        System.out.println(c != d); //false

        int i = 10 ;
        int j = 10 ;
        //判断相等必须是"==" ， 不是"="。
        //以下代码会赋值输出
        System.out.println(i = j);
    }
}

小结：
1.判断是否相等必须是“==”，不是“=”。
2.比较运算符的结果一定是布尔类型的结果：true false。

1.4逻辑运算符

逻辑运算符，是用来对两个布尔类型进行运算的，运算结果也是布尔值true或者是false。
逻辑运算符有哪些：&&短路与，短路或，！非， ^异或， &但与， |单或

1.短路与
必须前后连个布尔结果都是true，最终结果才是true
只要有一个是false 结果就是一定是false。

2.短路或
必须前后连个布尔结果都是false，最终结果才是false
只要有一个是true结果就是一定是true。

3.非
！false结果就是true
！true结果就是false

4.异或
如果前后两个布尔值不同，结果就是true
如果前后两个布尔值相同，结果就是false

5.单与
结果与&&是一样的
必须前后连个布尔结果都是true，最终结果才是true
只要有一个是false 结果就是一定是false。

与&&的区别：
&&：如果发现第一个条件就已经是false了，根本不会执行第二个布尔值。直接返回false。
&：如果发现第一个条件已经是false 了。依然会去判断第二个条件。

6.单或
结果与||是一样的。
必须前后连个布尔结果都是false，最终结果才是false
只要有一个是true结果就是一定是true。

与||的区别：
||：如果发现第一个条件就已经是true了，根本不会执行第二个布尔值。直接返回true。
&：如果发现第一个条件已经是true了。依然会去判断第二个条件。

开发中用：&& ， || ，！最多


public class OperatorDemo06 {
    public static void main(String[] args) {
        //逻辑运算符：需求招年龄超过18岁，工作技术能力达到一年标准的人。
        //需要两个条件都满足。
        int workyear = 1 ;
        int age = 20;
        System.out.println(workyear >= 1 && age >=18);

        //&&
        System.out.println(true && true); //true
        System.out.println(true && false); //false
        System.out.println(false && true); //false
        System.out.println(false && false); //false
        System.out.println("-------------------------");

        //||
        System.out.println(true || true); //true
        System.out.println(true || false); //true
        System.out.println(false || true); //true
        System.out.println(false || false); //false
        System.out.println("-------------------------");

        //&
        System.out.println(true && true); //true
        System.out.println(true && false); //false
        System.out.println(false && true); //false
        System.out.println(false && false); //false
        System.out.println("-------------------------");

        //|
        System.out.println(true || true); //true
        System.out.println(true || false); //true
        System.out.println(false || true); //true
        System.out.println(false || false); //false
        System.out.println("-------------------------");

        //!非
        System.out.println(!(10 > 5)); //false
        System.out.println(!true); //false
        System.out.println(!false); //true
        System.out.println("-------------------------");

        //^
        System.out.println(true ^ true); //false
        System.out.println(true ^ false); //true
        System.out.println(false ^ true); //true
        System.out.println(false ^ false); //false
        System.out.println("-------------------------");
    }
}

5.三元运算符

三元运算符是一个分支表达式。远没有 if语句强大
格式：
条件表达式？值1 ：值 2
执行流程：
先执行条件表达式的结果，如果是true选择值1返回，如果是false，选择值2返回。

public class OperatorDemo07 {

    public static void main(String[] args) {
        int age = 9 ;
        //String是字符串的类型可以用于接收字符串数据
        String rs = age >= 18 ? "您是成年人" : "您是未成年人";

        //求最大值
        int a = 100;
        int b = 99;
        int max = (a > b) ? a : b;
        System.out.println(max);

        //求三个数的最大值
        int i = 10;
        int j = 999;
        int x = 888;

        int max1 = (i > j) ? (i > x ? i : x) :( j > x ? j : x);
        System.out.println(max1);

    }


}

运算符练习题

/**
 运算符练习题
 随便给你一个三位数，计算出它的个位，十位，和百位并输出显示
 */
public class ExecDemo08 {

    public static void main(String[] args) {
        int num = 898;
        //输出个位
        System.out.println("个位：" + num % 10); //8
        //输出十位
        System.out.println("十位：" + num / 10 % 10); // 9
        //输出百位
        System.out.println("百位：" + num / 100 % 10); // 8
    }
}