小数运算经常出现精度丢失的问题,不建议使用基本类型运算.
示例：
public class Home4{
public static void main(String[] args){
double x=100.8;
double y=20.6;
double add=x+y;
double sub=x-y;
System.out.println("x+y的和为："+add);
System.out.println("x-y的差为："+sub);
}
}
输出：
x+y的和为：121.4
x-y的差为：80.19999999999999
【4】
1. 算数运算符
1.1 ++ 自身加1
1.2 -- 自身减1
语法：
变量名++ 或 ++变量名
变量名-- 或 --变量名
++放在前面和放在后面，是有先后顺序的，但是如果这行代码只有++，对于结果来说没有影响
示例：
public class Demo1{
public static void main(String[] args){
int i=10;
int j=i++;
System.out.println(i);
System.out.println(j);
int a=10;
int b=++a;
System.out.println(a);
System.out.println(b);
}
}
输出：
11
10
11
11
分析上面++过程【跟原先想的，可能不一样!!!】：
public class Demo1{
public static void main(String[] args){
int i=10;
int j=i++;//除了++运算之外，还有一个赋值运算
//① 肯定是运算i++
// a. 将i的值赋值给i++这个整体
// b. 在将i的值进行自增
//② 在进行赋值
// 将i++的值赋给了j,所以j的结果是10
// ++在后面，是先赋值在自增
// ① 将i的值赋给j ② i在自增 错误的
// ① 将i的值赋给i++ ② i在自增 ③ 将i++的值赋给j 正确的
// i 和 i++ 是两码事！
System.out.println(i);//11
System.out.println(j);//10
int a=10;
int b=++a;
//++放在前面，得到的结论是 先自增在赋值
//① 先进行a的自增 ② 将a的值赋值给++a ③ 将++a的值赋给b
System.out.println(a);//11
System.out.println(b);//11
}
}
//排除你之前的思想，下面再来验证一下
示例：
public class Demo2{
public static void main(String[] args){
int i=10;
i=i++;
System.out.println(i);
}
}
输出：
10
分析上面++过程
public class Demo2{
public static void main(String[] args){
int i=10;
i=i++;
//先赋值在自增
// 我的思想： ① 将i的值赋值给i++ ② i在自增 ③ 将i++的值赋值给i
// 之前的思想： ① 将i的值赋值给i ② i在自增 错误的
System.out.println(i); //10
/*
额 那这样的话，如果一直循环输出的话，是不是i一直都是10？ 对的
int j = (a+b)++ 可以吗? 不可以【因为：++前后需要是变量名】
不是，第二种方法是先将i赋值给j如果i，结果是10，然后i自增前边的i
i==i++ 判断i和i++是否相等？ 是相等的
j=++（i++） 不可以的
先将i赋值给i，结果是10，然后i自增前边的i
i++后的i不是11吗，再执行i++赋值此时不应该是11吗？
如果按照第二种思想i的值应该是11，但是结果是10
*/
int a=10;
System.out.println(a==a++);
//int j=++(i++); //报错
}
}
练习：
1. int i=10; int k=i++ + i; int m=i++ - i + i++;
System.out.println(i);
System.out.println(k);
System.out.println(m);
练习解答：
public class Test1{
public static void main(String[] args){
int i=10;
int k=i++ + i; //【注：+ i 时，会去取当前i的值，无论前++ 或 后++，即取自增后的值】
/*
① 将i的值赋值给i++ i=10 i++=10
② i会自增 i=11 i++=10
③ i++ + i = 10 + 11 =21
④ 将21赋值给k k=21
*/
int m=i++ - i + i++; //i=11
/*
① 将i的值赋值给i++ i=11 i++=11
② i会自增 i=12 i++=11
③ i++ -i 11 - 12 = -1
④ 将i的值赋值给i++ i=12 i++=12
⑤ i会自增 i=13 i++=12
⑥ -1 + 12 =11
⑦ 将11赋值给m m=11
*/
System.out.println(i);//13
System.out.println(k);//21
System.out.println(m);//11
}
}
输出：
13
21
11
2. 赋值运算符(了解)
= += -= *= /= %=
2.1 = ★
等号右侧的值赋给左侧的内容(变量)
2.2 += -= *= /= %=
在原变量值的基础上做相应的操作，将结果在赋值给该变量
3. 关系(比较运算符)运算符
比较运算符的结果是一个布尔值(只有两个结果true false)
3.1 > >= < <=
可以进行比较的数据类型有 byte short int long float double char
3.2 == 判断两个值是否相等
任意类型都可以采用==做对比，但是前后类型要兼容
3.3 != 判断两个值是否不相等
任意类型都可以采用!=做对比，但是前后类型要兼容
4. 逻辑运算符
4.1 并且 两个条件都成立总体才成立，否则总体就不成立
① && 双与(短路与)
会造成短路--> 当第一个条件不成立的时候，总体就已经不成立了，不在判断第二个条件
② & 单与
第一条件是不成立时，第二个也需要判断(需求需要执行)
4.2 或者 两个条件都不成立，总体就不成立，否则总体就是成立
① || 双或(短路或) --> 当第一个条件成立的时候，总体就已经成立了
② | 单或
4.3 非
① ! 取反
4.4 异或(了解)
^ 相同为false，不同为true
true ^ true 相同
false ^ false 相同
true ^ false 不同
false ^ true 不同
【8】
布尔值不能参与数值型的比较运算（跟布尔值不能参与数值运算是一致的）
"j"+"a"+"v"+"a"=="java" 暂时不讲(涉及到内存) 专门讲String
示例：
public class Demo5{
public static void main(String[] args){
int a=50;
int b=10;
System.out.println(a++>50 & b++>5);//false
System.out.println(b);//10 11
int i=20;
int j=30;
System.out.println(i++>10 | j++>10);
System.out.println(j);//30
System.out.println(!(i>10));
System.out.println("------------------------------");
System.out.println(i>10 ^ j>10);//结果？相同为false
System.out.println(i>100 ^ j>100);//结果？相同为false
System.out.println(i>100 ^ j>10);//结果？不同为true
System.out.println(i>10 ^ j>100);//结果？不同为true
System.out.println(i ^ j);//此时的^是位运算符，不是异或
}
}
输出：
false
11
true
31
false
------------------------------
false
false
true
true
10
5. 三元运算符
语法： 条件?值1:值2;
原理：条件成立返回值1，条件不成立返回值2！
6. 位运算符(了解) 和二进制有关 后面会有详细讲解(偏难)
因为我们在学习集合的时候，源码内会有相关的位运算符，能看懂
左移：<<
运算规则：左移几位就相当于乘以2的几次方
右移：>>
运算规则：右移几位就相当于除以2的几次方
练习：
1. 随机生成一个10000内的整数，判断该数字是否能被7或者3整除！
输出true或者false!
【13】
示例：
public class Demo2{
public static void main(String[] args){
short s=10;//直接赋值，默认是可以转化
//s=s+5;//有运算，类型会提升，5默认是int值，所以s+5结果是int
s+=5;//默认是可以转化的
System.out.println(s);
}
}
7. 流程控制
7.1 顺序结构
程序是按照顺序执行的(从上往下)
① 输出
输出语句，从上往下依次执行
② 输入(在实际工作中没有用处)
用途：为了一些练习使用
功能：在命令窗口输入一些数据，被程序获取！
知识点范围：属于面向对象
关注点：实现步骤
步骤：
a. 准备一个输入的工具
java.util.Scanner input=new java.util.Scanner(System.in);
b. 准备输入入口
nextInt() 整型数据输入的入口
nextDouble() 浮点型数据的输入入口
next() 字符串数据的输入入口
只能取空格前面的内容
nextLine() 字符串数据的输入入口
读取一行，空格也算
建议使用next()，输入的数据不要有空格
注意事项：
java.util.InputMismatchException 输入的数据和类型不匹配
练习：
1. 手动输入自己的个人信息，姓名、年龄、身高、手机号码、地址...
输入完毕后，在展示数据！
2. 手动输入一个四位数字，求出各位之和！
7.2 分支结构和选择结构 ★
分支结构：
① 单分支
举例：手动输入小明的java成绩，如果成绩高于90，奖励假发一顶
语法：if(条件){代码块}
原理：如果条件成立，则执行代码块，如果条件不成立则不执行代码块
特性：
a. 当if后大括号中只有一行代码的时候，大括号可以省略的
这行代码不能是变量的声明(做完练习后在解释)
b. if是可以嵌套的，if的大括号就可以写main方法大括号中的任意代码
补充：
变量的作用域：是在当前大括号
② 双分支
举例：手动输入小明的java成绩，如果成绩高于90，奖励假发一顶
否则在敲2万行代码
语法：if(条件){代码块1}else{代码块2}
原理：条件成立执行代码块1，条件不成立执行代码块2
特性：
a. if和else后的大括号中只有一行代码的时候，大括号可以省略的
这行代码不能是变量的声明(做完练习后在解释)
b. 大括号是可以嵌套的
③ 多分支
举例：手动输入小明的java成绩，如果成绩满分，奖励植发一次
如果成绩高于90，奖励假发一顶，
如果成绩高于80，奖励洗头膏一袋，
如果成绩大于60，奖励洗面奶一瓶，
否则在敲2万行代码
语法：if(条件1){代码块1}
else if(条件2){代码块2}
else if(条件3){代码块3}
...
【else{代码块n}】
原理：判断条件1是否成立，如果成立，执行代码块1，多分支结束
如果条件1不成立，就会判断条件2，如果成立的，执行代码块2，多分支结束
如果条件2不成立，就会判断条件3，如果成立的，执行代码块3，多分支结束
...
如果所有的条件都不成立，则执行代码块n(存在else的情况下)
选择结构：
语法：
switch(变量名){
case 值1:
代码块1;
【break;】
case 值2:
代码块2;
【break;】
case 值3:
代码块3;
【break;】
...
【default:
代码块n;
break;】
}
原理：判断变量的值和值1是否相等，如果相等，则执行代码块1，
执行完之后，开始寻找break(才是结束switch的标识)
如果不相等，则判断变量和值2是否相等，如果相等，则执行代码块2，
执行完之后，开始寻找break(才是结束switch的标识)
如果不相等，则判断变量和值3是否相等，如果相等，则执行代码块3，
执行完之后，开始寻找break(才是结束switch的标识)
变量如果和所有值都不一样，则执行default中的代码块n
注意：
a. case后的值不能相同
b. case的穿透（下坠）
c. switch结束，要么执行完毕，要么遇到break
d. switch都支持什么数据类型
byte short int char String(JDK1.7新增) 枚举(后面会讲到)
示例：
public class Demo4{
public static void main(String[] args){
char num='a'; //97
switch(num){
case 96:
System.out.println("969696");
break;
case 97:
System.out.println("aaaaaa");
case 98:
System.out.println("穿透到98");
}
}
}
输出：
aaaaaa
穿透到98
7.3 循环结构 (难点) ★
7.4 跳转结构 ★
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
