JAVA先递增后递减_Java操作符

关于操作符

前言

优先级

赋值

算数操作符

自动递增和递减

关系操作符

逻辑运算符

按位操作符

补充

移位操作符

三元操作符

字符串操作符 + 和 +=

类型转换操作符

补充

直接常量

欢迎关注公众号：一盐难进

前言

操作符作用于操作数，生成一个新值。几乎所有的操作符都只能操作 “基本类型”。但是 “=”, “==”, “!=”, 这些操作符能操作所有的对象。

优先级

当代码中一个表达式有多个操作符时，操作符的优先级决定了各部分的计算顺序。最简单的规则就是先乘除后加减。基本顺序归纳如下：

名称

符号

分隔符

. [] () , ;

单目运算符

+ - ~ ! ++ –

创建或类型转换

.new

乘除法

* / %

加减法

+ -

关系

< <= > >= instanceof

等价

== !=

位与

&

异或

^

条件与

&&

条件或

||

条件

?

赋值

=

赋值

赋值使用操作符 “ = “。 意思就是取右边的值，将它复制给左边。右值可以是任何常数、变量、或者表达式(只要能生成一个值就可以)。但是左值必须是一个明确的已命名的变量。

//将常数赋给变量

int a = 4;

在对对象进行赋值操作时，我们真正操作的是对象的对象的引用。所以如果将一个对象赋值给另一个对象，实际上是将引用从一个地方赋值到另一个地方。

Tank tank1 = new Tank();

Tank tank2 = new Tank();

tank1.level = 12;

tank2.level = 13;

System.out.println(“tank1:” + tank1.level + “, tank2:” + tank2.level);

//对一个对象进行赋值操作

tank1 = tank2;

System.out.println(“tank1:” + tank1.level + “, tank2:” + tank2.level);

//由于 tank1 和 tank2 是同一个对象的引用，所以会同时修改 tank2

tank1.level = 20;

System.out.println(“tank1:” + tank1.level + “, tank2:” + tank2.level);

以上现象就是 “别名现象”，是 Java 操作对象的一种基本方式。

算数操作符

Java 的基本算数操作符与其他大多数程序语言是相同的。包括加号(+)、减号(-)、除号(/，除法会直接去掉结果的小数位)、乘号(*)和取模操作符(%，用于从出发中取余)。

//定义三个变量

int a, b, c;

//取 0 到 100 的随机数，对 a 赋值

a = new Random().nextInt(100);

b = new Random().nextInt(100);

System.out.println(“a :” + a + “, b :” + b);

//加法

c = a + b;

System.out.println(“a + b = “ + c);

//减法

c = a - b;

System.out.println(“a - b = “ + c);

//除法

c = a / b;

System.out.println(“a / b = “ + c);

//乘法

c = a b;

System.out.println(“a b = “ + c);

//取余

c = a % b;

System.out.println(“a % b = “ + c);

//将 c 加 4，然后将结果赋给 c

c += 4;

System.out.println(“c + 4 = “ + c);

自动递增和递减

自动递增和自动递减运算是两种很不错的快捷运算。递减操作符是 “–”， 就是减少一个单位；递增操作符是 “++”，就是增加一个单位。

这两个操作符有两种使用方式，称为 “前缀式” 和 “后缀式”。“前缀递增” 表示 “++” 操作符位与变量或表达式的前面，如 ++a；“后缀递增” 表示 “++” 位于变量或表达式的后面，如 a++。“前缀递减” 表示 “–” 操作符位于变量或表达式的前面，“后缀递减” 表示 “–” 操作符位于变量或表达式的后面。

//初始化一个变量 a

int a = 10;

//定义变量 b

int b;

//变量打印

System.out.println(“a : “ + a);

//前缀递增，就是先递增后赋值

b = ++a;

System.out.println(“++a : “ + b);

//后缀递增，就是先赋值后递增

b = a++;

System.out.println(“a++ : “ + b);

System.out.println(“a : “ + a);

//前缀递减，就是先递减后赋值

b = –a;

System.out.println(“–a : “ + b);

//后缀递减，就是先赋值后递减

b = a–;

System.out.println(“a– : “ + b);

前缀形式，就是执行运算后才得到值。后缀形式，就是运算执行前先得到值。

关系操作符

关系操作符生成的是一个 boolean(布尔)结果，计算的是操作数值之间的关系。如果关系是真实的，那么返回 true (真)；如果关系不真实，那么返回 false (假)。关系运算符包括小于()、小于或等于(<=)、大于或等于(>=)、等于(==)以及不等于(!=)。

Integer num1 = new Integer(12);

Integer num2 = new Integer(12);

//比较的是两个对象的引用

System.out.println(num1 == num2);

System.out.println(num1 != num2);

由于比较的是两个对象的引用，所以打印结果先是 true，后是 false。如果要比较对象的值，那么用 equals 方法，该方法适用所有对象。

//比较对象的值用 equals 方法，适用于所有对象

System.out.println(num1.equals(num2));

逻辑运算符

逻辑运算符 “与” (&&)、”或”(||)、”非”(!)能根据参数的逻辑关系，生成一个布尔值(true 或 false)。

//定义两个变量，赋值 1 到 100 的随机数

int a = new Random().nextInt(100);

int b = new Random().nextInt(100);

System.out.println(“a : “ + a);

System.out.println(“b : “ + b);

//定义一个布尔类型变量, a 小于 50 并且 b 小于 50

boolean flag = (a < 50) && (b < 50);

System.out.println(“(a < 50) && (b < 50) is “ + flag);

flag = (a < 50) || (b < 50);

System.out.println(“(a < 50) || (b < 50) is “ + flag);

“与”、“或”、“非”只可应用于布尔值。

按位操作符

按位操作符用来操作整数的二进制位，会对两个参数中对应的位执行布尔代数运算，并最终生成一个结果。

与操作符 “&”，如果两个输入位都是 1，那么输出位是 1，否则输入位是 0；

或操作符 “|” ，如果两个输入位有一个是 1，那么输出位是 1，只有两个输入位都是 0，输出位才是 0；

异或运算符 “^”，如果两个输入位都为 1 或者都为 0，那么输出位是 0，否则输出位是 1。

非运算符 “~”，这个一元操作符，只能对一个数操作，规则是输出位与输入位相反。

//转化为二进制：0101

int num1 = 5;

//转化为二进制：1001

int num2 = 9;

//与运算，二进制结果为 0001，打印结果为 1

System.out.println(num1 & num2);

//或运算，二进制结果为 1101，打印结果为 13

System.out.println(num1 | num2);

//异或运算，二进制结果为 1100，打印结果为 12

System.out.println(num1 ^ num2);

//非运算，二进制结果为 11111111111111111111111111111010，打印结果 -6

System.out.println(Integer.toBinaryString(~ num1));

好吧，进哥承认，我看到那个 -6 也蒙了那么一下，所以整理了以下内容。

补充

数字的二进制表现形式为 “有符号的二进制补码”。

原码：数字的二进制表示法，最高位为符号位， “ 0 ” 为正，“ 1 ” 为负。

反码：正数的反码与原码相同，负数的反码对原码逐位取反，符号位除外。

补码：正数的补码与原码相同，负数的补码在其反码末位加 1。

负数的二进制算法(以 -6 为例)：

1)将 -6 的绝对值转化为二进制，即：00000000 00000000 00000000 00000110

2)求该二进制数的反码，即：11111111 11111111 11111111 11111001

3)对以上求得的二进制数加 1，即：11111111 11111111 11111111 11111010

移位操作符

移位操作符的运算对象也是二进制的 “位”，但是只能用来处理整数类型。

左移位操作符 “< 右移位操作符 “>>” 按照操作符右侧指定的位数将操作符左边的操作数向右移动。“有符号”。该操作符使用 “符号扩展”：若符号为正，则高位插入 0；若符号为负，则高位插入 1。

“无符号”右移位操作符 “>>>”，使用 “零扩展”，无论正负，都在高位插入 0。

//二进制 1111;

int i = 15;

//向右边移动两位，二进制结果为 0011，打印结果为 3

System.out.println(i >> 2);

//向左边移动两位，二进制结果为 111100，打印结果为 60

System.out.println(i << 2);

移位操作符可以与等号组合使用(<<= 或 >>= 或 >>>=)，表示操作符左边的值会移动由右边数值指定的位数，再将得到的结果赋给左边的变量。

三元操作符

三元操作符也称为条件操作符，因为它有三个操作数，但是它确实属于操作符的一种，因为它最终也会生成一个值。我们通常习惯称之为三目运算符。

基本形式如下：

result = boolean - exe ? value0 : value1

如果boolean - exe(布尔表达式)结果为 true，就计算 value0，否则就计算 value1，计算的结果赋给 result，也就是操作符最终产生的值。

//定义两个变量，取 0 到 100 的随机数

int a = new Random().nextInt(100);

int b = new Random().nextInt(100);

System.out.println(“a = “ + a + “, b = “ + b);

//求 a 和 b 的差值，如果 a > b 那么计算 a - b，反之，计算 b - a

int c = a > b ? a - b : b - a;

System.out.println(“|a - b| = “ + c);

以上三目运算符中，a > b 即为布尔表达式，如果判断结果为 true，那么 c 的值就是 a - b；反之 c 的值就是 b - a；

字符串操作符 + 和 +=

字符串操作符用于连接不同的字符串。这个操作符有一个很有趣的行为，如果表达式以一个字符串开头，那么后续所有操作数都必须是字符串型。

//定义三个常量

int a = 1;

int b = 2;

int c = 3;

//定义一个字符串 s

String s = “ “;

//没有字符串,结果为常量相加的值：6

System.out.println(a + b + c);

//第一个 a + b 前面没有字符串所以结果为常量相加的值：3

//第二 a + b 前面有个字符串，所以结果为：12

System.out.println(a + b + s + a + b);

//使用 += 进行字符串追加

s += “sum : “;

//a + b 因为加了括号改变了赋值顺序，所以结果为常量相加的值：3

System.out.println(s + (a + b));

类型转换操作符

类型转换符就是将一种数据类型转换为另一种。执行类型转换，需要将希望得到的数据类型置于圆形括号内，放在要进行类型转换的值得左边。

int a = 122;

//使用类型转换将 int 类型的变量转为 long 型

long b = (long)a;

//使用类型转换将 int 类型的数值转为 long 型

long c = (long)122;

//使用类型转换将 long 类型的变量转为 int 型

a = (int)b;

将 int 类型转换为 long 类型，这是扩展转换，这种操作不必进行显示地进行进行类型转换，因为 long 型肯定能容纳 int 型的数值，不会造成信息丢失。

将 long 类型转换为 int 类型，这是窄化转换，因为有时候 int 型显然无法容纳 long 型那么多的信息，所以可能面临信息丢失的风险。此时编译器会要求强制进行类型转化。

补充

1)Java 允许将任何基本数据类型转换为别的基本数据类型，但是布尔型除外，布尔型不能进行任何类型的转换处理。

2)将 float 或 double 类型转换为整型时，总是对该数字进行截尾(去掉小数位)。

3)在 char 或 byte 或 short 这些类型时，这些只会自动转换为整型，最终生成的结果也是 int 类型。

4)通常表达式中出现的最大的数据类型决定表达式最终结果的数据类型，如：float 和 double 相乘，结果是 double 型。

直接常量

直接常量后面的后缀字符标志了它的类型。若为大写(不推荐小写)L，代表 long，大写的 F 代表 float，大写的 D 代表 double。

//大写的 L ，表示 long 型

long num1 = 12L;

//大写的 F ，表示 float 型

float num2 = 12.1F;

//大写的 D ，表示 double 型

double num3 = 12.2D;

欢迎关注公众号：一盐难进