JavaSE学习day2_03, 算数运算符

5. 算术运算符

5.1 分类：

+ - * / % 

5.2 细节：

1.运算规则。跟小学数学是一模一样的

2.如果是整数跟整数进行计算，结果只能是整数。直接去掉小数部分，保留整数。如5/2=2,而不是2.5.

3.如果想要结果中有小数，需要有小数参与计算。

4.只要有小数参与计算，那么结果是有可能不精确的

5.%，叫做取余或者取模，进行的也是除法运算，只不过获取的是余数。本文最后会细讲取模和取余的区别.

代码示例：

// %
//取余  取模
//跟除法一样，做的也是除法运算。
//除法 取的是商 取余取的是余数
System.out.println(10 / 3);//3
System.out.println(10 % 3);//1

%的使用场景：

1.我们可以利用%判断数字a是否可以被数字b整除。（掌握）

10 % 7 
看他的最终结果是不是0，如果结果为0，那么就表示10是7的倍数。
如果结果不是0，那么就表示10不是7的倍数。

2.我们可以利用%判断一个数字是奇数还是偶数。（掌握）

10 % 2
看他的最终结果是不是0，如果结果为0，表示10是偶数
如果结果是1，表示10是奇数。

3.我们还可以利用%去做游戏中的发牌（了解）

到了就业班还会再讲。

斗地主牌
1.我们可以把54张扑克牌都定义一个序号：1~54
2.拿着每一张牌的序号对3取模
如果结果为1，就把当前的牌发给第一个玩家。
如果结果为2，就把当前的牌发给第二个玩家。
如果结果为0，就把当前的牌发给第三个玩家。

5.3 练习

需求：

键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台

代码示例：

//对于任意的一个整数
//个位：数字 % 10
//十位：数字 / 10 % 10
//百位：数字 / 100 % 10
//千位：数字 / 1000 % 10
//万位：数字 / 10000 % 10
//...以此类推
​
​
//分析：
//1.键盘录入一个三位数，123
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = sc.nextInt();
System.out.println(number);
//2.将其拆分为个位、十位、百位后，打印在控制台
​
//number是什么？就是键盘录入的数字
//拿着键盘录入的数字跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int ge = number % 10;
​
//拿着键盘录入的数字先跟10相除，得到整数部分
//拿着得到的整数部分，再跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int shi = number / 10 % 10;
​
int bai = 456 / 100 % 10;
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);

6. 隐式转换(C语言中强制类型转换)

概念

取值范围小的，变成取值范围大的。

细节：

隐式转换是不需要我们自己单独写代码实现的。是由虚拟机帮我们自动完成的。

触发时机：

在实际开发中，什么时候用到这个知识点。

1.取值范围小的跟取值范围大的进行计算的时候，小的会先提升为大的，然后再进行计算。

2.byte, short, char 这三种类型在参与计算的时候，先提升为int，再进行计算。这是个超级重点!!!取值范围比int小的类型，在计算的时候。先直接提升为int。再进行计算。这里可以去比较一下C语言的内容.

小化大,不会错,自动转换

大化小,强制类型转换.

举例：

int a = 10;
double b = a;
//不会报错
//就是把一个取值范围小的，变成取值范围大的。
//把小的给大的不会报错，可以直接给。
//提升的时候，实际提升的不是变量a，而是变量a里面的数据10.

int a = 10;
long n = 100L;
??? result = a + n;
//问：result 是什么数据类型？long
//数据类型不一样，不能直接进行计算
//需要转成一样的才能进行计算。
//把变量a里面的数据10，提升为long类型的
//实际上，最终就是两个long类型的数据进行计算。
//最终的结果result就是long类型的

int a = 10；
long n = 100L;
double d = 20.1;
??? result = a + n + d;
//问：result 是什么数据类型？double
//数据类型不一样，不能直接进行计算
//需要转成一样的才能进行计算
//第一步：是a + n 类型不一样，变量a里面的数据先变成long，进行计算
//       a + n 的结果是long类型的、
//第二步：long + double。需要继续提升，最终提升为double
//所以，最终的结果就是double类型。

byte b1 = 10；
byte b2 = 20；
??? result = b1 + b2;
//问：result 是什么数据类型？int
//取值范围比int小的类型，在计算的时候。先直接提升为int。再进行计算。
//b1和b2里面的数据，在进行计算的时候，先提升为int，再进行计算
//所以，结果为int。

7. 强制转换

核心：

把一个取值范围大的，交给取值范围小的。

在代码中，不能直接给，如果一定要这么干，就需要加入强制转换。

格式：

因为这个操作，不是虚拟机帮我们进行的，需要我们自己写代码实现。

简单理解：想要转成什么类型，就在前面的小括号中，写什么类型即可。

目标数据类型 变量名 = （目标数据类型）待转换的数据。

细节：

强制转换，有可能导致数据发生改变。

举例：

double a = 12.3;
int i = (int)a;//i=12

byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
//第三行代码是报错的，因为等号的右边最终结果为int类型
//而把大的给小的，是不能直接给的，会报错。
//所以我们可以加入强制转换
​
//错误的。此时强转的是b1.
byte b3 = (byte)b1 + b2;
​
//错误的。此时强转的仅仅是b1,相加后仍然是int类型.
//就算转完了，他们在再次相加计算的时候，还会变成int类型
byte b3 = (byte)b1 + (byte)b2;
​
//正确的。先计算小括号中的b1 + b2 ，得到一个int类型的结果
//然后再把int类型的结果转换成byte类型
byte b3 = (byte)(b1 + b2);

8. 字符串的加操作

规则1：

在+的过程中，如果有字符串参与计算，那么此时+就不是算术运算符了，而是字符串的拼接符。会把数据进行拼接，并产生一个新的字符串。

规则2：

如果有多个+连续存在，从左到右依次计算，如果没有字符串，就是普通的算术运算符。

如果有字符串参与，就是拼接。

规则3：

如果字符串跟变量进行拼接，是拿着变量里面的数据跟字符串进行拼接。

但是变量不能用双引号引起来。

规则4：

字符串只有相加操作，没有减，乘，除，取模操作

举例：

"123" + 123  结果："123123"

123 + 123 + "123" 结果："246123"//从左到右依次计算拼接

int age = 18;
//如果字符串跟变量进行拼接，是拿着**变量里面的数据**跟字符串进行拼接。
sout("我的年龄是" + age + "岁");//我的年龄是18岁
//此时是三个字符串进行拼接
sout("我的年龄是" + "age" + "岁");//我的年龄是age岁

System.out.println(1 + 2 + "abc" + 2 + 1);//3abc21
//当连续+的时候，从左到右依次计算的，如果有字符串就是拼接
//如果没有字符串，就是相加。
//第一步：1 + 2 结果3
//第二步：3 + "abc" 结果"3abc"
//第三步："3abc" + 2 结果"3abc2"
//第四步："3abc2" + 1 结果"3abc21" 

用法：

可以让我们的变量在展示的时候，更加有意义。

//分析：
//1.键盘录入一个三位数，123
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = sc.nextInt();
System.out.println(number);
//2.将其拆分为个位、十位、百位后，打印在控制台
​
//number是什么？就是键盘录入的数字
//拿着键盘录入的数字跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int ge = number % 10;
​
//拿着键盘录入的数字先跟10相除，得到整数部分
//拿着得到的整数部分，再跟10进行取余的计算。
//把得到的余数赋值给左边的变量
int shi = number / 10 % 10;
​
int bai = number / 100 % 10;
System.out.println("个位是:" + ge);
System.out.println("十位是:" + shi);
System.out.println("百位是:" + bai);

9. 字符的加操作

ASCII码表：

在这张码表中，字符跟数字有一个一一对应的关系。

'a' --- 97

'A' --- 65

规则：

当字符加字符 或者 字符加数字的时候，此时字符会到ASCII码表中找对应的数字，然后再进行计算。

注意点：

当字符跟字符串参与计算的时候，做的是拼接操作。

代码示例：

char c = 'a';
int result = c + 0;//97
//先拿着字符a到码表中查，查到了数字97，再跟0进行计算，结果就是97.

char c = 'a';
System.out.println("ABC" + c);//ABCa

10. 自增自减运算符

基本用法：（掌握）

不管是写在前面，还是写在后面，只要单独写一行，结果就是一样的。

代码示例：

int a = 1;
​
//后++
a++;//把变量里面的值+1，执行完毕之后，变量里面的值就是2
System.out.println(a);//2
​
//先++
++a;//把变量里面的值+1，执行完毕之后，变量里面的值就是3
System.out.println(a);//3
​
//后--
a--;
System.out.println(a);//2
​
//先--
--a;
System.out.println(a);//1

扩展用法：（了解）

先++和后++，以后在实际开发中，我们基本上都是单独写成一行的。

如果实际参与了计算，一般在代码里面是不会写的。

运算规则：

先++：

先加后用

int a = 1;
int b = ++a;
// 先把变量a的值1，自增变成2.
// 再把2拿出来使用，赋值给变量b
所以，程序运行完毕之后，a为2，b为2

后++：

先用后加

int a = 1;
int b = a++; 
// 先把变量a的值进行使用，赋值给变量b
// 然后变量a再进行自增
所以，程序运行完毕之后，a为2，b为1

面试题举例：

public class Test {
    public static void main(String[] args) {
        int x = 10;
        int y = x++;//10
        //后++，先用后加
        //先把x的值10拿出来用，赋值给y，然后x再进行自增变成11
        //当这行代码执行完毕之后，x = 11 y = 10
       
         int z = ++x;//12
        //先++，先加后用
        //先把x的值进行自增，变成12，再把自增之后的值拿出来用。赋值给z
        //当这行代码执行完毕之后，x = 12 z = 12    
        
        //因为x自增了两次就是12
        System.out.println("x:" + x);//12
        System.out.println("y:" + y);//10
        System.out.println("z:" + z);//12
    }
}

应用场景一：

当过生日的时候，记录age的变量要自增。

变量在合适的时候需要自增一次。

应用场景二：

商城项目中的购物车，也需要用到自增，自减运算符。

应用场景三：

统计数量的时候。

在一开始，我们可以定义一个变量记录0

把所有参与统计的数据，一个一个进行对比，如果满足，变量就自增一次。

当所有参与统计的数据全部统计完毕，那么变量就表示最终的次数。

举例：

1 ~ 100 之间有多少个偶数？

代码中，我们可以从1开始去数到100。如果遇到一个偶数，那么统计的变量就需要自增一次。

当100个数全部统计完毕之后，变量的值就是最终的结果。

具体的代码我们会在后面学习完循环的时候写，现在知道一下应用场景即可。

11. 赋值运算符

分类：

符号	说明
=	把等号的右边赋值给左边。int a = 10;
+=	把左边和右边进行相加，结果赋值给左边，对右边没有任何影响。
-=	把左边和右边进行相减，结果赋值给左边，对右边没有任何影响。
*=	把左边和右边进行相乘，结果赋值给左边，对右边没有任何影响。
/=	把左边和右边进行相除，结果赋值给左边，对右边没有任何影响。
%=	把左边和右边进行相除，把余数赋值给左边，对右边没有任何影响。

代码示例：

//赋值运算符
//基本的赋值运算符 =
​
//其他赋值运算符
//+= -= *= /= %=
//以+=为例
int a = 10;
int b = 20;
//就表示把左右进行相加，把结果赋值给左边的，对右边没有任何影响
//相当于 a = a + b;
a += b;
System.out.println(a);//30
System.out.println(b);//20

扩展点：（了解）

+=、-=、*=、/=、%= 在底层隐藏了强制类型转换

代码示例：

byte b1 = 10;
byte b2 = 20;
b1 += b2;
//相当于：b1 = (byte)(b1 + b2)这个容易出错.

如下：

这是底层隐藏了 强制类型转换。

而下面这样就会报错：

 这是因为最终结果为int类型，是不能赋值给byte类型的。

12. 比较运算符

概念：

比较运算符，又叫做关系运算符，其实就是做了一个判断而已。

分类：

==：判断左右是否相等
!=：判断左右是否不相等
>:判断左边是否大于右边
>=：判断左边是否大于等于右边
<：判断左边是否小于右边
<=：判断左边是否小于等于右边

注意点：

关系运算符的结果只能是布尔类型的，要么是true，要么是false。在后面实际开发中，我们会根据两种情况来执行不同的代码。

用户登录，正确true，登录成功

错误false，登录失败

==千万不能写成一个=

练习：

需求：

您和您的约会对象在餐厅里面正在约会。 ​ 键盘录入两个整数，表示你和你约会对象衣服的时髦度。（手动录入0~10之间的整数，不能录其他） ​ 如果你的时髦程度大于你对象的时髦程度，相亲就成功，输出true。 ​ 否则输出false。

代码示例：

//分析：
//1.键盘录入两个整数
Scanner sc = new Scanner(System.in);
System.out.println("请输入你衣服的时髦度");
int fashtion1 = sc.nextInt();
System.out.println("请输入约会对象衣服的时髦度");
int fashtion2 = sc.nextInt();
//2.比较一下即可
boolean result = fashtion1 > fashtion2;
System.out.println(result);

取模和取余的区别:

先来看一些例子

1. 取模

   • 5 mod 3 = 2
   • -5 mod 3 = 1
   • 5 mod -3 = -1
   • -5 mod -3 = -2

2. 取余

   • 5 rem 3 = 2
   • -5 rem 3 = -2
   • 5 rem -3 = 2
   • -5 rem -3 = -2

 从上面的区别可以总结出，取余（rem）和取模（mod）在被除数、除数同号时，结果是等同的，异号时会有区别，所以要特别注意异号的情况。

经过测试，在C/C++, C#, JAVA, PHP这几门主流语言中，’%’运算符都是做取余运算，而在python中的’%’是做取模运算。

那么异号之间着呢嗯么计算?

我们发现取余运算异号时,余数总是跟被除数的符号保持一致.可以用他们用绝对值进行取余运算,然后符号保持跟被除数即可.而Python里的取模运算:取模运算的余数总是跟除数的符号保持一致。

若c=a%b;那么当a和b异号时，有如下结论：

做取余运算：

当 |a| > |b| 时，c=|a| - |b|

当 |a| < |b| 时， c=|a| 

做取模运算：

当 |a| > |b| 时，c=|b| - |a+b|

当 |a| < |b| 时， c=|a+b| 

很多人可能一直搞不懂这俩的区别，现在公式给你列出来了，不信你直接用java语言和python语言找几个数字测试一下即可。