今天我们开始第四天的学习，学习是一个艰苦的过程，让我们努力付出，享受收获吧！
这边我放上前几期的链接，希望可以到帮助大家
| 目录 | 内容 | 链接 |
| 从零开始学Java-Day01 | Java简介、编写第一个Java程序 | 从零开始学Java - Day01_阿怂Jun的博客-CSDN博客前言： 作为一个非科班毕业的大专生，很高兴能够进入Java这个大家庭。在这里，我会分享一些Java初学阶段所需要知道的一些内容，如果各位感觉有什么写的不对的地方，可以随意指出，我们共同学习，共同进步。一、计算机简介在开始学习Java之前，我们首先需要了解一些计算机的一些常识。相信大家可能比我还要了解计算机了，这里我就找了些资料，简单的描述一下。1.1、第一台计算机的诞生世界上第一台通用计算机“ENIAC”于1946年2月14日... |
| 从零开始学Java-Day02 | 八大基本数据类型 | 从零开始学Java - Day02_阿怂Jun的博客-CSDN博客今天，我们学习Java的一些基础知识，循序渐进，让我们慢慢的发现Java的魅力！一、Java须知的命名规则和规范 1.1 标识符 标识符，通俗意义上讲，就是我们程序员自己定义的名称，例如类名，方法名，变量名等等。也可以这样理解，只要需要我们自己起名字的，就是标识符。当然，名字也不能随便取，Java定义了合法标识符的规则： 1）由26个英文字母大小写，0-9，_或者$组成 2）数字不可以开头... |
| 从零开始学Java-Day03 | 变量、常量、数据类型转换 | 从零开始学Java-Day03 -- 基础语法、类型转换_阿怂Jun的博客-CSDN博客兄弟们，时隔多天，我们又见面了。今天，我们学习一下Java的一些基础语法。一、常量 常量的定义：常量就是固定不变的量，一旦被定义，它的值就不能再被改变。通过final关键字进行修饰，是否使用static关键字根据实际情况而定。 常量的语法：final 数据类型 常量名 = 值； 使用示例：/** * Java基础语法 */public class JavaGrammar { s... |
目录
一、运算符
1.1、算术运算符
1.2、关系运算符
1.3、赋值运算符
1.4、逻辑运算符
1.5、位运算符
二、运算符的优先级
一、运算符
Java中的语句有多种形式，表达式就是其中的一种形式。表达式是由操作数与运算符所组成；
例如表达式（num + 100），“num” 与 “100”都是操作数，而“+”就是运算符。
1.1、算术运算符
算术运算符主要用于进行基本的算术运算，如加减乘除等。
代码示例：
/**
* 算术运算符演示
*/
public class CountTest {
public static void main(String[] args) {
int number1 = 10;
int number2 = 3;
/*
* ‘+’，用于运算操作时，表示加法运算
* */
int result = number1 + number2;
System.out.println("+ ：result = " + result);
/*
* '-'，用于运算操作时，表示减法运算
* */
result = number1 + number2;
System.out.println("- ：result = " + result);
/*
* '*'，用于运算操作时，表示乘法运算
* */
result = number1 * number2;
System.out.println("* ：result = " + result);
/*
* '/'，用于运算操作时，表示除法运算
* */
result = number1 / number2;
System.out.println("/ ：result = " + result);
/*
* '%'，用于运算操作时，表示取余（取模）运算
* 这里需要注意：取余结果的正负取决于被余数。
* */
result = 10 % 3;
System.out.println("% ：result = " + result);
result = 10 % -3;
System.out.println("% ：result = " + result);
result = -10 % 3;
System.out.println("% ：result = " + result);
result = -10 % -3;
System.out.println("% ：result = " + result);
/*
* '++'，用于运算操作时，表示自增1运算
* ++在操作数后面时，表示这次操作结束后进行自增
* ++在操作数前面时，表示先进行自增，自增完成后再继续操作
* */
//这次运算结束后，number1被赋值为11
result = number1++;
System.out.println("number1++：result = " + result);
//这里number1的值已经为11了，在进行一次自增1，所以number的值为12
result = ++number1;
System.out.println("++number1：result = " + result);
/*
* '--'，用于运算操作时，表示自减1运算
* --在操作数后面时，表示这次操作结束后进行自减
* --在操作数前面时，表示先进行自减，自减完成后再继续操作
* */
//程序运行到这里，number1的值已经经过自增操作后变成了12，在这次操作结束后进行自减1
result = number1--;
System.out.println("number1--：result = " + result);
//这里number1已经自减过一次，值为11，又因为这次--在操作数前面，先进行自减，再操作。所以11再自减1，最终值为10
result = --number1;
System.out.println("--number1：result = " + result);
}
}运行结果如下：
注意点：
1）进行取余操作时，计算结果的正负取决于被余数。
2）‘+’ 在算术运算中做加法处理，不过在处理字符串时，被当做拼接符。
3）在‘++’，‘--’操作时，当运算符在操作数的左边时，先自增/自减,再赋值。当运算符在操作数的右边是，先赋值，再自增/自减。
4）在‘++’，‘--’操作时，运算符只能对变量进行操作，无法直接用于常量和数值。例如 5++，6--这样的写法是错误的。
5）在进行除法运算时，当除数和被除数都为整数时，得到的结果会忽略小数点后面的小数部分，结果只取整数。当除数或被除数有一方为小数时，结果会是一个小数。
1.2、关系运算符
Java中的关系运算符的表示方式和在数学中类似，但是由于赋值运算符为“=”，为了避免混淆，关系运算符“等于”时，必须用“==”表示；而关系运算符“不等于”用“!=”表示，这是因为键盘想输入数学中的“≠”符号毕竟困难，所以就使用“!=”表示不等于。关系运算符用于对两个数值或变量进行比较，得到的结果是一个布尔值。
代码示例：
/**
* 关系运算符演示
*/
public class RelationalOperator {
public static void main(String[] args) {
int a = 1;
int b = 2; //声明两个变量
boolean result; //定义一个boolean类型result保存结果
result = a > b;
System.out.println("a > b：result = " + result);
result = a < b;
System.out.println("a < b：result = " + result);
result = a >= b;
System.out.println("a >= b：result = " + result);
result = a + 1 >= b;
System.out.println("a + 1 >= b：result = " + result);
result = a <= b;
System.out.println("a <= b：result = " + result);
result = a + 1 <= b;
System.out.println("a + 1 <= b：result = " + result);
result = a == b;
System.out.println("a == b：result = " + result);
result = a != b;
System.out.println("a != b：result = " + result);
}
}运行结果如下：
注意：Java允许“==”和“!=”两种运算符用于任何数据类型，例如，既可以判断两个数的值是否相等，也可以判断对象或数组的实例是否相等。判断实例时比较的是两个对象在内存中的引用地址是否相等。
1.3、赋值运算符
赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量
代码示例：
/**
* 赋值运算符演示
*/
public class AssigningOperator {
public static void main(String[] args) {
/*
* “=”就是将右边的表达式或变量的值传入左边的变量中
* */
int a = 10;
int b = 4;
/*
* +=在这里相当于a = a + b;
* 程序走到这里 a = 14; b = 4
* */
a += b;
System.out.println("a = " + a);
/*
* -=在这里相当于a = a - b;
* 程序走到这里 a = 10; b = 4
* */
a -= b;
System.out.println("a = " + a);
/*
* *=在这里相当于a = a * b;
* 程序走到这里 a = 40; b = 4
* */
a *= b;
System.out.println("a = " + a);
/*
* /=在这里相当于a = a / b;
* 程序走到这里 a = 10; b =4
* */
a /= b;
System.out.println("a = " + a);
/*
* %=在这里相当于a = a % b;
* 程序走到这里 a = 2; b =4
* */
a %= b;
System.out.println("a = " + a);
}
}运行结果如下：
1.4、逻辑运算符
逻辑运算符主要用于进行逻辑运算
代码示例：
/**
* 逻辑运算符演示
*/
public class LogicalOperator {
public static void main(String[] args) {
int a = 1;
int b = 2;
/*
* 一假即假
* 当 a < b 并且 ++a < b 同时满足时，返回true，否则返回false
* ‘&’，当第一个条件判断为false时，仍然会继续执行第二个条件进行判断
* */
System.out.println(a > b & ++a < b); //此时a = 2;b = 2
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("=======================");
/*
* 一假即假
* 当 a < b 并且 ++a < b 同时满足时，返回true，否则返回false
*“&&”，当第一个条件判断为false时，语句直接结束，不会继续执行
* */
System.out.println(a < b && ++a < b); //此时a = 2;b = 2
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("=======================");
/*
* 一真即真
* 当a == b 或者 a > ++b中 有一个满足条件，返回true，两个都不满足则返回false
* ‘|’，当第一个条件判断为true时，仍然会继续执行第二个条件进行判断
* */
System.out.println(a == b | a > ++b); //此时a = 2; b =3
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("=======================");
/*
* 一真即真
* 当a == b 或者 a > ++b中 有一个满足条件，返回true，两个都不满足则返回false
* ‘|’，当第一个条件判断为true时，语句直接结束，不会继续执行
* */
System.out.println(a < b || a > ++b); //此时a = 2; b =3
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("=======================");
/*
* ‘！’，结果取反，如果(a < b)返回true，则!(a<b)就返回false，反之亦然。
* */
System.out.println(!(a < b)); //此时a = 2; b =3
System.out.println(!(a > b));
System.out.println("=======================");
/*
* ‘^’,当两边的表达式返回结果不一样时，返回true，若两边表达式返回一样，返回false
* 此时a = 2; b =3
* */
System.out.println(a < b ^ a > b); //左边表达式返回true，右边表达式返回false，最终返回true
System.out.println(a < b ^ b > a); //左边表达式返回true，右边表达式返回true，最终返回false
System.out.println(a > b ^ b < a); //左边表达式返回false，右边表达式返回false，最终返回false
}
}运行结果如下：
注意：“|| / &&”，当第一个条件就能判断出结果的时候，语句就不会继续执行，效率要高于“| / &”。
1.5、位运算符
位运算就是操作数进行二进制的运算。
代码示例：
/**
* 位运算符演示
*/
public class AnOperator {
public static void main(String[] args) {
/*
* “&”与运算符，在位运算中，如果两个二进制位都为1，则该位的运算结果为1，否则为0.
* 可以理解为：遇0为0，无0为1。
*我们可以看一下下面两个表达式的运算过程：
* 1的二进制：0000 0001,2的二进制：0000 0010
* 0000 0001
* & 0000 0010
* =============
* 0000 0000 转换为十进制为：0
*
* 11的的二进制：0000 1011，22的二进制为：0001 0110
* 0000 1011
* & 0001 0110
* =============
* 0000 0010 转换为十进制为：2
* */
System.out.println("&运算符：" + (1 & 2)); //运行结果：0
System.out.println("&运算符：" + (11 & 22)); //运行结果：2
System.out.println("======================");
/*
* “|”或运算符，在位运算中，如果二进制位上有一个值为1，则该位的运行结果为1，否则为0
* 1的二进制：0000 0001,2的二进制：0000 0010
* 0000 0001
* | 0000 0010
* =============
* 0000 0011 转换为十进制为：3
*
* 11的的二进制：0000 1011，22的二进制为：0001 0110
* 0000 1011
* | 0001 0110
* =============
* 0001 1111 转换为十进制为：31 * */
System.out.println("|运算符：" + (1 | 2)); //运行结果：3
System.out.println("|运算符：" + (11 | 22)); //运行结果：31
System.out.println("======================");
/*
*“^”异或运算符，在位运算中，如果二进制位相同，则值为0，否则为1
* 1的二进制：0000 0001,2的二进制：0000 0010
* 0000 0001
* ^ 0000 0010
* =============
* 0000 0011 转换为十进制为：3
*
* 11的的二进制：0000 1011，22的二进制为：0001 0110
* 0000 1011
* ^ 0001 0110
* =============
* 0001 1101 转换为十进制为：29
* */
System.out.println("^运算符：" + (1 ^ 2)); //运行结果：3
System.out.println("^运算符：" + (11 ^ 22)); //运行结果：29
System.out.println("======================");
/*
* “~”取反运算符，只对一个操作数进行运算，如果二进制位是0，则取反值为1；如果是1，则取反值为0
* 2的二进制：0000 0010
* 取反后：1111 1101 ，转换为二进制为：-3
* 22的二进制位：0001 0110
* 取反后：1110 1001，转换为二进制为：-23
* */
System.out.println("~运算符：" + ~2); //运行结果：-3
System.out.println("~运算符：" + ~22); //运行结果：-23
System.out.println("======================");
/*
* “<<”左移运算符，就是将被操作数转换为2进制后，向左移动指定的位数，空位补0；
* 127的二进制：0111 1111
* 进行“<<2”位的运算后：01 1111 1100，转换为十进制后：508
* 22的二进制：0001 0110
* 进行“<<2”位的运算后：0101 1000，转换为十进制后：88
* */
System.out.println("<<运算符:" + (127 << 2)); //运行结果：508
System.out.println("<<运算符:" + (22 << 2)); //运行结果：88
System.out.println("======================");
/*
* “>>”右移运算符，就是将被操作数转换为2进制后，向右移动指定的位数，正数空位补0，负数空位补1
* 127的二进制：0111 1111
* 进行“>>2”位的运算后：0001 1111，转换为十进制后：31
* -22的二进制：1001 0110
* 进行“>>2”位的运算后：1000 0101，转换为十进制后：-6
* */
System.out.println(">>运算符:" + (127 >> 2)); //运行结果：31
System.out.println(">>运算符:" + (-22 >> 2)); //运行结果：-6
System.out.println("======================");
/*
* “>>>”无符号位移符，无符号右移的计算规则与右移相同，区别在于，不会进行正负的区分，高位一律用0补位
*22转换为32位的二进制数： 0000 0000 0000 0000 0000 0000 0001 0110，
* 进行“>>>2”位的运算后：0000 0000 0000 0000 0000 0000 0000 0101,转换为10进制为：5
* -22转换为32位的二进制数： 1000 0000 0000 0000 0000 0000 0001 0110，
* 取补码： 1111 1111 1111 1111 1111 1111 1110 1010
* 进行“>>>2”位的运算后： 0011 1111 1111 1111 1111 1111 1111 1010
* 转换为10进制后：1073741818
* */
System.out.println(">>>运算符:" + (22 >>> 2)); //运行结果：5
System.out.println(">>>运算符:" + (-22 >>> 2)); //运行结果：1073741818
int i = 1073741821;
}
}运行结果如下：
为了方便理解<</>>/>>>三个位操作符，可以看下面这张图：
注意：
1）移动的位数不应该超过该数字对应的二进制位数，不然会得到毫无意义的结果。
2）当x,y都为正整数时，且满足第一条注意事项的情况下，进行x << y运算时，运算结果和相同。进行x>>y运算时，运算结果和
相同。
3)>>>无论正负最高位取0，<<空位补0，>>正数补0，负数补1。
二、运算符的优先级
在Java中大多数的运算符也是从左向右结合的，其中，单目运算符、赋值运算符和三目运算符是从右向左结合的，也就是从右向左运算。运算符有不同的优先级，所谓优先级就是在表达式运算中的运算顺序。
这里演示几种常见的使用：
public class Priority {
public static void main(String[] args) {
int x = 2;
int y = 3;
int z = 4;
/*
* 在这个表达式中，*的优先级要大于+，而（）的优先级要高于*，与正常的数学运算中的计算顺序相同
* 1）先计算（2+3）
* 2）再计算5*4，结果为201
* */
System.out.println("结果为：" + (x+y)*z);
/*
* 1)优先计算自增，3*5
* 2）然后再计算*，结果为15
* */
System.out.println("结果为：" + (++x * ++z));
x = 2;
z = 4;
/*
* 1)先计算自增，2 += 5；
* 2）再计算赋值，2 = 2 + 5，结果为7
* */
System.out.println("结果为：" + (x += ++z));
}
}运行结果如下：
注意：为了提高代码的可读性，尽量不要使用太过复杂的表达式。尽量使用（）来控制计算顺序。
