【Java】运算符

已于 2022-10-25 08:48:48 修改
阅读量1.1w 收藏 29
点赞数 39
分类专栏： Java SE 文章标签： java servlet 前端
于 2022-09-19 10:33:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66488562/article/details/126572999
版权

我不去想是否能够成功

既然选择了远方

便只顾风雨兼程

                                                                                                    —— 汪国真 

目录

1. 认识运算符 

1.1 认识运算符 

1.2 运算符的分类

2. 算术运算符

2.1 四则运算符 

 2.2 复合赋值运算符

2.3 自增 / 自减 运算符 

3.关系运算符 

4.逻辑运算符

4.1 逻辑与 &&

4.2 逻辑或 ||

4.3 逻辑非 ！ 

4.4 短路求值

4.5 记忆口诀

5.位运算符 

5.1 按位与 &

5.2 按位或 |

5.3 按位取反 ~

5.4 按位异或 ^

6.移位运算

6.1 左移  <<

5.2 右移 >>

5.3 无符号右移 >>> 

6.条件运算符

1. 认识运算符 

1.1 认识运算符 

运算符：对操作数进行操作时而用到的符号就叫做运算符（最常见的的操作便是进行数学运算），比如：+ - x  /  都是运算符。

public class Test {
    public static void main(String[] args) {
        int a = 1;// = ：是赋值运算符
        int b = 2;
        int c = 1 + 2;// + ：算术运算符
        System.out.println(c);
    }
}

上述代码中 = 和 + 就是运算符，即：对操作数进行操作时的符号就是运算符，不同运算符操作的含义不同。

1.2 运算符的分类

2. 算术运算符

2.1 四则运算符 

四则运算符：+  -  *  /  %

四则运算符 是 双目运算符

补充知识：

  • 双目运算符：有两个操作数的就叫做双目运算符
  • 单目运算符：有一个操作数的就叫做单目运算符
  1. 四则运算符两边操作数要是整型则结果就是整型
  2. 当左右两边操作数类型不一致是，则类型小会向类型大的提升

 四则运算符两边操作数可以是变量也可以是常量

①  +   -   *   / 

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(1 + 2);
    }
}

a / b：int / int = int，如果我们想要得到小数，有两种方法

方法一：强制类型转换法

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println((double) a / b);
    }
}

首先将 a 强制类型转换为 double 类型，然后除 b，当 b 看到 a 是 double 类型，则会自动提升成double 类型 

方法二：乘小数法 

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println((a * 1.0) / b);
    }
}

首先我们知道 一个数 乘 1 等于这个数本身，a * 1.0 此时相当于 int * double = double ，a * 1.0的结果是 double 类型的，然后在除 b，就相当于 double / int = double

在做除法运算的时候右操作数不能为 0 

②  %

public class Test {
    public static void main(String[] args) {
        System.out.println(7 % 2);
        System.out.println(-7 % 2);
        System.out.println(7.5 % 2);
    }
}

运行结果 ：

取余算法：

注：Java中的取余运算符左右两边操作数可以浮点数，但是C语言中取余运算符左右两边操作数必须是整数 

 在做取余运算的时候右操作数不能为 0 

 2.2 复合赋值运算符

复合赋值运算符：+=   -=    *=     /=      %=    <<=   等等

复合赋值运算符作用：将操纵的结果赋值给左操作数。比如：（a = 1；）  a += 7；  相等于  a = a + 7；

public class Test {
    public static void main(String[] args) {
        int a = 1;
        a += 6;//等价于 a = a + 6 ，a = 7
        System.out.println(a);
        a -= 1;//等价于 a = a - 3 ，a = 6;
        System.out.println(a);
        a /= 2;//等价于 a = a / 2 ，a = 3;
        System.out.println(a);
        a *= 7;//等价于 a = a * 3 ，a = 21;
        System.out.println(a);
        a %= 5;//等价于 a = a % 3 ，a = 1;
        System.out.println(a);
        a += 7 + 1;//等价于 a = a + (7 + 1) ，a = 9;
        System.out.println(a);
    }
}

注：复合赋值运算符左操作数必须是变量，因为常量不允许被修改 

当不同类型使用复合赋值运算符是会自动发生类型转换，不需要我们自己强制转换 

public class Test {
    public static void main(String[] args) {
        int a = 1;
        a += 1.5;//等价于：a = (int)(a + 1.5)
        System.out.println(a);
    }
}

2.3 自增 / 自减 运算符 

自增 / 自减 运算符 ：++   --

自增 / 自减 运算符的作用：对变量的值进行 加一 或 减一

自增可以分为 前置++ 和 后置++

  • 前置++：先加一，后运算
  • 后置++：先运算，后加一 

自减可以分为 前置-- 和 后置--

  • 前置--：先减一，后运算
  • 后置--：先运算，后减一
public class Test {
    public static void main(String[] args) {
        int a = 9;
        System.out.println(++a);//先将a的值加一（a = 10），然后在打印。打印结果为：10
        System.out.println(a++);//先将a的值打印，然后在加一（a = 11）。打印结果为：10
        System.out.println(--a);//先将a的值减一（a = 10），然后在打印。打印结果为：10
        System.out.println(a--);//先将a的值打印，然后在减一（a = 9）。打印结果为：10
    }
}

虽然 ++a ，看似没有给 a 赋值，但是 a 中的值依然会 +1

自增 / 自减 运算符看似没有给变量赋值，但是变量中的值依然发改变 

注：只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改 

3.关系运算符 

关系运算符：>  <   >=   <=    !=   == 

关系运算符的作用：用于判断是否为 true 或者是 false

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a > b);//10 > 20 为假，打印false
        System.out.println(a >= b);//10 >= 20 为假，打印false
        System.out.println(a < b);//10 < 20 为真，打印true
        System.out.println(a <= b);//10 <= 20 为真，打印true
        System.out.println(a != b);//10 != 20 为真，打印true
        System.out.println(a == b);//10 == 20 为假，打印false
        System.out.println(1 > 2);//1 > 2为假，打印false
        System.out.println(1 < 2);//1 < 2为真，打印true
    }
}
  • Java 中 true 表示真，false 表示假
  • >=：表示大于或者等于 两者只用满足一个就为true
  • !=：表示不等于
  • ==：Java中两个等号才表示相等（一个等号表示赋值）
  • 关系运算符两边操作数可以是变量也可以是常量 

4.逻辑运算符

逻辑运算符：&&    ||     ！ 

逻辑运算符的作用 ：用于判断是否为 true 或者是 false

4.1 逻辑与 &&

&&： 双目运算符，左右两边都是表达式，表达式的结果都是 boolean 类型

&&语法规则：表达式1 && 表达式2，表达式1结果为true ， 表达式2 结果为true，整个表达式的结果才为true

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a < b && c > b);//true && true，打印true
        System.out.println(a < b && c < b);//true && false，打印false
        System.out.println(a > b && c > b);//false && true，打印false
        System.out.println(a > b && c < b);//false && false，打印false
    }
}

注：boolean 类型只有两个值，一个是true ，还有一个是 false

4.2 逻辑或 ||

||：双目运算符，左右两边都是表达式，表达式的结果都是 boolean 类型 

|| 语法规则：表达式1 || 表达式2，表达式1结果 或者 表达式2结果 至少有一个为为true，整个表达式的结果才为true 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a < b || c > b);//true || true，打印true
        System.out.println(a < b || c < b);//true || false，打印true
        System.out.println(a > b || c > b);//false || true，打印true
        System.out.println(a > b || c < b);//false || false，打印false
    }
}

4.3 逻辑非 ！ 

！：单目运算符，只有一个操作数。表达式的结果都是 boolean 类型 

！语法规则：!（表达式），表达式的结果为为 true，则整个表达式的结果就为 false；表达式的结果为 false，则整个表达式的结果就为false

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(!(a > b));//10 > 20,结果为false，然后经过逻辑非结果就是true
        System.out.println(!(a < b));//10 > 20,结果为true，然后经过逻辑非结果就是false
    }
}

4.4 短路求值

对于 && 和 || ，都是遵循短路求值规则

① && 的短路求值 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println((a > b) && ((++a) > b));
        System.out.println(a);
    }
}

上述代码运行结果： 

代码解析： 

&& 两边操作数都为真，结果为真；要是有一个结果为假，则结果为假。 当执行 表达式1 时发现为假，则整个表达式的结果为假。如果为真，则继续判断下一个 表达式2 的结果 ，表达式2 的结果为真，则整个表达式的结果为真，如果 表达式2 的结果为假，则整个表达式的结果为假

a > b ---->  10 > 20 ,表达式为假，则不会执行（++a）> b。所以整个表达式的结果为假，并且 a 的值不变

② || 的短路求值 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println((a < b) || ((++a) < b));
        System.out.println(a);
    }
}

上述代码运行结果：

代码解析： 

|| 两边操作数的结果至少有一个为真，则整个表达式为真；都为假，则整个表达式为假 。当执行表达式1 的时候如果结果为真，则不会去执行 表达式2 ，整个表达式的结果就为真。当执行 表达式1 的时候，如果结果为假，则去执行 表达式2 ，表达式2 的结果为真，则整个表达式的结果就为真，要是 表达式2 的结果为假，则整个表达式的结果为假

4.5 记忆口诀

&&：全真得真

||：见真得真

!  : 非真即为假，非假即为真

5.位运算符 

位运算符，见名知意 就可以知道是处理二进制位的运算符。

补充知识： 

Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位

1 字节 = 8 比特位

位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(二进制：01构成的序列), 按位运算就是在按照 二进制位 的每一位依次进行运算。

位运算符：&        |        ~        ^ 

  • &：按位与
  • | ：按位或 
  • ~：按位取反
  • ^：按位异或

注：位运算符操作数可以是变量也可以是常量 

5.1 按位与 &

&：全一得一，两个比特位都是 1 ，则为 1 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a & b);
        System.out.println(7 & 6);
    }
}

上述代码运行结果：

代码分析： 

a = 10，b = 20，然后 a & b。 首先将 a 和 b 都转换成二进制的形式，因为 a，b 是 int 类型所以转换为 32 位二进制位：

a：00000000 00000000 00000000 00001010

b：00000000 00000000 00000000 00010100

然后进行按位与，全一得一，则结果为：

00000000 00000000 00000000 00000000，结果就为 0

7 & 6, 7 和 6 默认都是 int 类型的，首先将 7 和 6 都转换为 32 位二进制位：

7：00000000 00000000 00000000 00000111

6：00000000 00000000 00000000 00000110 

然后进行按位与，全一得一，则结果为：

00000000 00000000 00000000 00000110 ，就为 6

5.2 按位或 |

| ：见一得一，两个比特位只要有一个是 1 ，则为 1 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a | b);
        System.out.println(7 | 6);
    }
}

上述代码运行结果： 

代码解析： 

a = 10，b = 20，然后 a | b。 首先将 a 和 b 都转换成二进制的形式，因为 a，b 是 int 类型所以转换为 32 位二进制位：

a：00000000 00000000 00000000 00001010

b：00000000 00000000 00000000 00010100

然后进行按位与，见一得一，则结果为：

00000000 00000000 00000000 00011110，结果就为 30

7 & 6, 7 和 6 默认都是 int 类型的，首先将 7 和 6 都转换为 32 位二进制位：

7：00000000 00000000 00000000 00000111

6：00000000 00000000 00000000 00000110 

然后进行按位与，见一得一，则结果为：

00000000 00000000 00000000 00000111 ，就为 7

5.3 按位取反 ~

~ ： 1 变 0 , 0 变1

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(~a);
    }
}

上述代码运行结果：

 代码解析：

a = 10，然后 ~a 。 首先将 a  转换成二进制的形式，因为 a 是 int 类型所以转换为 32 位二进制位： 

a：00000000 00000000 00000000 00001010

然后按位取反得，1 变 0 , 0 变 1，得：

11111111 11111111 11111111 11110101

计算机只会存储二进制补码的形式，所以计算机会认为这是补码，在用户进行读取的时候计算机会自动将补码转换成原码，然后进行读取出来

补码转原码有两种方法

方法一：补码除了符号位，其他位按位取反，然后加1，的原码

方法二：补码减一得反码，反码符号位不变其他位按位取反得原码 

则 ~a 的结果就是 -11 

补充知识：

正数的原 反 补相同

负数的反码等于原码符号位不变，然后按位取反；负数的补码就是负数的反码加1 

5.4 按位异或 ^

^ ：相同为 0，不同为 1 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a ^ b);
    }
}

上述代码运行结果 ：

代码解析：

 a = 10，b = 20，然后 a ^ b。 首先将 a 和 b 都转换成二进制的形式，因为 a，b 是 int 类型所以转换为 32 位二进制位：

a：00000000 00000000 00000000 00001010

b：00000000 00000000 00000000 00010100

然后进行按位异或，相同为 0，不同为 1 则结果为：

00000000 00000000 00000000 00011110，结果就为 30

6.移位运算

移位运算符，见名知意 肯定又是对二进制位的运算

移位运算符：<<         >>         >>>

  • <<：左移
  • >>：右移
  • >>>：无符号右移 

6.1 左移  <<

<< ：最左侧位不要了, 最右侧补 0 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a << 1);
    }
}

上述代码运行结果： 

代码解析： 

a = 10，然后 a << 1 。 首先将 a  转换成二进制的形式，因为 a 是 int 类型所以转换为 32 位二进制位： 

a：00000000 00000000 00000000 00001010

然后最左侧位不要了, 最右侧补 0 

00000000 00000000 00000000 00010100

将二进制位转换为十进制就是 20 

注：

  • 向左移位时，丢弃的是符号位，因此正数左移可能会变成负数 
  • 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.

5.2 右移 >>

 >>：最右侧位不要了, 最左侧补符号位（正数补0, 负数补1）

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a >> 1);
    }
}

上述代码运行结果： 

代码解析： 

a = 10，然后 a >> 1 。 首先将  a  转换成二进制的形式，因为 a 是 int 类型所以转换为 32 位二进制位： 

a：00000000 00000000 00000000 00001010

然后最右边侧位不要了, 左边正数补0, 负数补1

00000000 00000000 00000000 00001010

将二进制位转换为十进制就是 20 

注：右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方. 

5.3 无符号右移 >>> 

>>>：最右侧位不要了, 最左侧补 0 

public class Test {
    public static void main(String[] args) {
        int a = -10;
        System.out.println(a >>> 1);
    }
}

上述代码运行结果：  

代码解析： 

a = -10，然后 a >>> 1 。 首先将  a  转换成二进制的形式，因为 a 是 int 类型所以转换为 32 位二进制位： 

a：10000000 00000000 00000000 00001010

如果是负数，则需要转为补码然后存储在计算机内进行运算 

原码：10000000 00000000 00000000 00001010 

反码：11111111 11111111 11111111 11110101 

补码：11111111 11111111 11111111 11110110

然后无符号左移： 01111111 11111111 11111111 11111011

结果就为：2147483643

6.条件运算符

条件运算符只要一个：？： 

条件运算符的格式：表达式1 ? 表达式2 : 表达式3

表达式1 的结果必须是 boolean 类型 

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值; 当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.

条件运算符也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法. 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = (a > b) ? a : b;
        System.out.println(c);
    }
}

 上述代码运行结果：

 代码解析：

如果 a > b 为 true ,则把 a 的值赋值给 c，如果 a > b 为 false ，则把 b 的值赋值给 c 

拼命阿紫
关注
  • 39
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 59
    评论
专栏目录
Java运算符
09-20
运算符优先级 ，类型 ，转义字符 ，Math函数 ，数据类型转换
Java中的逻辑、关系、算术、赋值以及位运算符
weixin_52626164的博客
12-27 985
Java中的运算符
彻底理解双目操作符’&’,’|’,’^’
csq_love_hy的博客
01-30 440
为了让小白们更加轻松融入C语言的学习当中，我也是熬夜加班将这三个令我抓狂的双目操作符总结出来。相信大部分人对于取地址符’&’并不陌生，用来获取变量a的内存地址。为了便于在后续代码中使用变量的地址来进行间接访问。’&&’是逻辑运算符，表示逻辑与；相当于生活中说的“并且”，就是两个条件都成立的情况下“逻辑与”的运算结果才为“真”。重点来了，看到这个是不是很懵逼，
java双目运算符重载_运算符重载
weixin_29174141的博客
02-27 447
什么是运算符的重载?运算符与类结合，产生新的含义。为什么要引入运算符重载？作用：为了实现类的多态性(多态是指一个函数名有多种含义)怎么实现运算符的重载？方式：类的成员函数 或 友元函数(类外的普通函数)规则：不能重载的运算符有 . 和 .* 和 ?: 和 :: 和 sizeof友元函数和成员函数的使用场合：一般情况下，建议一元运算符使用成员函数，二元运算符使用友元函数1、运算符的操作需要修改类...
c语言双目运算和单目运算符,单目运算符 双目运算符 三目运算符
热门推荐
weixin_30336531的博客
05-22 1万+
1。单目就是这个运算符只对一个变量进行操作代表符号：!(逻辑非) ~(按位取反)++(自增)--(自减)举例：int a=1;a++;(第二句“a++”则只对a一个变量进行了操作)2。双目就是这个运算符对两个变量进行操作举例：int a=1,b=2,c;c=a+b;(第二句“c=a+b”则是对a,b两个变量进行了操作)3。三目就是这个运算符对三个变量进行操作代表符号： ?:(条件运算符)关于三目运...
详解 Java中的运算符
晴天的博客
12-30 432
快速详解Java中的运算符
c++双目运算符详解
Yoyo的博客
08-14 1665
本文将深入探讨C++中的双目运算符，详细介绍双目运算符的种类、使用方法以及常见的应用场景，并附带代码示例，帮助读者更好地理解和应用双目运算符。本文详细介绍了常见的双目运算符的种类、使用方法以及应用场景，并提供了相关的代码示例。希望读者通过学习双目运算符的使用，能够更好地应用于实际编程中，提高程序的效率和质量。C++中的双目运算符有多种类型，包括算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符等。双目运算符可以应用于各种不同的场景，下面我们介绍一些常见的应用示例。
【Java基础】Java的运算符
wang_qiu_hao的博客
06-22 3774
算术运算符都是双目运算符，即连接两个操作数的运算符。优先级上，*、/、％ 具有相同运算级别，并高于 +、-（+、- 具有相同级别）加减乘除，很简单就不用说了，大家都懂,就这个取余要求必须是两个整型数字才行++ 或 - - 是单目运算符，放在操作数的前面或后面都是允许的。++运算，变量自增长1；- -运算，变量自减少1。那么如果有一个变量i，++i和i++有什么区别呢？独立运算时：i++和++i没有区别，都是实现自动加1的功能混合运算时：i++和++i就不同了1.++/- -在先，先运算后取值 2.++/-
java运算符
m0_51779342的博客
01-14 495
java运算符 运算符就是用来指明对操作数采取怎样的运算方式的一种符号 java按操作数可分为：单目运算符、双目运算符、三目运算符，有几个操作数参与运算就是几目运算符 Java运算符按功能可分为：算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符和条件运算符等。 按操作数划分 类型 符号 单目运算符 ~（按位取反）、! (取非)、-（负号运算符）、 ++（自增）、 - -（自减） 双目运算符 + 、- 、*、 / 、%（取余） 三目运算符 ? : 按功能划分 算术运
java二目运算符_Java的运算符
weixin_39533795的博客
02-12 1324
运算符分类运算符指明对操作数的运算方式.组成表达式的java操作符有很多种..运算符按照其要求的操作数数目来分,可以有单目运算符、双目运算符和三目运算符，他们分别对应1个、2个、3个操作数。运算符按其功能来分，有算术运算符、赋值运算符，关系运算符，逻辑运算符，位运算符和其他运算符操作数数目来分单目运算符~(按位取反)、！(取非)、-(负号运算符)、++(自增)、--(自减)列如1 ~5 //按位取...
Java基础语法(上)-变量和运算符
weixin_44894173的博客
01-06 218
Java基础语法（上）-变量和运算符标识符数据类型 标识符 凡是自己可以起名的地方都叫标识符。 比如：类名，变量名，方法名，接口名，包名… 标识符的命名规则 由26个英文字母大小写，0-9，_，或$组成 数字不可以开头 不可以使用关键字和保留字，但能包含关键字和保留字 Java中严格区分大小写，长度无限制 标识符不能包含空格 Java中的名称命名规范： 包名：多单词组成时所有字母都小写：xxxyyyzzz 类名，接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz 变量名，方法名：多单词组成
28.java运算符.zip
06-15
28.java运算符.zip28.java运算符.zip28.java运算符.zip28.java运算符.zip28.java运算符.zip28.java运算符.zip28.java运算符.zip28.java运算符.zip28.java运算符.zip28.java运算符.zip28.java运算符.zip28.java运算符...
Java运算符优先级
08-11
在实际的开发中，不需要去记忆运算符的优先级别，也不要刻意的使用运算符的优先级别，对于不清楚优先级的地方使用小括号去进行替代
04-JAVA运算符思维导图
05-27
JAVA运算符思维导图，便捷整理思路，算数运算符、连接运算符、赋值运算符、扩展赋值运算符、三目运算符、逻辑运算符、关系运算符
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 644
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
ReentrantLock
最新发布
Adepth的博客
04-22 608
这是标准库给我们提供的另一种锁，前面我们学到的一种是顾名思义，Reentrant:可重入的 但我们也知道，synchronized锁不也是可重入的嘛?那这个锁到底有什么其他的过人之处呢？
Web前端 Javascript笔记5
cycyzh的博客
04-18 840
script>'console.log("哈哈哈佳人们好困")'}, 3000)​let t1 = setTimeout('console.log("你们看到这句话的时候我早已身价百万！！")', 4000)​</script>3秒，四秒后出来的东西，出现前会返回计时器编号。
2.8 构建gradle环境
蚊者逆袭的博客
04-18 2156
Gradle是一种现代化的构建工具，用于自动化地构建、测试和部署软件项目。它是一种基于JVM（Java虚拟机）的构建工具，最初是为了解决Apache Ant和Apache Maven等传统构建工具的一些限制而开发的。
java 运算符的优先级
09-18
Java运算符的优先级如下： 1. 一元运算符: ++, --, +, -, !, ~ 2. 乘法/除法/取余运算符: *, /, % 3. 加法/减法运算符: +, - 4. 移位运算符: <<, >>, >>> 5. 关系运算符: <, <=, >, >=, instanceof 6. 相等运算符: ==, != 7. 位与运算符: & 8. 位异或运算符: ^ 9. 位或运算符: | 10. 逻辑与运算符: && 11. 逻辑或运算符: || 12. 条件运算符: ? : 13. 赋值运算符: =, +=, -=, *=, /=, %=, <<=, >>=, >>>=, &=, ^=, |= 14. lambda运算符: -> 请注意，优先级从高到低排列，同一级别运算符按照从左到右的顺序进行计算。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 59
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拼命阿紫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值