目录
一、类型转换
1.隐式转换
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的,直接书写即可
double num = 10; // 将int类型的10直接赋值给double类型
System.out.println(num); // 输出10.0
注意:1.整数默认是int型,byte、short和char类型数据参与运算均会自动转换为int类型。
2.boolean类型不能与其他基本数据类型相互转换。
2.强制转换
强制类型转换:把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。
强制类型转换格式:目标数据类型 变量名 = (目标数据类型)值或者变量;
double num1 = 5.5;
int num2 = (int) num1; // 将double类型的num1强制转换为int类型
System.out.println(num2); // 输出5(小数位直接舍弃)
常量优化机制:
在编译时,整数常量的计算会直接算出结果,并且会自动判断该结果是否在byte取值范围内,
在:编译通过
不在:编译失败
二、运算符
1.算术运算符
运算符:对常量或者变量进行操作的符号
表达式:用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
不同运算符连接的表达式体现的是不同类型的表达式。
符号 | 作用 | 说明 |
---|---|---|
+ | 加 | 参看小学一年级 |
- | 减 | 参看小学一年级 |
* | 乘 | 参看小学二年级,与“×”相同 |
/ | 除 | 参看小学二年级,与“÷”相同 |
% | 取余 | 获取的是两个数据做除法的余数 |
注意:
-
/和%的区别:两个数据做除法,/取结果的商,%取结果的余数。
-
整数操作只能得到整数,要想得到小数,必须有浮点数参与运算。
2.字符的“+”
char类型参与算术运算,使用的是计算机底层对应的十进制数值。三个字符对应的数值:
'a' -- 97 a-z是连续的,所以'b'对应的数值是98,'c'是99,依次递加
'A' -- 65 A-Z是连续的,所以'B'对应的数值是66,'C'是67,依次递加
'0' -- 48 0-9是连续的,所以'1'对应的数值是49,'2'是50,依次递加
// 可以通过使用字符与整数做算术运算,得出字符对应的数值是多少
char ch1 = 'a';
System.out.println(ch1 + 1); // 输出98,97 + 1 = 98
char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66,65 + 1 = 66
char ch3 = '0';
System.out.println(ch3 + 1); // 输出49,48 + 1 = 49
算术表达式中包含不同的基本数据类型的值的时候,整个算术表达式的类型会自动进行提升。
提升规则:
byte类型,short类型和char类型将被提升到int类型,不管是否有其他类型参与运算。
整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型
等级顺序:byte,short,char --> int --> long --> float --> double
byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2; // 该行报错,因为byte类型参与算术运算会自动提示为int,int赋值给byte可能损失精度
int i3 = b1 + b2; // 应该使用int接收
byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
-------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收,因为num1会自动提升为double类型
3.字符串的+操作
当“+”操作中出现字符串时,这个”+”是字符串连接符,而不是算术运算。
4.数值拆分应用
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// 1:使用Scanner键盘录入一个三位数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int num = sc.nextInt();
// 2:个位的计算:数值 % 10
int ge = num % 10;
// 3:十位的计算:数值 / 10 % 10
int shi = num / 10 % 10;
// 4:百位的计算:数值 / 100
int bai = num / 100;
// 5:将个位, 十位, 百位拼接上正确的字符串, 打印即可
System.out.println("整数"+num+"个位为:" + ge);
System.out.println("整数"+num+"十位为:" + shi);
System.out.println("整数"+num+"百位为:" + bai);
}
}
5.自增自减运算符
符号 | 作用 | 说明 |
---|---|---|
++ | 自增 | 变量的值加1 |
-- | 自减 | 变量的值减1 |
单独使用的时候, ++和-- 无论是放在变量的前边还是后边,结果是一样的。
参与操作的时候,如果放在变量的后边,先拿变量参与操作,后拿变量做++或者--。
参与操作的时候,如果放在变量的前边,先拿变量做++或者--,后拿变量参与操作。
6.赋值运算符
赋值运算符的作用是将一个表达式的值赋给左边,左边必须是可修改的,不能是常量。
符号 | 作用 | 说明 |
---|---|---|
= | 赋值 | a=10,将10赋值给变量a |
+= | 加后赋值 | a+=b,将a+b的值给a |
-= | 减后赋值 | a-=b,将a-b的值给a |
*= | 乘后赋值 | a*=b,将a×b的值给a |
/= | 除后赋值 | a/=b,将a÷b的商给a |
%= | 取余后赋值 | a%=b,将a÷b的余数给a |
7.关系运算符
关系运算符有6种关系,分别为小于、小于等于、大于、等于、大于等于、不等于。
符号 | 说明 |
---|---|
== | a==b,判断a和b的值是否相等,成立为true,不成立为false |
!= | a!=b,判断a和b的值是否不相等,成立为true,不成立为false |
> | a>b,判断a是否大于b,成立为true,不成立为false |
>= | a>=b,判断a是否大于等于b,成立为true,不成立为false |
< | a<b,判断a是否小于b,成立为true,不成立为false |
<= | a<=b,判断a是否小于等于b,成立为true,不成立为false |
关系运算符的结果都是boolean类型,要么是true,要么是false。
8.逻辑运算符
逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式,以判断程序中的表达式是否成立,判断的结果是 true 或 false。
符号 | 作用 | 说明 |
---|---|---|
& | 逻辑与 | a&b,a和b都是true,结果为true,否则为false |
| | 逻辑或 | a|b,a和b都是false,结果为false,否则为true |
^ | 逻辑异或 | a^b,a和b结果不同为true,相同为false |
! | 逻辑非 | !a,结果和a的结果正好相反 |
9.短路逻辑运算符
符号 | 作用 | 说明 |
---|---|---|
&& | 短路与 | 作用和&相同,但是有短路效果 |
|| | 短路或 | 作用和|相同,但是有短路效果 |
在逻辑与运算中,只要有一个表达式的值为false,那么结果就可以判定为false了,没有必要将所有表达式的值都计算出来,短路与操作就有这样的效果,可以提高效率。同理在逻辑或运算中,一旦发现值为true,右边的表达式将不再参与运算。
-
逻辑与&,无论左边真假,右边都要执行。
-
短路与&&,如果左边为真,右边执行;如果左边为假,右边不执行。
-
逻辑或|,无论左边真假,右边都要执行。
-
短路或||,如果左边为假,右边执行;如果左边为真,右边不执行。
int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
System.out.println(x); // 4
System.out.println(y); // 5
System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false,右边不参与运算
System.out.println(x); // 4
System.out.println(y); // 4
10.三元运算符
三元运算符语法格式: 关系表达式 ? 表达式1 : 表达式2;
问号前面的位置是判断的条件,判断结果为boolean型,为true时调用表达式1,为false时调用表达式2。其逻辑为:如果条件表达式成立或者满足则执行表达式1,否则执行第二个。
11.位运算符-基本位运算符
位运算概述 : 位运算符指的是二进制位的运算,先将十进制数转成二进制后再进行运算。在二进制位运算中,1表示true,0表示false。
位运算符介绍:
public class Demo2 {
/*
位运算:
位运算符指的是二进制位的运算,先将十进制数转成二进制后再进行运算。
在二进制位运算中,1表示true,0表示false。
& 位与 : 遇false则false, 遇0则0
00000000 00000000 00000000 00000110 // 6的二进制
& 00000000 00000000 00000000 00000010 // 2的二进制
-----------------------------------------
00000000 00000000 00000000 00000010 // 结果: 2
| 位或 : 遇true则true, 遇1则1
^ 位异或 : 相同为false, 不同为true
~ 取反 : 全部取反, 0变1, 1变0 (也包括符号位)
00000000 00000000 00000000 00000110 // 6的二进制补码
~ 11111111 11111111 11111111 11111001
- 1 // -1求反码
------------------------------------
11111111 11111111 11111111 11111000 // 反码推原码
10000000 00000000 00000000 00000111 // -7
*/
public static void main(String[] args) {
System.out.println(6 & 2);
System.out.println(~6);
}
}
public class Demo3 {
/*
位移运算符:
<< 有符号左移运算,二进制位向左移动, 左边符号位丢弃, 右边补齐0
运算规律: 向左移动几位, 就是乘以2的几次幂
12 << 2
(0)0000000 00000000 00000000 000011000 // 12的二进制
-----------------------------------------------------------------------------
>> 有符号右移运算,二进制位向右移动, 使用符号位进行补位
运算规律: 向右移动几位, 就是除以2的几次幂
000000000 00000000 00000000 0000001(1) // 3的二进制
-----------------------------------------------------------------------------
>>> 无符号右移运算符, 无论符号位是0还是1,都补0
010000000 00000000 00000000 00000110 // -6的二进制
*/
public static void main(String[] args) {
System.out.println(12 << 1); // 24
System.out.println(12 << 2); // 48
}
}
package com.itheima.demo;
public class Demo4 {
/*
^ 运算符的特点
一个数, 被另外一个数, 异或两次, 该数本身不变
*/
public static void main(String[] args) {
System.out.println(10 ^ 5 ^ 10);
}
}
三、流程控制语句
在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的。所以,我们必须清楚每条语句的执行流程。而且,很多时候要通过控制语句的执行顺序来实现我们想要的功能。
1.if
①格式:
if (关系表达式) {
语句体;
}
②格式:
if (关系表达式) {
语句体1;
} else {
语句体2;
}
③格式:
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
2.switch语句
switch (表达式) {
case 1:
语句体1;
break;
case 2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
执行流程:
-
首先计算出表达式的值
-
其次,和case依次比较,一旦有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结 束。
-
最后,如果所有的case都和表达式的值不匹配,就会执行default语句体部分,然后程序结束掉
case穿透: 如果switch语句中,case省略了break语句, 就会开始case穿透
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期数:");
int week = sc.nextInt();
switch(week){
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("工作日");
break;
case 6:
case 7:
System.out.println("休息日");
break;
default:
System.out.println("您的输入有误");
break;
}
}
}
3.for循环
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
格式解释:
-
初始化语句: 用于表示循环开启时的起始状态,简单说就是循环开始的时候什么样
-
条件判断语句:用于表示循环反复执行的条件,简单说就是判断循环是否能一直执行下去
-
循环体语句: 用于表示循环反复执行的内容,简单说就是循环反复执行的事情
-
条件控制语句:用于表示循环执行中每次变化的内容,简单说就是控制循环是否能执行下去
for循环案例 ---求1-100偶数和
public class ForTest03 {
public static void main(String[] args) {
//求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0
int sum = 0;
//对1-100的数据求和与1-5的数据求和几乎完全一样,仅仅是结束条件不同
for(int i=1; i<=100; i++) {
//对1-100的偶数求和,需要对求和操作添加限制条件,判断是否是偶数
if(i%2 == 0) {
sum += i;
}
}
//当循环执行完毕时,将最终数据打印出来
System.out.println("1-100之间的偶数和是:" + sum);
}
}
for循环案例-每行打印2个水仙花数(统计)
-
需求:在控制台输出所有的“水仙花数”,要求每行打印2个
-
示例代码:
public class Demo6For {
/*
需求:在控制台输出所有的“水仙花数”,要求每行打印2个
System.out.print (打印内容); 打印后不换行
System.out.println(打印内容); 打印后换行
分析:
1. 定义变量count,用于保存“打印过”的数量,初始值为0
2. 在判定和打印水仙花数的过程中,拼接空格, 但不换行,并在打印后让count变量+1,记录打印过的数量
3. 在每一次count变量+1后,判断是否到达了2的倍数,是的话,换行。
*/
public static void main(String[] args){
// 1. 定义变量count,用于保存“打印过”的数量,初始值为0
int count = 0;
for(int i = 100; i <= 999; i++){
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
if( (ge*ge*ge + shi*shi*shi + bai*bai*bai) == i){
// 2. 在判定和打印水仙花数的过程中,拼接空格, 但不换行,并在打印后让count变量+1,记录打印过的数量
System.out.print(i + " ");
count++;
// 3. 在每一次count变量+1后,判断是否到达了2的倍数,是的话,换行
if(count % 2 == 0){
System.out.println();
}
}
}
}
}
4.while循环
初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}
while循环执行流程:
①执行初始化语句
②执行条件判断语句,看其结果是true还是false
如果是false,循环结束;如果是true,继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
5.dowhile循环
初始化语句;
do {
循环体语句;
条件控制语句;
}while(条件判断语句);
执行流程:
① 执行初始化语句
② 执行循环体语句
③ 执行条件控制语句
④ 执行条件判断语句,看其结果是true还是false
如果是false,循环结束;如果是true,继续执行
⑤ 回到②继续
6.三种循环的区别
-
三种循环的区别
-
for循环和while循环先判断条件是否成立,然后决定是否执行循环体(先判断后执行)
-
do...while循环先执行一次循环体,然后判断条件是否成立,是否继续执行循环体(先执行后判断)
-
-
for循环和while的区别
-
条件控制语句所控制的自增变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到了
-
条件控制语句所控制的自增变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用
-
-
死循环(无限循环)的三种格式
-
for(;;){}
-
while(true){}
-
do {} while(true);
-
7.跳转控制语句
-
跳转控制语句(break)
-
跳出循环,结束循环
-
-
跳转控制语句(continue)
-
跳过本次循环,继续下次循环
-
-
注意: continue只能在循环中进行使用
案例:
import java.util.Scanner;
public class Test {
/*
需求:程序运行后,用户可多次查询星期对应的减肥计划,直到输入0,程序结束
步骤:
1. 不明确用户操作几次, 使用死循环包裹业务逻辑
2. 匹配到0的时候,使用break结束循环死循环
*/
public static void main (String[] args){
lo:while(true){
System.out.println("请输入您要查看的星期数:");
System.out.println("(如无需继续查看,请输入0退出程序)");
// 1. 键盘录入星期数据,使用变量接收
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
// 2. 多情况判断,采用switch语句实现
switch(week){
// 3. 在不同的case中,输出对应的减肥计划
case 0:
System.out.println("感谢您的使用");
break lo;
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("慢走");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("拳击");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("好好吃一顿");
break;
default:
System.out.println("您的输入有误");
break;
}
}
}
}
四、Random
1.Random产生随机数(掌握)
-
概述:
-
Random类似Scanner,也是Java提供好的API,内部提供了产生随机数的功能
-
API可以简单理解为Java已经写好的代码
-
-
-
使用步骤:
-
导入包
import java.util.Random;
-
创建对象
Random r = new Random();
-
产生随机数
int num = r.nextInt(10);
解释: 10代表的是一个范围,如果括号写10,产生的随机数就是0-9,括号写20,参数的随机数则是0-19
-
2.
Random练习-猜数字(应用)
-
需求:
程序自动生成一个1-100之间的数字,使用程序实现猜出这个数字是多少?
当猜错的时候根据不同情况给出相应的提示
A. 如果猜的数字比真实数字大,提示你猜的数据大了
B. 如果猜的数字比真实数字小,提示你猜的数据小了
C. 如果猜的数字与真实数字相等,提示恭喜你猜中了
-
示例代码:
import java.util.Scanner;
import java.util.Random;
public class Test {
/*
需求:程序自动生成一个1-100之间的数字,使用程序实现猜出这个数字是多少?
当猜错的时候根据不同情况给出相应的提示
如果猜的数字比真实数字大,提示你猜的数据大了
如果猜的数字比真实数字小,提示你猜的数据小了
如果猜的数字与真实数字相等,提示恭喜你猜中了
1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
2. 使用Random产生一个1-100之间的数, 作为要猜的数
3. 键盘录入用户猜的的数据
4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
6. 猜对之后, break结束.
*/
public static void main(String[] args){
// 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
Random r = new Random();
Scanner sc = new Scanner(System.in);
// 2. 使用Random产生一个1-100之间的数, 作为要猜的数
int randomNum = r.nextInt(100) + 1;
// 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
while(true){
// 3. 键盘录入用户猜的的数据
System.out.println("请输入您猜的数据:");
int num = sc.nextInt();
// 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
if(num > randomNum){
System.out.println("猜大了");
}else if(num < randomNum){
System.out.println("猜小了");
}else{
// 6. 猜对之后, break结束.
System.out.println("恭喜,猜中了");
break;
}
}
System.out.println("感谢您的使用");
}
}