java_Day03_运算符
1.运算符
1.1 算术运算符
开发算术运算符:
加 + 减 - 乘 * 除 / 取余 % 小括号 () = 赋值号
注意事项:
1. 先乘除，后加减
2. 从左至右运行
3. 除数不能为0
4. 先运算小括号里面的内容
【批注】
1. Java中所有的运算符优先级有18-19个等级，优先级最高的是小括号，开发中
如果出现了需要整理优先级的问题，简单粗暴加括号
2. 小括号里面的内容对于小括号外部而言是一个整体，是一个【常量】
= 赋值号
赋值号的功能是将赋值号右侧的数据，赋值给左侧的【变量】
char ch = ‘A’; True
10 = 20; false
使用总结:
1. 变量有且只能是被赋值之后才可以修改内容，未赋值不能修改
2. 取余操作注意细节
3. 【批注】
取余操作针对整数，小数没有取余操作
/* 算术运算符演示 */
class Demo1 {
public static void main(String[] args) {
// 定义两个int类型变量
int num1 = 10;
int num2 = 20;
// num1 + num2结果赋值给num1
num1 = num1 + num2; // num1 = 30 num2 = 20
// 变量在代码运行的过程中是会发生改变。
num1 = num1 * num2; // num1 = 600 num2 = 20
num1 = num1 - num2; // num1 = 580 num2 = 20
num1 = num1 / num2; // num1 = 29 num2 = 20
// 小学手写方式
// 20 ÷ 29 = 0 ...... 20
// 5 ÷ 2 = 2 ...... 1
// 9 ÷ 4 = 2 ...... 1
num1 = num2 % num1; // num1 = 20 num2 = 20
/*
num2的值从开始到最后没有发生改变
num2从开始没有被赋值过
*/
System.out.println(num1);
System.out.println(num2);
}
}
1.2 偷懒专用算术运算符
+= -= /= *= %=
num1 = num1 + num2; ==> num1 += num2;
/* 偷懒专用算术运算符 */
class Demo2 {
public static void main(String[] args) {
// 定义两个变量
int num1 = 10;
int num2 = 20;
// num1 = num1 + num2;
num1 += num2;
num1 *= num2;
System.out.println(num1);
System.out.println(num2);
}
}
1.3 关系运算符
小学关系运算符:
> < ≥ ≤ ≠ =
代码开发中关系运算符
> 大于
< 小于
>= 大于等于
<= 小于等于
!= 不等于
== 等于判断
注意事项：
1. 关系运算符结果是一个boolean数据类型，true or false
2. 关系运算符一般用于条件判断，数据过滤…
/* 关系运算符 */
class Demo3 {
public static void main(String[] args) {
// 定义一个boolean 类型变量
boolean ret = true;
// 5 > 10 结果赋值给ret 这个boolean类型变量
ret = 5 > 10;
System.out.println(ret); // false
ret = 5 < 10;
System.out.println(ret); // true
ret = 5 >= 5;
System.out.println(ret); // true
ret = 5 <= 2;
System.out.println(ret); // false
ret = 5 != 5;
System.out.println(ret); // false
ret = 5 == 4;
System.out.println(ret); // false
}
}
1.4 自增自减运算符
【明确】
自增自减运算符【有且只能操作变量】，不可以操作常量
【建议】
开发中尽量减少或者标准化使用自增自减运算符。
语法
++ 自增运算符 操作的变量自增1 等价于 += 1
– 自减运算符 操作的变量自减1 等价于 -= 1
【难点】
前后关系
自增自减运算符在
变量之前：首先执行自增自减操作，再来完成当前行代码的运行
变量之后：首先执行当前行代码，再来执行自增自减操作
【16岁老程序员给你的建议】
1. 尽量使用 += 1 或者 -= 1替换自增自减运算符。阅读性更好，并且在Swift语言中
已经取消自增自减运算符，使用 += 1 和 -= 1代替，为了避免没有必要的歧义性
2. 如果非要使用自增自减运算符，推荐自增自减运算符，单独成行。
int num = 10;
++num; or num++; 没有任何的歧义性。
/* 自增运算符前后关系演示 */
class Demo4 {
public static void main(String[] args) {
int num1 = 10;
// 双引号内容是所见即所得
/*
自增运算符在操作数之后，首先操作数原始数据参与该行代码运行
当前代码运行结束之后，再进行自增操作。
先执行当前行代码，再执行自增操作
*/
System.out.println("num1++ : " + num1++); // num1++ : 10
System.out.println("num1 : " + num1); // num1 : 11
/*
自增运算符在操作数之前，首先执行自增操作，num1 += 1;
num1 ==> 12 然后在进行数据展示
先执行自增，在参与当前行代码执行
*/
System.out.println("++num1 : " + ++num1); // ++num1 : 12
System.out.println("num1 : " + num1); // num1 : 12
}
}
/* 自减运算符演示 */
class Demo5 {
public static void main(String[] args) {
int num = 10;
System.out.println("num-- : " + num--); // num-- : 10
System.out.println("num : " + num); // num : 9
System.out.println("--num : " + --num); // num-- : 8
System.out.println("num : " + num); // num : 8
}
}
2.自增自减运算符考点
2.1 常见面试题1
int num = 5;
int ret = num++ * ++num;
ret = ?
num = ?
/*
请问num值经历了几次自增操作？
两次，num确定最后结果为7
ret的结果从何而来？
num++
++在后，提供的数据5， num++在运行表达式中提供的数据为5
这里运算操作是一个乘以操作，num++需要执行完毕 num ==> 6
*
++num:
++在前，提供的数据6 + 1 ==> 7
最终表达式的结果为
5 * 7 = 35 ==> ret;
int ret = num++ * ++num;拆解
num == 5;
num += 1 ==> 6
*
++num ==> 7
*/
2.2 常见面试题2
int num = 5;
++(num++);
num = ?;
/*
Demo7.java:5: 错误: 意外的类型
++(num++);
^
需要: 变量
找到: 值
1 个错误
解释:
因为(num++)是存在于小括号以内，按照计算优先级处理，首先计算小括号里面的内容，但是因为小括号是一个整体，对外的数据时num++的结果，这是一个常量！！！
自增自减运算符，只能操作变量，不可以操作常量。
语法报错！！！
同理
++num++ 也是错误的
++num结果是一个常量
(num)这个是常量还是变量呢
这个小括号是无用的！！！
（num）++这是对的
num = 5
拿++num*++num = 42
5
num++ + --num + ++num
*/
3.逻辑运算符
与 && :
银行的金库，两个人两把钥匙，需要同时在场，缺一不可。
【重点】同真为真，有假【即】假
或 || :
自己家门，我和我女朋友出去逛街，只要有一个人带有钥匙就可以回家，满足一个条件即可。
【重点】有真【即】真，同假为假
非 ! : 取反
逻辑运算符运算的结果都是boolean类型数据。
通常用于条件判断，数据过滤…
/* 逻辑运算符演示 */
class Demo8 {
public static void main(String[] args) {
// 定义一个boolean类型的变量
boolean ret = false;
ret = 5 > 3 && 10 > 8;
System.out.println("ret : " + ret); // true
ret = 5 < 3 && 10 > 8;
System.out.println("ret : " + ret); // false
ret = 5 < 3 || 10 > 8;
System.out.println("ret : " + ret); // true
ret = 5 < 3 || 10 < 8;
System.out.println("ret : " + ret); // false
ret = !(5 > 3);
System.out.println("ret : " + ret); // false
}
}
3.1 逻辑运算符短路原则
/* 逻辑与短路原则 */
class Demo9 {
public static void main(String[] args) {
int num = 5;
boolean ret = false;
/*
只要有错后面的就不看了吗 为了效率是吗
逻辑与的情况下：
同真为真，有假【即】假
当出现一个条件为false之后，整个逻辑与表达式的结果为
false，从false之后的其他所有条件都不会执行。
计算机的节约性能问题！！！
*/
ret = num > 10 && ++num > 1;
System.out.println("ret : " + ret);
System.out.println("num : " + num);
}
}
/* 逻辑或短路原则问题 */
class Demo10 {
public static void main(String[] args) {
int num = 10;
boolean ret = false;
/*
逻辑或短路原则
有【真】即真，同假为假
只要发现一个条件为真，整个表达式结果已经确定为真。
从true条件开始其他条件不需要执行
*/
ret = num > 5 || ++num > 20;
System.out.println("ret : " + ret); // true
System.out.println("num : " + num); // 10
}
}
4.练习题
/*
条件：
写出判断是否是英文大写字母的条件
在使用字符常量时，请使用字符本身
*/
char ch; // 声明一个变量
ch >= 'A' && ch <= 'Z';
// 'A' <= ch <= 'Z'; // 计算机不承认这样的写法！！！ ERROR
/*
条件:
写出判断是否是英文小写写字母的条件
在使用字符常量时，请使用字符本身
*/
char ch; // 申明一个变量
ch >= 'a' && ch <= 'z';
/*
条件:
写出判断是否是英文字母的条件
*/
char ch;
(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z';
/*
以上两种写法结果一致
按照Java规范的运算符优先级问题，&& 高于 ||
使用小括号是将条件作出一个整体！！！便于阅读和整理思路
*/
/*
闰年问题:
1. 能被4整除，但是不能被100整除
2. 能被400整除
*/
int year;
// 能被4整除
year % 4 == 0;
// 不能被100整除
year % 100 != 0;
// 能被400整除
year % 400 == 0;
// 以上三个条件如何组合？
(year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
/*
加上小括号是一个整体，增强阅读性！！！
*/
小练习
1. 写出判断【数字字符】的条件
2. 写出判断数值0 ~ 9的条件
3. 代码阅读
int num = 5;
int ret = num++ - num++;
ret ? num ?
4. 代码阅读
int num = 10;
int ret = ++num % num–;
ret ? num?
5. 代码阅读
int num1 = 10;
int num2 = 20;
int ret = num1 % num2;
ret = ?
ret = num1 / num2;
ret = ?