java入门（数据类型转换、运算符、流程控制）
一、数据类型转换
自动转换
/*
类型自动转换：
概念： 运算过程中，类型范围小的数据可以自动转换为类型范围大的数据。【小转大】
byte < short < int < long < float < double
转换规律：
1）小转大
2）byte short char 在运算的时候自动转换为int类型
*/
public class Demo01 {
public static void main(String[] args) {
//运算过程中，类型范围小的数据可以自动转换为类型范围大的数据。【小转大】
byte b1 = 100;
int i1 = b1; // b1(byte 小) ->i1 (int 大)
System.out.println(i1); //100
long l1 = 1000L;
float f1 = l1; //【小转大】
System.out.println("f1 = " + f1);
//int i2 = f1; // 大转小 ，不能自动转换
}
}
强制转换
/*
强制转换
概念： 类型范围大的数据，转换为类型范围小的数据【大转小】
规律：大转小
需要人为转换，格式：
需要借助强制转换符号，(需要转换的类型)
小类型 变量名 = (小类型)大类型值;
*/
public class Demo02 {
public static void main(String[] args) {
double d1 = 3.14;
//需要借助强制转换符号，(需要转换的类型)
int i1 = (int) d1;
System.out.println("i1 = " + i1);// 3
int i2 = 257;
byte b1 = (byte)i2;
System.out.println("b1 = " + b1);// 1
}
}
ASCII编码表
-
编码表：就是将人类的文字和一个十进制数进行对应起来组成一张表格。
-
存储字符时：需要查找ASCII码表,找到字符对应的数字,将数字转换为二进制数存放到计算机中
-
使用字符时：将对应的二进制数转换为十进制 找到ASCII表中对应的字符 显示出来
编码表中的字符就是char类型的数据了。
字符可以参与加减运算，因为字符运算时，会转换为int类型后进行运算
int和char可以相互转化
public class Demo01 {
public static void main(String[] args) {
char c1 = 'a';
int i1 = c1;
System.out.println("i1 = " + i1);//97
int i2 = 65;
char c2 = (char) i2; // 强制转换可以借助：Alt+Enter完成
System.out.println("c2 = " + c2); //A
}
}
常量和变量的运算
/*
常量和变量的运算
纯常量运算的特点：在编译时就可以直接得到结果
*/
public class Demo01 {
public static void main(String[] args) {
//纯常量运算的特点：在编译时就可以直接得到结果
byte b4 = 10+10; // byte b4 = 20;
//byte b5 = 10+120; // 超出了范围，报错
//2个字节： 0~65535
char c1 = 65+1;
System.out.println("c1 = " + c1); // B
//有变量参与得运算，只能在具体运算得时候，才能得到结果
byte b1 = 10;
byte b2 = 10;
byte b3 = (byte) (b1+b2);
}
}
二、运算符
算数运算符
/*
算术运算符
+ - * / %
运算特点：
1）当算术运算符两侧数据类型一致，运算结果也是一致
2）当算术运算符两侧数据类型一致，小类型会自动转化为大类型，得到得结果就是大类型结果。
3）byte short char 在运算的时候会自动转化为int
*/
public class Demo01 {
public static void main(String[] args) {
//1）当算术运算符两侧数据类型一致，运算结果也是一致
int i1 = 10;
int i2 = 3;
System.out.println(i1 + i2);// 13
System.out.println(i1 - i2);// 7
System.out.println(i1 * i2);// 30
System.out.println(i1 / i2);// 3
System.out.println(i1 % i2);// 1
//2）当算术运算符两侧数据类型一致，小类型会自动转化为大类型，得到得结果就是大类型结果。
double d1 = 10;
System.out.println(d1 + i2);// 13.0
System.out.println(d1 - i2);// 7.0
System.out.println(d1 * i2);// 30.0
System.out.println(d1 / i2);// 3.33333....
System.out.println(d1 % i2);// 1.0
//3）byte short char 在运算的时候会自动转化为int
byte b1 = 10;
short s1 = 20;
short s2 = (short) (s1 + b1);
int i3 = s1 + b1; // 结果为int类型
System.out.println("s2 = " + s2);
byte b2 = 10;
byte b3 = (byte) (b1 + b2);
char c1 = 65;
char c2 = (char) (c1 + 1);
}
}
字符串和加号拼接用法
字符串也是一种引用数据类型。
字符串类型使用String表示。
String str = "Hello World";
加号【+】与字符串的使用：拼接,连接
字符串可以使用加号【+】与任何类型的数据拼接在一起，得到一个新的字符串。
/*
字符串可以使用加号【+】与任何类型的数据拼接在一起，得到一个新的字符串。
*/
public class Demo02 {
public static void main(String[] args) {
String str = "Hello";
//任何类型的数据拼接在一起，得到一个新的字符串。
System.out.println(str + "World"); // HelloWorld
System.out.println(str + 100);
System.out.println(str + 3.14);
System.out.println(str + 'A');
System.out.println(str + true);
System.out.println(str + false);
//任何类型的数据拼接在一起，得到一个新的字符串。
int i1 = 1000;
System.out.println("i1 = " + i1); //i1 = 1000
int i2 = 200;
System.out.println(i1 + i2); // 1200
System.out.println("1000+200 = " + i1 + i2);//1000+200 = 1000200
System.out.println("1000+200 = " + (i1 + i2));//1000+200 = 1200
}
}
赋值运算符
使用特点：
1）= ：就是将符号右边的值赋值给左边的变量。
等号的左边，一定是变量
等号的右边，可以常量，变量，表达式 int a = 10+20;
- += -= *= /= %= ：【复合赋值运算符】 当一个变量参与了运算，并把结果赋值回自身
- 复合赋值运算符， 当一个变量参与了运算，并把结果赋值回自身
- 复合赋值运算符，可以自动强转
/*
+= -= *= /= %= ：【复合赋值运算符】 当一个变量参与了运算，并把结果赋值回自身
*/
public class Demo01 {
public static void main(String[] args) {
int a = 100;
a += 100; // ==> a = a + 100;
System.out.println("a = " + a);
int b = 10;
b %= 3; // ==> b = b % 3;
System.out.println("b = " + b); //1
//特点：复合赋值运算符，可以自动强转
byte b1 = 10;
b1 = (byte) (b1 + 10); //需要手动强转
System.out.println("b1 = " + b1); //20
byte b2 = 10;
b2 += 10; // 自动强转
System.out.println("b2 = " + b2); //20
}
}
自增自减运算符
混合使用: 一个变量运算有自增或者自减参与,也有其他的赋值运算，四则运算…
1：符号在变量前面:【先算，后用】
2：符号在变量后面:【先用，后算】
/*
++：自增，将变量的的值+1
--：自减，将变量的的值-1
自增和自减符号，用法规律是一样，运算结果一个+1一个-1。
1）单独使用： 一个变量运算只有自增或者自减参与，没有其他的赋值运算，四则运算...
1：符号在变量前面
2：符号在变量后面
2）混合使用: 一个变量运算有自增或者自减参与,也有其他的赋值运算，四则运算...
1：符号在变量前面:【先算，后用】
2：符号在变量后面:【先用，后算】
*/
public class Demo01 {
public static void main(String[] args) {
//1）单独使用： 一个变量运算只有自增或者自减参与，没有其他的赋值运算，四则运算...
//特点： 符号在前在后一样，没有影响
int i1 = 100;
// 1：符号在变量前面
++i1; // ==》 i1 +=1 i1=i1+1
System.out.println("i1 = " + i1); //101
// 2：符号在变量后面
i1++;
System.out.println("i1 = " + i1);// 102
//2）混合使用: 一个变量运算有自增或者自减参与,也有其他的赋值运算，四则运算,打印...
//特点：
// 1：符号在变量前面：【先算，后用】
int i2 = 1000;
int i3 = ++i2; //先计算i2+1 (i2=1001)结果，后使用i2(i2=1001)
System.out.println("i2 = " + i2); //1001
System.out.println("i3 = " + i3); //1001
// 2：符号在变量后面:【先用，后算】
int i4 = 1000;
int i5 = i4++; // 先使用i4的值赋值给i5,然后再运算+1
System.out.println("i4 = " + i4); // 1001
System.out.println("i5 = " + i5); // 1000
// 3：打印
int i6 = 100;
System.out.println(i6++); // 100
System.out.println(i6); // 101
// 4:四则运算
int i7 = 10;
int i8 = (++i7) + (i7++) + (--i7 * 10);
// i7 11 12 11
// i8 11 + 11 + 110
System.out.println("i7 = " + i7); // 11
System.out.println("i8 = " + i8); // 132
}
}
关系运算符【比较运算符】
public class Demo01 {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a==b);// false
System.out.println(a>=b);// false
System.out.println(a>b);// false
System.out.println(a<=b);// true
System.out.println(a<b);// true
System.out.println(a!=b);// true
}
}
逻辑运算符
/*
逻辑运算符：
1）与 &&
房 && 车 结果
true true true
true false false
false true false
false false false
特点:
1）一假即假： 符号两侧如果有一个为false，那么结果就为false
2）短路特点: 只要符号左侧的结果为false，右侧的表达式不会运算了，结果可以确定为false
2）或 ||
房 && 车 结果
true true true
true false true
false true true
false false false
特点：
1）一真即真
2）短路特特点：只要符号左侧的结果为true，右侧的表达式不会运算了，结果可以确定为true
3）非 !
取反操作
!true = false
!false = true
*/
public class Demo01 {
public static void main(String[] args) {
//1）与 &&
//短路特点: 只要符号左侧的结果为false，右侧的表达式不会运算了，结果可以确定为false
int i1 = 100;
System.out.println(++i1 > 1000 && ++i1<1000); // false && true = false
System.out.println("i1 = " + i1); //101有短路 i1=102 没有短路，i1 = 101 有短路
//2）或 ||
//2）短路特特点：只要符号左侧的结果为true，右侧的表达式不会运算了，结果可以确定为true
int i2 = 100;
System.out.println(++i2 < 1000 || ++i2 <1000); //true || true = true
System.out.println("i2 = " + i2); //101 i2=101有短路，i2=102没有短路
//3）非 !
System.out.println(!true); //false
System.out.println(!false); //true
}
}
三元运算符
一元运算符：只操作一个数据的运算符， ++ –
二元运算符：只操作两个数据的运算符，+ & > …
三元运算符：只操作三个数据的运算符： ？：
1）三元运算符的格式：
布尔表达式：如果运算结果为布尔类型【关系表达式，逻辑表达式】
变量类型 变量 = 布尔表达式 1? 真值表达式2 : 假值表达式3
2）三元运算符表达式的运算流程：
先运算 布尔表达式 1 得到一个 布尔结果：
结果为true： 此三元表达式的结果即**真值表达式2** 的结果
结果为false：此三元表达式的结果即**假值表达式3** 的结果
然后将三元表达式的结果赋值给变量
需求1：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同
/*
动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。
*/
public class Demo01 {
public static void main(String[] args) {
//1）先定义两个变量，保存两只老虎的体重
int t1 = 180;
int t2 = 200;
//2）借助三元算运算符判断是否相同
boolean result = t1 == t2 ? true:false ;
System.out.println("result = " + result); //false
}
}
需求2：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。
/*
一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。
*/
public class Demo02 {
public static void main(String[] args) {
//1)定义三个变量用来保存三个和尚的身高
int h1 = 150;
int h2 = 210;
int h3 = 160;
//2)先比较两个和尚得到较高和尚，较高和尚再与第三个和尚比高得到最高和尚。
//比较h1和h2 得到较高和尚
int jiaoGao = h1 > h2 ? h1 : h2;
//jiaoGao 和 h3 得到最高
int zuiGao = jiaoGao > h3 ? jiaoGao : h3;
System.out.println("zuiGao = " + zuiGao);
}
}
注意：在使用三元运算符时，当使用变量接受三元表达式结果时，变量的类型要和，真值，假值表达式结果的类型要一致。
三、数据输入
数据录入Scanner的用法
Scanner就是JDK核心类库中的一个类，用来键盘输入数据。
如何使用：
-
导包：为了找到这个类
import java.util.Scanner;以上语句，要写在类上面，包名下面。
-
创建对象
Scanner sc = new Scanner(System.in); -
调用方法
实现数据的键盘输入：输入整数，输入字符串，输入布尔类型的数据…
int i = sc.nextInt(); //输入int数据 double d1 = sc.nextDouble();//输入double数据 String str = sc.next();//输入字符串数据注意：当执行到方法调用时，程序回阻塞等待用户的键盘输入。
package demo10Scanner;
import java.util.Scanner;//1.导包
public class Demo01 {
public static void main(String[] args) {
//2创建对象
Scanner sc = new Scanner(System.in);
//3调用方法获取数据
//获取一个整数
//输入int数据
int i1 = sc.nextInt(); //阻塞
System.out.println("i1 = " + i1);
//输入double数据
double d1 = sc.nextDouble();//阻塞
System.out.println("d1 = " + d1);
//输入字符串数据
String str = sc.next();//阻塞
System.out.println("str = " + str);
}
}
Scanner练习
-
在获取三个和尚中的最高身高案例中，身高数据如果由键盘录入，该怎样实现呢？
/* 一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。 */ import java.util.Scanner; public class Demo02Practice { public static void main(String[] args) { Scanner sc = new Scanner(System.in); //1)定义三个变量用来保存三个和尚的身高，身高来自于键盘输入 System.out.println("请输入第一个和尚身高"); int h1 = sc.nextInt(); System.out.println("请输入第二个和尚身高"); int h2 = sc.nextInt(); System.out.println("请输入第三个和尚身高"); int h3 = sc.nextInt(); //2)先比较两个和尚得到较高和尚，较高和尚再与第三个和尚比高得到最高和尚。 //比较h1和h2 得到较高和尚 int jiaoGao = h1 > h2 ? h1 : h2; //jiaoGao 和 h3 得到最高 int zuiGao = jiaoGao > h3 ? jiaoGao : h3; System.out.println("zuiGao = " + zuiGao); } }
四、流程控制
流程控制概述，分类及顺序结构
- 流程控制： 控制代码执行的流程
- 顺序结构：程序按照书写顺序自上而下执行
- 分支结构：根据某个条件判断是否执行某些代码
- 循环结构：根据某个条件判断是否循环执行代码
顺序结构
public static void main(String[] args){
//顺序执行，根据编写的顺序，从上到下运行
System.out.println(2);
System.out.println(1);
System.out.println(3);
}
分支结构
分支结构可以使用Java的两种语句：if,swtich
if格式1：
其他语句1
if(布尔表达式){
语句体
}
其他语句2
执行流程：
先程序自上而下执行，当执行到if语句时，先布尔表达式的结果是否为true，如果为true执行语句体，否则不执行语句体直接跳过执行后面其他语句。
if格式2：
其他语句1
if(布尔表达式){
语句体1
}else{
语句体2
}
其他语句2
执行流程：
程序自上而下执行，当执行if语句时，先判断布尔表达式结果是否为true，如果结果为true执行语句体1，否则执行语句体2.
public class Demo02 {
public static void main(String[] args) {
System.out.println("今天天气挺好，出门逛逛！");
int age = 17;
if (age >= 18) {
//只有括号中的结果为true，才会执行
System.out.println("去网吧，学习Java");
} else {
//只有括号中的结果为false，才会执行
System.out.println("去图书馆，学习Java，顺便交个女朋友");
}
System.out.println("天色已晚，回家吃饭");
}
}
if语句格式3：
if(条件1){
语句体1;
}else if(条件2){
语句体2;
}
//.......n个else if 语句
else if(条件n){
语句体n;
}else{
语句体n+1;
}
//其他语句
【执行流程】
- 条件自上而下的进行判断，当某一个条件结果为true，就会执行对于的语句体，执行完语句体后if结构结束。如果所有条件都不满足，就会执行else中的语句体。
对成绩进行优良中差划分。
要求成绩由键盘输入，使用if语句进行划分
/*
要求成绩由键盘输入，使用if语句进行划分
*/
public class Demo01 {
public static void main(String[] args) {
//1:创建Scanner对象，录入分数，用变量score保存。
Scanner sc = new Scanner(System.in);
System.out.println("请输入分数：");
int score = sc.nextInt();
//2：借助if判断成绩
if (score >= 90 && score <= 100) {
// 优 [90,100]
System.out.println("成绩优秀");
} else if (score >= 80 && score <= 89) {
// 良 [80,89]
System.out.println("成绩良好");
} else if (score >= 60 && score <= 79) {
// 中 [60,79]
System.out.println("成绩中等");
} else if (score >= 0 && score <= 59) {
// 差 [0,59]
System.out.println("成绩不理想");
} else {
System.out.println("李时珍的皮，录入的数据无效！！");
}
}
}
switch格式
switch(受检值){
case 常量1:
语句体1;
break; //中断
//....可以有多个case
case 常量n:
语句体n;
break;
default:
语句体n+1;
break;
}
【执行流程】
- 当switch得到受检值后，受检值会和case中的常量进行比较是否相等。如果某个case后面的常量与受检值相等，就会执行对应的语句体，执行break后整个switch结构就结束。如果所有的case常量都和受检值不一样，就会执行default中的语句体。
【练习】switch语句练习-春夏秋冬
- 需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
- 演示效果
输入： 1、2、12 输出：冬季
输入： 3、4、5 输出：春季
输入： 6、7、8 输出：夏季
输入： 9、10、11 输出：秋季
输入：其它数字 输出：数字有误
public class Demo01 {
public static void main(String[] args) {
//1:借助Scanner输入一个月份，可以使用一个变量month保存月份
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个月份：");
int month = sc.nextInt();
//2：借助switch对month进行判断，输出对应的季节
switch (month) {
case 1:
System.out.println(month + "月是冬季");
break;
case 2:
System.out.println(month + "月是冬季");
break;
case 12:
System.out.println(month + "月是冬季");
break;
case 3:
System.out.println(month + "月是春季");
break;
case 4:
System.out.println(month + "月是春季");
break;
case 5:
System.out.println(month + "月是春季");
break;
case 6:
System.out.println(month + "月是夏季");
break;
case 7:
System.out.println(month + "月是夏季");
break;
case 8:
System.out.println(month + "月是夏季");
break;
case 9:
System.out.println(month + "月是秋季");
break;
case 10:
System.out.println(month + "月是秋季");
break;
case 11:
System.out.println(month + "月是秋季");
break;
default:
System.out.println("李时珍的皮，没有这个月份！！");
break;
}
System.out.println("其他语句11");
//。。。
}
}
/*
switch受检值的类型可以是：int，byte, short, char ，字符串【String】,枚举【Enum】
*/
public class Demo02 {
public static void main(String[] args) {
// 字符串
String week = "1";
switch (week) {
case "1":
System.out.println("周一");
break;
case "2":
System.out.println("周二");
break;
}
//注意：long类型不能
/* long week1 =1;
switch (week1){
case 1:
System.out.println("周一");
break;
}*/
}
}
switch中case的穿透性
【概念】什么是case的穿透性？
当switch中case语句没有写break，当执行到此没有break的case语句后，switch不会中断结束，继续忽略下一个case条件执行其语句体。直到遇到break,或者执行结束。
【练习】使用case穿透性，优化练习-春夏秋冬
/*
- 需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
- 演示效果
输入： 1、2、12 输出：冬季
输入： 3、4、5 输出：春季
输入： 6、7、8 输出：夏季
输入： 9、10、11 输出：秋季
输入：其它数字 输出：数字有误
*/
public class Demo03 {
public static void main(String[] args) {
//1:借助Scanner输入一个月份，可以使用一个变量month保存月份
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个月份：");
int month = sc.nextInt();
//2：借助switch对month进行判断，输出对应的季节
switch (month) {
case 1:
case 2:
case 12:
System.out.println(month + "月是冬季");
break;
case 3:
case 4:
case 5:
System.out.println(month + "月是春季");
break;
case 6:
case 7:
case 8:
System.out.println(month + "月是夏季");
break;
case 9:
case 10:
case 11:
System.out.println(month + "月是秋季");
break;
default:
System.out.println("李时珍的皮，没有这个月份！！");
break;
}
System.out.println("其他语句11");
//。。。
}
}
循环概述
循环结构：根据某个条件判断循环执行某些代码。
循环结构的语句：for,while,do-while
循环结构包含以下语句：
-
初始化语句：初始化循环变量，循环变量用来记录循环次数
-
循环判断语句：判断为true，执行循环，否则结束循环。
-
循环体语句：就是循环结构要不断重复执行的语句
-
步进语句：循环条件变化的语句
for循环语句的使用
【格式】
for(初始化语句1;循环判断语句2;步进语句4){
循环体语句3
}
【执行流程】 1 - 2 3 4 - 2 3 4 - 2 3 4 - 2 3 4 - 2 直到循环判断语句2的判断结果为false，循环就结束。
【练习】打印10遍HelloWorld字符串
public class Demo01 {
public static void main(String[] args) {
//【练习】打印10遍HelloWorld字符串
for (int i = 0; i < 10; i++) {
System.out.println("HelloWorld" + i);
}
}
}
for循环练习1
在控制台输出1-5和5-1的数据
public class Demo02Practice {
public static void main(String[] args) {
//在控制台输出1-5
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
// 5-1的数据
for (int i = 5; i > 0; i--) {
System.out.println(i);
}
}
}
for循环练习2
求1-5之间的数据和，并把求和结果在控制台输出
public class Demo03Practice {
public static void main(String[] args) {
//求1-5之间的数据和，并把求和结果在控制台输出
//1：定义一个变量用来存储和。
int sum = 0;
//2：借助for循环提供1~5的数字
for (int i = 1; i < 6; i++) {
//3：在循环内部进行完成累加操作。
//sum = sum +i;
sum += i;
}
//4：打印求和结果
System.out.println("sum = " + sum);
}
}
for循环练习3
/*
求1-100之间的偶数和，并把求和结果在控制台输出
*/
public class Demo04Practice {
public static void main(String[] args) {
//1:定义一个变量保存累加的和
int sum = 0;
//2：借助for循环提供1~100的数字
for (int i = 1; i <=100 ; i++) {
//3：循环内部判断是否为偶数，如果为偶数进行累加，否则不做任何操作。
if (i % 2 == 0) {
//偶数:如果一个数能够被2整除，就是偶数【对2取余为0】
sum+=i;
}
}
//4：循环结束，打印累加结果
System.out.println("sum = " + sum);
}
}
for循环练习4
【难点】如何获取个，十，百位的数据
public class Demo05 {
public static void main(String[] args) {
int num1 = 54123;
//个:只要对10取余即可
System.out.println(num1%10); //3
//十：把十位转换位个位【先除10，再模10】
System.out.println(num1/10%10);//2
//百：把百位转换为个位【除100】
System.out.println(num1/100%10);//1
//千
System.out.println(num1/1000%10);//4
//万
System.out.println(num1/10000%10); //5
}
}
在控制台输出所有三位数的“水仙花数”
什么是水仙花数？水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数
例如 153 3*3*3 + 5*5*5 + 1*1*1 = 153
/*
在控制台输出所有三位数的“水仙花数”
什么是水仙花数？水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数
例如 153 3*3*3 + 5*5*5 + 1*1*1 = 153
*/
public class Demo06Practice {
public static void main(String[] args) {
//1:借助for循环获取所有的三位数
for (int i = 100; i < 1000; i++) {
//2：在循环内部完成对数字的个十百位数字获取，
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
// 立方求和与数字对比是否相等，
if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
//相等即水仙花数
System.out.println(i);
}
}
}
}
while循环语句的使用
【格式】
初始化语句1;
while(循环条件语句2){
循环体语句3;
步进语句4
}
【执行流程】1 - 2 3 4 - 2 3 4 - 2 3 4 - 2 直到循环条件语句2判断结果位false，while循环就结束。继续执行下面的其他语句
-
在控制台输出10次HelloWorld
public class Demo01 { public static void main(String[] args) { //在控制台输出10次HelloWorld int i = 0; while (i < 10) { System.out.println("Hello World" + i); i++; } System.out.println("循环已经执行完了。。。。"); } }
- while循环练习2：珠穆朗玛峰
/*
需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
*/
public class Demo02Practice {
public static void main(String[] args) {
//1:初始化数据，定义变量保存，山高，纸厚，折叠次数
int mh = 8844430;//山高
double ph = 0.1;//纸厚
int count = 0; //次数
//2:循环折叠纸，当纸厚小于山高继续折纸，直到纸厚大于等于山高停止折叠
while (ph < mh) {
//3：次数+1，纸厚*=2
count++;
ph *= 2;
}
//4：打印次数，纸厚
System.out.println("折叠次数：" + count);//27
System.out.println("纸厚：" + ph); //13421772.8 E7
// 8844430
}
}
do-while循环语句的使用
【格式】
初始化语句1
do{
循环体语句2
步进语句3
}while(循环判断语句4);
【执行流程】1 2 3 - 4 2 3 - 4 2 3 - 4 直到 循环判断语句4结果位false，结束循环。
【特点】无条件执行一次。
- do-while循环练习1
/*
使用do-while循环来操作打印10次HelloWorld
*/
public class Demo01 {
public static void main(String[] args) {
int i=0;
do {
System.out.println("Hello World" + i);
i++;
} while (i < 10);
}
}
循环语句的区别
三个循环语句：
- for
- while
- do-while
区别：
-
for，while循环第一次执行循环体，需要条件成立，do-while循环无条件执行一次。
-
for,while的区别：for的循环变量只能在for结构中使用，while的循环变量，可以在while结构后面使用。
-
如何找到变量的作用域【变量可以使用的范围】？
先找到包裹该变量最近的一对大括号
{}，从这个变量定义开始，到 右括号}结束，都是该变量的作用域。
-
/*
如何找到变量的作用域【变量可以使用的范围】？
先找到包裹该变量最近的一对大括号{}，从这个变量定义开始，到 右括号}结束，都是该变量的作用域。
*/
public class Demo01 {
public static void main(String[] args) {
//System.out.println(x);
int x = 10;
System.out.println(x);
//for循环的变量特殊：只能在for结构中使用
for (int i = 0; i < 10; i++) {
System.out.println(i);
int y = 20;
System.out.println(y);
}
//System.out.println(i);
//System.out.println(y); // 不在y的作用域
//while循环的循环变量
int z =30;
while (z < 40) {
System.out.println(z);
}
System.out.println(z); //是z的作用域
}
}
使用建议：
- 使用循环语句根据需要而定，如果必须无条件执行一次，可以使用do-while。
- 建议优先使用for，while循环。
- 如果对循环变量使用比较紧密，建议使用for循环【数组遍历】
- 如果对条件比较敏感，建议使用while。
跳出语句break和continue的使用
流程控制语句
-
break:中断，打断
- 可以在switch中用来结束switch结构
- 可以用在循环结构，当执行此语句时，结束整个循环。
/*
break:中断，打断
1. 可以在switch中用来结束switch结构
2. 可以用在循环结构，当执行此语句时，结束整个循环。
*/
public class Demo01 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
System.out.println(i);
if (i == 5) {
break; //该循环结束，剩下的循环将不执行
}
}
}
}
-
continue：继续不可以单独的在switch语句中使用
在循环中使用，表示中断当次循环，继续执行下一次循环。
public class Demo01 {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i == 5) {
continue;//当次循环到此结束，继续下一次循环
}
System.out.println(i);
}
}
}
【逢七过练习】
/*
逢7过
*/
public class Demo02 {
public static void main(String[] args) {
for (int i = 1; i < 100; i++) {
//逢7过：7的倍数，含有7
if ((i % 7 == 0) || (i % 10 == 7 || i / 10 % 10 == 7)) {
//7的倍数 || 含有7
System.out.println("过");
continue; //结束当次循环，继续下一次循环
}
System.out.println(i);
}
}
}
死循环
死循环就是无限循环，也叫永真循环。
-
标准形式
for死循环： for(;;){ 循环体 } while死循环： while(true){ 循环体 } do-while死循环： do{ 循环体 } while(true);/*注意：后面不能接收及其他代码，因为无法执行到。 */ public class Demo01 { public static void main(String[] args) { //while死循环 while (true) { System.out.println("我爱你！！"); } //注意：后面不能接收及其他代码，因为无法执行到。 //System.out.println("Hello World"); } } -
条件不可达死循环【如果条件不能达到边界，也会导致死循环】
public class Demo02 { public static void main(String[] args) { for(int i=0;i<10;i++){ i--; //System.out.println("Hello"); } //上面的循环为死循环，该语句不能执行到 System.out.println("我恨你！"); } }
猜数字游戏
/*
先随机提供一个[1,100]之间的随机数，使用num保存。
玩家猜数字，为guessNum
如果大了，提示大了
如果小了，提示小了
如果猜对了，游戏结束
直到猜对为止
*/
public class Demo01 {
public static void main(String[] args) {
//1：使用Random生成一个随机数，使用num保存。
Random rd = new Random();
//[1,100] = [0,99]+1
int num = rd.nextInt(100)+1;
while (true) {
//2：使用Scanner键盘输入用户猜的数值，用guessNum
Scanner sc = new Scanner(System.in);
System.out.println("请输入您要猜的数值：");
int guessNum = sc.nextInt();
//3：比较guessNum和num
if (guessNum > num) {
//如果大了，提示大了
System.out.println("不好意思，您猜大了"+guessNum);
} else if (guessNum < num) {
//如果小了，提示小了
System.out.println("不好意思，您猜小了" + guessNum);
} else {
//如果猜对了，游戏结束
System.out.println("恭喜您，猜对了" + guessNum);
break;//猜对了就结束游戏
}
}
}
}
五、随机数Random
【作用】生成随机数字
【使用步骤】
-
导包
import java.util.Random; -
创建对象
Random rd = new Random(); -
调用方法
int num = rd.nextInt(bounds); //bounds范围 num将会得到 [0,bounds-1]之间的一个随机数 bounds必须为正数
【练习】使用Random类，完成生成3个10以内的随机整数的操作
import java.util.Random;
public class Demo01 {
public static void main(String[] args) {
// 使用Random类，
Random rd = new Random();
// 完成生成3个10以内的随机整数的操作,包含10
for (int i = 0; i < 3; i++) {
int num = rd.nextInt(11);
System.out.println("num = " + num);
}
System.out.println("====");
//int i = rd.nextInt(-1); //传入的数字，必须为正数
//System.out.println("i = " + i);
}
}