DAY07
DAY07
2)运算符
运算符：
就是对常量或者变量进行操作的符号。
比如： + - * /
表达式：
用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。
比如：a + b 这个整体就是表达式。
而其中+是算术运算符的一种，所以这个表达式也称之为算术表达式。
1.算数运算符
+ 加 - 减 * 乘 / 除 % 取模 取余
ackage com.scuec.Arithmeticoperator;
public class ArithmeticoperatorDemo01 {
public static void main(String[] args) {
// +加
System.out.println(3 + 2 );
//-减
System.out.println(5-1);
//*乘
System.out.println(2*10);
// /除
//1.整数参与运算,结果只能得到整数
/*2.小数参与运算,结果有可能是不精确的,
如果我们需要精确运算,那么需要用到后面的知识点
*/
System.out.println(20 / 10);
System.out.println(10 / 3);
System.out.println(10.00 / 3);
// %取模 取余
System.out.println(20 % 10);
System.out.println(5 % 2);
//取模应用场景:
/*1.可以用取模来判断,a是否能被b除尽
2.可以判断a是否为偶数
3.制作斗地主小程序
桑格玩家,把每张牌定义为某一序号,
该序号 % 3余1,发给第一个玩家
该序号 % 3余2,发给第二个玩家
该序号 % 3余0,发给第三个玩家
*/
//如果运算中有小数出现
//在代码中如果有小数参与运算,结果可能是不精确的
System.out.println(2.5 + 2.5);
System.out.println(20.1 - 0.1);
System.out.println(10.12 - 15.1);
}
}
小练习:数值拆分
键盘录入一个三位数,将其拆分为个位 十位 百位后,打印在控制台
公式总结:
个位:数值%10
十位:数值 / 10%10
百位:数值 / 100%10
千位:数值 / 100%10
import java.util.Scanner;
public class ArithmeticperatorTest01 {
//键盘录入
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数字");
int number = sc.nextInt();
//获取个位十位百位
int a = number %10;
int b = number /10 %10;
int c = number /100%10;
//输出个位十位百位
System.out.println("个位为" + a);
System.out.println("十位为" + b);
System.out.println("百位为" + c);
}
}
数字相加
类型转换:数字在进行运算时,数据类型不一样的不能运算,需要转成一样的,才能运算
1)隐式转化(自动类型提升)
把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的。
double>float>long>int>short>byte
int a = 10;
double b = a;
//此时b=10.0(系统自动实现)
两种提升规则：
1.取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。
2.byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。
2)强制转换
如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作。如果一定要这么干，就需要加入强制转换。
格式：目标数据类型 变量名 = （目标数据类型）被强转的数据
简单理解： 要转成什么类型的，那么就在小括号中写什么类型就可以了。
public class OperatorDemo2 {
public static void main(String[] args) {
double a = 12.3;
int b = (int) a;
System.out.println(b);//12
}
}
public class ArithmeticoperatorDemo03{
public static void main(String [] args){
byte a = 10;
byte b = 10;
byte result =(byte)(a+b);
System.out.println(result);
}
}
注意点：
强制转换有可能会导致数据发生错误。（数据的精度丢失）
字符串相加
1.当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
2.当连续进行+操作时，从左到右逐个执行的。
字符相加
当出现1) 字符 + 字符 2)字符 + 数字 时，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。
只要记住65是A，97是a就可以了，其他的可以推
2.自增自减运算符
++：就是把变量里面的值+1
--：就是把变量里面的值-1
int a = 10;
++a;
System.out.println(a);//11
单独使用: ++和-- 既可以放在变量的前边,也可以放在变量的后边.单独写在一行的时候，运算结果是一模一样的。
参与计算:用得少
int a = 10;
int b = a++;
//a = 11, b = 10
//先用后加
int a = 10;
int b = ++a;
//a = 11,b = 11
//先加后用
3.赋值运算符
最为常用的： =
运算过程：就是把等号右边的结果赋值给左边的变量
扩展赋值运算符: +=、-=、*=、/=、%=
就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。
public class AssigningoperatorDemo1{
public static void main(String[] args){
//+=
int a = 10;
int b = 20;
//相当于 a = a + b
a +=b;
System.out.println(a);//30
System.out.println(b);//20
//细节:
//+= -= /= %=,底层都隐藏了一个强制类型转化
short s = 1;
/*相当于 s = (short)(s+1)*/
s +=1;
Sstem.out.println(s);
}
}
4.关系运算符
又叫比较运算符，其实就是拿着左边跟右边进行了判断而已。
| 符号 | 解释 |
|---|---|
| == | 就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false |
| != | 就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false |
| > | 就是判断左边是否大于右边，如果成立就是true，如果不成立就是false |
| >= | 就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false |
| < | 就是判断左边是否小于右边，如果成立就是true，如果不成立就是false |
| <= | 就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false |
注意点：
- 关系运算符最终的结果一定是布尔boolean类型的。要么是true，要么是false
- 在写==的时候，千万不要写成=
public class ComperaoperatoeDemo{
public static void main(String[] args){
//==判断左右是否相等
int a = 10;
int b = 10;
int c = 20;
System.out.println(a==b);//true
System.out.println(a==c);//false
}
}
//您和您的约会对象在餐厅里面正在约会。
/*键盘录入两个整数，表示你和你约会对象衣服的时髦度。（手动录入0~10之间的整数，不能录其他）
如果你的时髦程度大于你对象的时髦程度，相亲就成功，输出true。
否则输出false。*/
public class Test02{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入自己衣服的时髦度");
int myFashion = sc.nextInt();
System.out.println("请输入约会对象衣服的时髦度");
int girlFashion = sc.nextInt();
System.out.println(myFashion > girlFashion)
}
}
5.逻辑运算符
&：逻辑与（而且）
两边都为真，结果才是真，只要有一个为假，那么结果就是假。
|：逻辑或（或者）
两边都为假，结果才是假，只要有一个为真，那么结果就是真。
// &
//两边都是真，结果才是真。
System.out.println(true & true);//true
System.out.println(false &false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false
// | 或
//两边都是假，结果才是假，如果有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true
使用场景：
1)用户登录。
用户名输入正确 & 密码输入正确
因为只有用户名和密码同时都正确了，那么才能成功登录，只要有一个失败了都不行。
使用技巧：
当我们需要同时满足左边和右边两种情况时，可以使用且
2)丈母娘选女婿
丈母娘：女婿啊，你要么买个房子，要么买辆车。就可以把我的小棉袄穿走了。
买个房子 | 买辆车
两个条件中，只要满足其中一个，就可以穿走小棉袄了。
使用技巧：
当两种条件只要满足其中一个的时候，可以使用或
^（异或）的使用：
如果两边相同，结果为false，如果两边不同，结果为true
//^
//左右不相同，结果才是true，左右相同结果就是false
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
!（取反）的使用：
取反，也叫做非。
false取反就是true，true取反就是false
温馨提示：取反最多只用一个。
System.out.println(!false);//true
System.out.println(!true);//false
System.out.println(!!false);//注意点：取反最多只用一个。
短路逻辑运算符
&&：运算结果跟&是一模一样的，只不过具有短路效果。
||：运算结果跟|是一模一样的。只不过具有短路效果。
逻辑核心：
当左边不能确定整个表达式的结果，右边才会执行。
当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。
举例：
1)用户登录案例
用户名正确 & 密码正确
如果使用一个&，不管用户名是否正确都会去验证密码。
思考：
如果用户名输入正确了，那么我们再判断密码是否正确，是符合业务逻辑的。
但是如果用户名输入错误了，那么现在还有必要去比较密码吗？没有不要了。
如果使用一个&，那么左边和右边不管什么情况下，都会执行。
用户名正确 && 密码正确
如果用户名输入正确了，那么才会验证密码是否输入正确。
如果用户名输入错误了，那么就不会再去验证密码是否正确，最终的结果直接为false。从而提高了程序运行的效率。
2)丈母娘选女婿
有房 | 有车
首先先看看有没有房，发现有，然后再去看看有没有车。
思考：
既然都有房子，干嘛还要去看车呢？多此一举。
有房 || 有车
首先先看看有没有房，如果有，那么右边就不执行了。最终的结果直接为true。
如果没有房子，才会去看右边有没有车。
总结：
&& 和 & 、||和|的运行结果都是一模一样的。
但是短路逻辑运算符可以提高程序的运行效率。
建议：最为常用： && || ！
如:
int a = 10;
int b = 10;
boolean result = ++a<5 && ++b<5;
System.out.println(result);//false
System.out.println(a);//11
System.out.println(b);//10
小练习:
/*数字6是一个真正伟大的数字，键盘录入两个整数。
如果其中一个为6，最终结果输出true。
如果它们的和为6的倍数。最终结果输出true。
其他情况都是false.*/
public class Test3{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number1 = sc.nextInt();
System.out.println("请输入第二个整数");
int number2 = sc.nextInt();
boolean result = number1 == 6 || number2 == 6|| (number1 + number2)%6==0;
System.out.println(result);
}
}
6.三元运算符
当需要定义一个变量记录两个整数的较大值时,三元运算符可以进行判断,根据判断的结果得到不同的内容
格式：关系表达式 ？ 表达式1 ：表达式2 ；
public class TernatyoperatorDemo1 {
public static void main(String[] args) {
int number1 = 10;
int number2 = 20;
int result = number1 > number2 ? number1 : number2;
System.out.println(result);
System.out.println(number1 > number2 ? number1 : number2);
int result2 = number1 < number2 ? number1 : number2;
System.out.println(result2);
}
}
import java.util.Scanner;
public class Test4 {
/*需求：动物园里有两只老虎，体重分别为通过键盘录入获得，
请用程序实现判断两只老虎的体重是否相同。*/
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
System.out.println("请输入第一只老虎的体重");
int tiger1 = sc.nextInt();
System.out.println("请输入第二只老虎的体重");
int tiger2 = sc.nextInt();
System.out.println(tiger1==tiger2?"相同":"不同");
}
}
import java.util.Scanner;
public class CompareWeight {
public static void main(String[] args) {
/*需求：一座寺庙里住着三个和尚，已知他们的身高
分别为150cm、210cm、165cm，
请用程序实现获取这三个和尚的最高身高。*/
/*在此联系基础上,我想再加一下,键盘录入,
分别输入三个和尚的任意身高,直接得出最高身高的和尚
*/
Scanner sc = new Scanner (System.in);
System.out.println("请输入第一个和尚的身高");
int height1 = sc.nextInt();
System.out.println("请输入第二个和尚的身高");
int height2 = sc.nextInt();
System.out.println("请输入第三个和尚的身高");
int height3 = sc.nextInt();
int result1 = height1>height2? height1:height2;
int result2 = result1>height3? result1:height3;
System.out.println("最高身高:" + result2);
}
}
7.运算符优先级
在Java中涉及了很多的运算符，每一种运算符都有各自的优先级。但是这些优先级不需要记忆。
咱们只要知道其中一点：
小括号优先于所有。
8.原码&反码&补码
原码:
十进制数据的二进制表现形式,最左边的是符号位,0为正,1为负
如:56→0011100, 其中最左边的"0"是符号位,
"0"或者"1"叫做一个bit(比特位),八个bit是一个字节
一个字节:最大值为01111111(二进制为127);最小值为11111111(二进制为-127)
but,利用原码进行计算的时候,如果是正数完全没有问题,但如果是负数计算,结果就出错,实际运算的方向,跟正确的运算方向是相反的
反码:
为了解决原码不能计算负数的问题而出现的
正数的反码不变,负数的反码在原码的基础上,符号位不变.数值取反,0变1,1变0
but,负数运算时,如果结果不跨0,是没有问题的,但出现跨零的情况结果就会有1的偏差,因为"0"有两种表现形式
于是补码运应而生↑
正数的原码 反码 补码都是一样的
多出来一位,所以一个字节的范围为+127到-128
补码:
为了解决负数计算时跨0的问题而出现的
正数的补码不变,负数的补码在反码的基础上加1
注意:计算机中的存储和计算都是以补码的形式进行的
补充:
基本数据类型:
如:
byte类型下的10:占一个字节 0000 1010
short类型下的10:占两个字节 0000 0000 0000 1010
int类型下的10:占四个字节 0000 0000 0000 0000 0000 0000 0000 1010
long类型下的10:占八个字节 ...64个比特位
隐式转化:
byte a = 10;//0000 1010
int b = a;//四个字节,32个比特位
强制转化:
int a = 300;//四个字节,32个比特位
//a=0000 0000 0000 0000 0000 0001 0010 1100
byte b = (byte)a;
//此时强行删去前24个字节
//b= 0010 1100
System.out.println(b);
左移一次相当于*2 ;左移几次 = *2的几次方;
右移一次相当于/2 ;右移几次 = /2的几次方;
无符号右移相当于在右移的基础上,把负数变为正数
浙公网安备 33010602011771号