复习到了运算符这块，整理一下笔记，以备后续参考。

运算符：运算符顾名思义是一种符号，它是连接一个以上的操作符，实现某种功能的运算。

目录

一、算数运算符 

二、位运算符

三、逻辑运算符

四、关系运算符

五、运算符优先级

根据需要点击目录可直接跳转。

一、算数运算符 

算术运算符用在数学表达式中，主要实现的是算术运算，如常见的加减乘除等。

表格中的例子中，变量 a 的值为 5，变量 b 的值为 3，变量 i 的值为 1：

其中，自增 (++) 和自减 (--) 运算符有两种写法：前缀（++i,--i）和后缀（i++,i--）。

• 前缀自增自减法 (++i,--i): 先进行自增或者自减运算，再进行表达式运算。
• 后缀自增自减法 (i++,i--): 先进行表达式运算，再进行自增或者自减运算

新建一个源代码文件 ArithmeticOperation.java：

public class ArithmeticOperation {
    public static void main(String args[]) {
        int a = 5;
        int b = 3;
        int c = 3;
        int d = 3;
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));
        System.out.println("a++ = " + (a++));
        System.out.println("++a = " + (++a));
        System.out.println("b-- = " + (b--));
        System.out.println("--b = " + (--b));
        System.out.println("c++ = " + (c++));
        System.out.println("++d = " + (++d));
    }
}

编译运行：

$ javac ArithmeticOperation.java
$ java ArithmeticOperation
a + b = 8
a - b = 2
a * b = 15
a / b = 1
a % b = 2
a++ = 5
++a = 7
b-- = 3
--b = 1
c++ = 3
++d = 4

二、位运算符

Java 定义了位运算符，应用于整数类型 (int)，长整型 (long)，短整型 (short)，字符型 (char)，和字节型 (byte) 等类型。位运算时先转换为二进制，再按位运算。

表格中的例子中，变量 a 的值为 60（二进制：00111100），变量 b 的值为 13（二进制：00001101）：

 新建一个源代码文件 BitOperation.java：

public class BitOperation {
    public static void main(String args[]) {
        int a = 60;
        int b = 13;
        System.out.println("a & b = " + (a & b));
        System.out.println("a | b = " + (a | b));
        System.out.println("a ^ b = " + (a ^ b));
        System.out.println("~a = " + (~a));
        System.out.println("a << 2 = " + (a << 2));
        System.out.println("a >> 2 = " + (a >> 2));
        System.out.println("a >>> 2 = " + (a >>> 2));
    }
}

编译运行：

$ javac BitOperation.java
$ java BitOperation
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

三、逻辑运算符

逻辑运算符是通过运算符将操作数或等式进行逻辑判断的语句。

表格中的例子中，假设布尔变量 a 为真（true），变量 b 为假（false）：

&& 与 || 是具有短路性质，当按优先级顺序计算到当前表达式时，表达式的结果可以确定整个表达式的结果时，便不会继续向后进行判断和计算，而直接返回结果。

例如：当使用 && 逻辑运算符时，在两个操作数都为 true 时，结果才为 true，但是当得到第一个操作为 false 时，其结果就必定是 false，这时候就不会再判断第二个操作了。在计算表达式 (a & b) && (a | b) 时，首先计算 a & b 得到了 false，因为之后是 &&，任何值与 false 进行与操作都是 false，所以可以不用再计算下去，而直接返回 a & b 的结果 false。

新建一个LogicOperation.java：

public class LogicOperation {
    public static void main(String args[]) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a && b));
        System.out.println("a || b = " + (a || b));
        System.out.println("!a = " + (!a));
        System.out.println("a ^ b = " + (a ^ b));
    }
}

编译运行：

$ javac LogicOperation.java
$ java LogicOperation
a && b = false
a || b = true
!a = false
a ^ b = true

四、关系运算符

关系运算符生成的是一个 boolean（布尔）结果，它们计算的是操作数的值之间的关系。如果关系是真实的，结果为 true（真），否则，结果为 false（假）。

表格中的例子中，假设变量 a 为 3，变量 b 为 5：

除了上表列出的二元运算符，Java 还有唯一的一个三目运算符 ?: 。

语法格式：

布尔表达式 ？表达式 1 : 表达式 2;

运算过程：如果布尔表达式的值为 true，则返回表达式 1的值，否则返回表达式 2的值。

新建一个源代码文件 RelationalOperation.java：

public class RelationalOperation {
    public static void main(String args[]) {
        int a = 3;
        int b = 5;
        System.out.println("a == b = " + (a == b));
        System.out.println("a != b = " + (a != b));
        System.out.println("a > b = " + (a > b));
        System.out.println("a < b = " + (a < b));
        System.out.println("a >= b = " + (a >= b));
        System.out.println("a <= b = " + (a <= b));
        System.out.println("a > b ? a : b = " + (a > b ? a : b));
    }
}

编译运行：

$ javac RelationalOperation.java
$ java RelationalOperation
a == b = false
a != b = true
a > b = false
a < b = true
a >= b = false
a <= b = true
a > b ? a : b = 5

强调：

• == 和 != 适用于所有的基本数据类型，其他关系运算符不适用于 boolean，因为 boolean 值只有 true 和 false，比较没有任何意义。
• == 和 != 也适用于所有对象，可以比较对象的引用是否相同。

引用：Java 中一切都是对象，但操作的标识符实际是对象的一个引用。

五、运算符优先级

运算符的优先级是帮助我们在一个表达式中如何对于不同的运算符和相同的运算符，进行正确的运算顺序。

运算符的优先级不需要特别地去记忆它，比较复杂的表达式一般使用圆括号 () 分开，提高可读性。

参考资料：实验楼学习文档

算术运算符

算术运算符有：+ - * / % ++ –
++分为前置++ 和后置++，这俩者有所不同。
前置++是先加后用，后置++是先用后加。
前置–是先加后用，后置–是先用后加。
如下：我们可以看出++a在a++之前，也就是说 ++a和a++屏幕显示的是6。

public class s{
    public static void main(String[] args)
    {
      
        int a,b;
        a=5;b=15;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
        System.out.println(a%b);
        System.out.println(++a);
        System.out.println(a++);
     

    }
}

关系运算符

关系运算符:> >= < <= == !=
关系运算符返回的值类型是boolean类型，即true和false

public class s{
    public static void main(String[] args)
    {
      
        int a,b;
        a=15;b=15;
        System.out.println(a>b);
        System.out.println(a>=b);
        System.out.println(a<b);
        System.out.println(a<=b);
        System.out.println(a==b);
        System.out.println(a!=b);
      
     

    }
}

逻辑运算符

逻辑运算符有： &（与） |（或） ^（异或） !（非）
&&(短路与) ||（短路或）
&&和&都是一假即假
||和|都是一真即真
^只有俩边不同才为真
！真变成假，假变成真
&&和&有所区别，当&前面的表达式为假的时候，后面的表达式依然会进行运算，而&&不会。

public class s{
    public static void main(String[] args)
    {
      
        int a,b;
        a=15;
        b=15;
        System.out.println(true&false);
        System.out.println(true&true);
        System.out.println(true|false);
        System.out.println(true^false);
        System.out.println(true^true);
        System.out.println(!true);
        System.out.println(a>b&&a++>b);
        System.out.println(a);
        System.out.println(a>b&a++>b);
        System.out.println(a);
      
     

    }
}

可以看出&&后面的表达式并没有执行，所以a依然为15，
而&后面的表达式执行，a为16.

赋值运算符

赋值运算符：= += -= *= /= %=

public class s{
    public static void main(String[] args)
    {
      
      byte a=10;
      a=a+4;
      
     

    }
}

这样的代码编译会报错，因为可能会损失精度，所以需要加强制类型转换。
而这样不会：

public class s{
    public static void main(String[] args)
    {
      
      byte a=10;
      a+=4;
      
     

    }
}

这说明复合运算符会默认加上强制类型转换，即a=(byte)(a+4)。

目录

一、算术运算符

二、关系运算符

三、逻辑运算符

一、算术运算符

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 4 + 5 * 2 - 6 / 3 + 11 % 4;//4+10-2+3=15
	printf("%d\n",a);
	scanf("%d", &a);
	printf("a=%d\n", a);//如果输入1234，输出4321
	while (a != 0)
	{
		printf("%d", a % 10);
		a = a / 10;
	}
	return 0;
}

二、关系运算符

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 2;
	if (3 < a < 10)//无论a等于多少，都为真
	{
		printf("a is right");
	}
	else
	{
		printf("a is wrong");
	}
	return 0;
}

事实上，无论a等于多少，都会执行printf（“a is right”）;这条语句，因为两个<的优先级一致，所以从左到右按顺序执行

如果a大于3，结果为真（即1），1小于10，故总体为真；

如果a小于3，结果为假（即0），0小于10，故总体为真。

所以关系运算符不能这样用，如果要表示a>3同时a<10，要使用逻辑运算符

三、逻辑运算符

将上面的代码修改成

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 2;
	if (3 < a && a < 10)
	{
		printf("a is right");
	}
	else
	{
		printf("a is wrong");
	}
	return 0;
}

练习：判断两个浮点数是否相等

写下面一段代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	float f = 234.56;

	return 0;
}

进行调试，可以知道内存中f其实存的并不是准确的234.56，如图

 所以如果写下面的代码不能进行正确的判断

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	float f = 234.56;
	if (f == 234.56)
	{
		printf("f is equal to 234.56\n");
	}
	else
	{
		printf("f is not equal to 234.56");
	}
	return 0;
}

结果如下

所以必须用下面这种方法进行判断，原理是浮点数的精确度是7位

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	float f = 234.56;
	if (f - 234.56 > -0.0001 && f - 234.56 < 0.0001)
	{
		printf("f is equal to 234.56\n");
	}
	else
	{
		printf("f is not equal to 234.56");
	}
	return 0;
}

练习：用c%输出0-128之间的整型数

 错误代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	char a;
	scanf("%d", &a);
	printf("%c\n", a);
	return 0;
}

原因：由于char占1个字节，int占四个字节，输入四个字节的数，要求输出char类型的a（1个字节）超出空间。

正确代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a;
	scanf("%d", &a);
	printf("%c\n", a);
	return 0;
}

此时的a也是四个字节的整型，0-128之间的整型数可以用c%输出。