第1章 引用类型的使用
1.1 引用数据类型的使用格式
与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。
导包：
使用import导包,在类的所有代码之前导包(找到要使用的类型)
定义变量，并创建对象赋值：
数据类型 变量名 = new 数据类型();
调用方法，每种引用数据类型都有其功能，我们可以调用该类型实例的功能：
变量名.方法名();
1.2 键盘录入：Scanner类
Scanner类是引用数据类型的一种，我们可以使用该类来完成用户键盘录入，终于不需要我们帮用户指定购物数量了，用户可以自己从键盘录入想买的数量了。
Scanner使用步骤：
导包：import java.util.Scanner;
创建对象实例：Scanner sc = new Scanner(System.in);
调用方法：
nextInt()：接收一个整数
next()：接收一个字符串
如：
int i = sc.nextInt(); 用来接收控制台录入的数字
String s = sc.next(); 用来接收控制台录入的字符串
/*
Scanner类:它是引用数据类型的一种,可以帮助我们获取键盘输入
使用步骤:
1.导包:import java.util.Scanner;一定要写在类的上(外)边
2.创建Scanner对象,为Sacanner变量赋值
Scanner xx = new Scanner(System.in);
3.通过变量名.方法(),获取Scanner类中的方法
int i = xx.nextInt();获取键盘输入的整数,获取到空格或者回车的时候结束获取
String s = xx.next();获取键盘输入的字符串,获取到空格或者回车的时候结束获取
*/
//1.导包
import java.util.Scanner;
public class Demo01Scanner{
public static void main(String[] args){
//2.创建Scanner对象,为Sacanner变量赋值
Scanner sc = new Scanner(System.in);
//3.通过变量名.方法(),获取Scanner类中的方法
//int i = xx.nextInt();
//友好提示
System.out.println("请输入一个整数,注意必须是整数:");
int i = sc.nextInt();//获取键盘输入的整数
System.out.println("i = " + i);
//String s = xx.next();
System.out.println("请输入一个字符串:");
String s = sc.next();//获取键盘输入的字符串
System.out.println("s = " + s);
}
}
1.2.1 Scanner练习
1.2.1.1 键盘输入两个数据并求和
public class Demo02Scanner {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);
// 接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
System.out.println("请输入第二个数据：");
int b = sc.nextInt();
// 对数据进行求和
int sum = a + b;
System.out.println("sum:" + sum);
}
}
1.2.1.2 键盘录入两个数据比较是否相等
public class Demo03Scanner {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);
// 接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
System.out.println("请输入第二个数据：");
int b = sc.nextInt();
// 比较两个数据是否相等
// boolean flag = ((a == b) ? true : false);
boolean flag = (a == b);
System.out.println("flag:" + flag);
}
}
1.2.1.3 键盘录入三个数据获取最大值
public class Demo04Scanner {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);
// 接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
System.out.println("请输入第二个数据：");
int b = sc.nextInt();
System.out.println("请输入第三个数据：");
int c = sc.nextInt();
// 如何获取三个数据的最大值
int temp = (a > b ? a : b);
int max = (temp > c ? temp : c);
System.out.println("max:" + max);
}
}
1.2.1.4 next相关问题
import java.util.Scanner;
/*
* next() nextInt nextDouble 都不解析.
* nextLine() : 可以解析空格 换行
*/
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double low = sc.nextDouble();
System.out.println(low);
double high = sc.nextDouble(); // /r/n
System.out.println(high);
// 请输入 id 点菜
System.out.println("id");
sc.nextLine();
String id = sc.nextLine();
System.out.println(id);
}
}
1.3 随机数：Random类
概述
用于产生一个随机数
使用步骤(和Scanner类似)
导包
import java.util.Random;
创建对象
Random r = new Random();
调用方法：
nextInt(int maxValue) 产生[0,maxValue)范围的随机数
nextDouble() 产生[0,1)范围的随机数
如：
Random random = new Random ();
int myNumber = random.nextInt(100);//结果为0-99的一个数
double myNumber2 = random.nextDouble();//结果为0-1之间的一个小数
/*
Random类:它是引用数据类型的一种,可以帮助我们获取随机数
使用格式:
1.导包:import java.util.Random;
2.创建Random对象,为Random变量赋值
Random xx = new Random();
3.通过变量名.方法(),获取Random类中的方法
int i = xx.nextInt(int maxValue);产生一个随机整数,范围[0,maxValue)
double d = xx.nextDouble();产生一个随机小数,范围[0,1)
*/
//1.导包
import java.util.Random;
public class Demo02Random{
public static void main(String[] args){
//2.创建Random对象,为Random变量赋值
Random r = new Random();
//3.通过变量名.方法(),获取Random类中的方法
//int i = xx.nextInt(int maxValue);产生一个随机整数,范围[0,maxValue)
//产生一个0-4之间的随机数
//int i = r.nextInt(5);
//产生一个1-5之间的随机数
int i = r.nextInt(5)+1;//0-4 1-5
System.out.println("i = " + i);
//double d = xx.nextDouble();产生一个随机小数,范围[0,1)
double d = r.nextDouble();
System.out.println("d = " + d);
}
}
1.3.1 Random练习
1.3.1.1 获取0-10之间的随机数
1.3.1.2 获取1-100之间的随机数
public class Demo01Random {
public static void main(String[] args) {
// 创建对象
Random r = new Random();
for (int x = 0; x < 10; x++) {
// 获取随机数
int number = r.nextInt(10);
// 输出随机数
System.out.println("number:" + number);
}
System.out.println("--------------------");
// 如何获取到一个1-100之间的随机数呢?
int i = r.nextInt(100) + 1;
System.out.println("i:" + i);
}
}
1.3.1.3 猜数字小游戏案例
系统产生一个1-100之间的随机数，请猜出这个数据是多少
public class Demo02Random {
public static void main(String[] args) {
// 系统产生一个随机数1-100之间的。
Random r = new Random();
int number = r.nextInt(100) + 1;
while(true){
// 键盘录入我们要猜的数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数字(1-100)：");
int guessNumber = sc.nextInt();
// 比较这两个数据(用if语句)
if (guessNumber > number) {
System.out.println("你猜的数据" + guessNumber + "大了");
} else if (guessNumber < number) {
System.out.println("你猜的数据" + guessNumber + "小了");
} else {
System.out.println("恭喜你,猜中了");
break;
}
}
}
}
第2章 选择结构
2.1 概述
选择结构也被称为分支结构。
选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。
Java语言提供了两种选择结构语句
if语句
switch语句
2.2 if语句
2.2.1 if语句简介
在现实业务中，许多场景需要我们做出条件判断，而每一种条件对应一则业务逻辑。比如，如果考试超过60分，不需要补考，低于60分需要补考。再比如如果是管理员，则可以删除论坛帖子，而普通游客却不可以等等。
对应这样需要选择的业务场景，我们可以使用if选择结构。
2.2.2 if语句格式
2.2.2.1 单条件判断(格式1)
满足if条件即执行，不满足不执行。如年龄大于18岁可以注册婚恋网站
if语句的语法格式：
if (条件语句){
代码块
}
执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体
流程图
/*
选择结构if语句的第一种格式,有可能一句话都不打印
格式:
if(条件语句){
code;
...
}
执行步骤:
首先判断条件语句是否成立
true:执行if{}中的代码
false:不执行if{}中的代码
*/
import java.util.Scanner;
public class Demo03If{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的年龄: ");
int age = sc.nextInt();
if(age >= 18){
System.out.println("年龄大于等于18岁,可以注册百合网,美女在等着你");
}
if(age < 18){
System.out.println("年龄小于18岁,不可以注册百合网,注册会员,可以放宽年龄限制");
}
}
}
2.2.2.2 互斥条件判断(格式2)
满足条件执行if语句体，不满足执行else语句体。如年龄大于18岁可以注册婚恋网站，小于18岁不可以注册。
if语句第二种格式：
if(关系表达式) {
语句体1;
}else {
语句体2;
}
执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2
流程图
/*
选择结构if语句的第二种格式:总会打印一句话
格式:
if(条件语句){
执行语句1;
...
}else{
执行语句2;
...
}
执行流程:
首先判断条件语句是否成立
true:执行if{}中的执行语句1
false:执行else{}中的执行语句2
*/
import java.util.Scanner;
public class Demo04If{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的年龄: ");
int age = sc.nextInt();
if(age >= 18){
System.out.println("年龄大于等于18岁,可以注册百合网,美女在等着你");
}else{
System.out.println("年龄小于18岁,不可以注册百合网,注册会员,可以放宽年龄限制");
}
}
}
2.2.2.3 多条件判断(格式3)
在多个条件中选择满足条件的if语句体执行。
例如，对一个学生的考试成绩进行等级的划分；
如果分数大于等于80分，小于等于100分等级为优；
如果分数大于等于70分，小于80分级为良；
如果分数大于等于60分，小于70分等级为及格；
60以下为不及格。
if语句第三种格式：
if (判断条件1) {
执行语句1
} else if (判断条件2) {
执行语句2
}
...
else if (判断条件n) {
执行语句n
} else {
执行语句n+1
}
执行流程
首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
…
如果没有任何关系表达式为true，就执行语句体n+1。
流程图
/*
选择结构if语句的第三种格式:终究会打印一个结果
格式:
if(条件1){
条件1成立执行
}else if(条件2){
条件1不成立,条件2成立执行
}
.....
else if(条件n){
条件1,条件2...都不成立,条件n成立执行
}else{
所有条件都不满足,执行
}
需求:根据成绩判断成绩等级
90-100分:优
80-90分:良
70-80分:中
60-70分:及格
0-60分:不及格
其它成绩:非法成绩
变量的作用域:在自己所在的{}内有效
*/
public class Demo05If{
public static void main(String[] args){
int score = 55;
if(score >=90 && score <=100){
System.out.println("成绩是"+score+",等级为优!");
}else if(score >=80 && score <90){
System.out.println("成绩是"+score+",等级为良!");
}else if(score >=70 && score <80){
System.out.println("成绩是"+score+",等级为中!");
}else if(score >=60 && score <70){
System.out.println("成绩是"+score+",等级为及格!");
}else if(score >=0 && score <60){
int a = 44;
System.out.println(a);
System.out.println("成绩是"+score+",等级为不及格!");
}else{
//System.out.println(a);//错误: 找不到符号
System.out.println("成绩是"+score+",非法成绩!");
}
//System.out.println(a);//错误: 找不到符号
}
}
例题:
x和y的关系满足如下：
x>=3 y = 2x + 1;
-1<=x<3 y = 2x;
x<=-1 y = 2x – 1;
根据给定的x的值，计算出y的值并输出。
public class Demo03If {
public static void main(String[] args) {
// x和y的关系满足如下：
// x>=3 y = 2x + 1;
// -1<=x<3 y = 2x;
// x<=-1 y = 2x – 1;
// 根据给定的x的值，计算出y的值并输出。
// 定义变量
int x = 5;
/*
int y;
if (x >= 3) {
y = 2 * x + 1;
} else if (x >= -1 && x < 3) {
y = 2 * x;
} else if (x <= -1) {
y = 2 * x - 1;
}else {
y = 0;
}
*/
/*int y = 0;
if (x >= 3) {
y = 2 * x + 1;
} else if (x >= -1 && x < 3) {
y = 2 * x;
} else if (x <= -1) {
y = 2 * x - 1;
}*/
int y;
if (x >= 3) {
y = 2 * x + 1;
} else if (x >= -1 && x < 3) {
y = 2 * x;
} else {
y = 2 * x - 1;
}
System.out.println("y的值是："+y);
}
}
键盘录入两个数据，获取这两个数据的较大值
public class Demo04If {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();
System.out.println("请输入第二个数据：");
int b = sc.nextInt();
//采用if语句格式2实现
/*
if(a>b){
System.out.println("较大的值是："+a);
}else {
System.out.println("较大的值是："+b);
}
*/
//拿到较大的值之后，我未必想直接输出，所以我们定义变量接收这个较大的值
int max;
if(a>b){
max = a;
}else {
max = b;
}
//可能做其他的操作
//max += 100;
System.out.println("较大的值是："+max);
}
}
2.2.2.4 多层条件判断
在复杂的业务逻辑中，可以使用多层的条件判断代码是否执行。
如 60分以下的同学不及格重考，
60分以上的同学不需要重考，
这个区间又可以分为：优秀、良好、及格三个等级。
if(第一层条件){
if(第二层条件){
真正运行逻辑
}
}
/*
多层if语句:if语句嵌套
格式:
if(条件语句){
if(条件语句){
code;
...
}
}
需求:
成绩>= 60
打印成绩合格,可以升级
90-100分:优
80-90分:良
70-80分:中
60-70分:及格
成<60
打印成绩不及格,需要补考
*/
import java.util.Scanner;
public class Demo06If{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的成绩: ");
int score = sc.nextInt();
if(score >= 60 && score <=100){
System.out.println("成绩合格,可以升级");
if(score >=90 && score <=100){
System.out.println("成绩是"+score+",等级为优!");
}else if(score >=80 && score <90){
System.out.println("成绩是"+score+",等级为良!");
}else if(score >=70 && score <80){
System.out.println("成绩是"+score+",等级为中!");
}else{
System.out.println("成绩是"+score+",等级为及格!");
}
}else if(score >=0 && score < 60){
System.out.println("成绩不及格,需要补考");
}else{
System.out.println("非法成绩");
}
System.out.println("程序结束");
}
}
2.3 switch语句
2.3.1 选择结构_switch概念
在现实业务中，许多场景需要我们从多个固定的值中选出一个，执行该数值对应的操作。比如，在一周七天，当输入1-7会打印不同的星期。
对应这样的业务场景，我们可以使用switch选择结构。
2.3.2 格式switch格式
以下为switch语句的格式：
switch (表达式){
case 目标值1:
执行语句1
break;
case 目标值2:
执行语句2
break;
．．．．．．
case 目标值n:
执行语句n
break;
default:
执行语句n+1
break;
}
执行流程
首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
流程图：
在上面的格式中，switch语句将表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，会执行对应case后的语句，如果没找到任何匹配的值，就会执行default后的语句。break的作用是跳出switch语句。
/*
需求:键盘输入对应1-7,输出对应的中文日期
*/
import java.util.Scanner;
public class Demo01Switch{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期对应的数字:");
int week = sc.nextInt();//2
switch(week){
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;
}
System.out.println("程序结束");
}
}
2.3.3 switch注意事项
switch表示这是switch语句
表达式的取值只能是：byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
如同if语句当中的else，default不是必须存在的
与if语句不同，switch语句只能完成具体值的选择，而不能指定取值区间
case后面跟的是要和表达式进行比较的值
语句体部分可以是一条或多条语句
break表示中断，结束的意思，可以结束switch语句
default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
case条件只判断一次，在判断完一次case条件后，所有的case判断语句将不再起作用，而剩余语句征程执行。这是switch语句的穿透。(了解)
/*
需求:键盘输入对应1-7
1-5:输出工作日
6-7:输出休息日
*/
import java.util.Scanner;
public class Demo02Switch{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期对应的数字:");
int week = sc.nextInt();//2
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;
}
System.out.println("程序结束");
}
}
2.3.4 switch案例---超市购物小票输入数量&打印小票&退出操作
2.3.4.1 案例介绍与演示
使用switch语句完成三个分支的代码逻辑
当用户输入1时，让用户输入所要购买的商品数量
当用户输入2时，给用户打印出对应的购物小票
当用户输入3时，退出系统
2.3.4.2 案例分析
a) 输入数量
输入数量可以使用之前学习的Scanner类完成。
导包：java.util.Scanner;
定义变量并创建对象为变量赋值：Scanner xx = new Scaner(System.in);
调用方法，接收数字：int y = xx.nextInt();
b) 打印购物小票
打印购物小票的逻辑与之前相同，分为票头、票体、票脚(见day02)
c) System类的退出程序方法
在System类中有一个可以退出程序的方法,当执行如下语句时，程序退出：System.exit(0);
/*
超市管理系统案例:
------------------超市购物系统-----------------
1:输入购买数量 2:打印购物小票 3:退出系统
请输入您要进行的操作:
分析:
1:初始化系统(进货)
while(true){
2:展示功能菜单
3:获取用户键盘输入的功能选项
4:根据用户输入的功能选项完成对应的功能,用switch语句完成
输入1:实现输入购买数量功能(购买)
输入2:实现打印购物小票功能(打印)
输入3:实现退出系统功能(退出)
输入不存在的数字:您输入有误,请重新输入
}
*/
import java.util.Scanner;
public class SuperMarketMange{
public static void main(String[] args){
//1:初始化系统(进货)
//先定义3组15个变量用来记录商品信息
//定义少林寺酥饼核桃
String slsName = "少林寺酥饼核桃";//商品名称
String slsID = "(090115)";//商品id
double slsPrice = 15.50;//商品单价
int slsNumber = 0;//商品数量
double slsMoney = 0;//商品金额
String xjName = "新疆美味羊肉串";
String xjID = "(090028)";
double xjPrice = 16.00;
int xjNumber = 0;
double xjMoney = 0;
String skName = "尚康杂粮牡丹饼";
String skID = "(090027)";
double skPrice = 14.50;
int skNumber = 0;
double skMoney = 0;
//不知道系统运行几次,所以用while循环
while(true){
//2:展示功能菜单
System.out.println("------------------超市购物系统-----------------");
System.out.println("1:输入购买数量 2:打印购物小票 3:退出系统");
System.out.println("请输入您要进行的操作:");
//3:获取用户键盘输入的功能选项
Scanner sc = new Scanner(System.in);
int choose = sc.nextInt();
//4:根据用户输入的功能选项完成对应的功能,用switch语句完成
switch(choose){
case 1:
//输入1:实现输入购买数量功能(购买)
System.out.println("请输入您要购买"+slsName+"的数量:");
slsNumber = sc.nextInt();
System.out.println("请输入您要购买"+xjName+"的数量:");
xjNumber = sc.nextInt();
System.out.println("请输入您要购买"+skName+"的数量:");
skNumber = sc.nextInt();
//计算每种商品购买的价钱
slsMoney = slsNumber * slsPrice;
xjMoney = xjNumber * xjPrice;
skMoney = skNumber * skPrice;
break;
case 2:
//输入2:实现打印购物小票功能(打印)
//计算:商品种类
int goodsItem = 3;
//计算:商品数量
int goodsNumner = slsNumber + xjNumber + skNumber;
//计算:商品总金额
double goodsMoney = slsMoney + xjMoney + skMoney;
//打印小票
//票头
System.out.println(" 欢 迎 光 临 ");
System.out.println("品名 售价 数量 金额");
System.out.println("------------------------------------------------");
//票体
System.out.println(slsName+slsID+" "+slsPrice+" "+slsNumber+" "+slsMoney);
System.out.println(xjName+xjID+" "+xjPrice+" "+xjNumber+" "+xjMoney);
System.out.println(skName+skID+" "+skPrice+" "+skNumber+" "+skMoney);
System.out.println("------------------------------------------------");
//票脚
System.out.println(" "+goodsItem+" 项商品 共计: "+goodsNumner+" 件");
System.out.println("总计: " + goodsMoney);
System.out.println("凭此小票换取发票!");
break;
case 3:
//输入3:实现退出系统功能(退出)
System.out.println("程序结束!");
System.exit(0);//结束正在运行java虚拟机 0-正常退出
break;
default:
//输入不存在的数字:您输入有误,请重新输入
System.out.println("您输入有误,请重新输入!");
break;
}
}
}
}
第3章 循环结构
3.1 概述
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
3.2 循环语句的组成
循环变量初始化 (初始化表达式)：
一条或者多条语句，这些语句完成一些初始化操作。
循环出口(布尔表达式)：
这是一个boolean 表达式，这个表达式能决定是否执行循环体。
循环逻辑内容(循环体)：
这个部分是循环体语句，也就是我们要多次做的事情。
循环增量(步进表达式)：
这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。
3.3 for循环
for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。
3.3.1 for循环语句的语法格式
格式：
for(初始化表达式①；布尔表达式②；步进表达式④){
循环体③
}
执行流程：
执行顺序： ①②③④>②③④>②③④… ②不满足为止。
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况
流程图：
/*
循环语句for:最常用的循环语句,一般用于已知循环次数
循环变量初始化 (初始化表达式)
循环出口(布尔表达式)
循环增量(步进表达式)
循环逻辑内容(循环体)
格式:
for(初始化表达式①；布尔表达式②；步进表达式④){
循环体③
}
执行顺序： ①②③④>②③④>②③④… ②不满足为止。
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况
需求:打印10次我爱java
*/
public class Demo07For{
public static void main(String[] args){
//打印10次我爱java
for(int x=0; x<10; x++){
System.out.println("我爱java!"+(x+1));
}
System.out.println("程序结束!");
}
}
3.3.2 for循环注意事项
a) ①②③④四个部分均可以为空
当①为空时，注意变量作用域的范围变化
当②为空时，为条件永远为true的死循环
当③为空时，通常没有意义
当④为空时，可以将其加入到循环体中，或同样成为死循环
b) 初始化表达式①的部分可以同时定义多个变量
步进表达式可以同时将多个循环相关变量改变，控制循环条件
/*
格式:
for(初始化表达式①；布尔表达式②；步进表达式④){
循环体③
}
执行顺序： ①②③④>②③④>②③④… ②不满足为止。
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况
for循环注意事项
a) ①②③④四个部分均可以为空
当①为空时，注意变量作用域的范围变化
当②为空时，为条件永远为true的死循环
当③为空时，通常没有意义
当④为空时，可以将其加入到循环体中，或同样成为死循环
b) 初始化表达式①的部分可以同时定义多个变量
步进表达式可以同时将多个循环相关变量改变，控制循环条件
*/
public class Demo08For{
public static void main(String[] args){
//打印10次我爱java
//当①为空时，注意变量作用域的范围变化
/*
int x=0;
for(; x<10; x++){
System.out.println("我爱java!"+(x+1));
}
//System.out.println(x);错误: 找不到符号
System.out.println(x);
*/
//当②为空时，为条件永远为true的死循环
/*
for(int x=0; ; x++){
System.out.println("我爱java!"+(x+1));
}
*/
//System.out.println("程序结束!");错误: 无法访问的语句
//当③为空时，通常没有意义
/*
for(int x=0; x<10; x++){
}
*/
//当④为空时，可以将其加入到循环体中，或同样成为死循环
/*
for(int x=0; x<10; ){
System.out.println("我爱java!"+(x+1));
//x++;
}
*/
/*
b) 初始化表达式①的部分可以同时定义多个变量
步进表达式可以同时将多个循环相关变量改变，控制循环条件
*/
for(int x=0,y=0; x<10; x++,y +=2){
System.out.println("x = " + x + " y = " + y);
}
}
}
3.3.3 练习
3.3.3.1 在控制台输出10次HelloWorld
public class Demo01For {
public static void main(String[] args) {
//原始写法
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("-------------------------");
//用循环改进
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld"+x);
}
}
}
3.3.3.2 获取数据1-5 和5-1
public class Demo02For {
public static void main(String[] args) {
//原始写法
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println("---------------------");
//使用for循环
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
System.out.println("---------------------");
//5-1
for (int i = 5; i>=1; i--) {
System.out.println(i);
}
}
}
3.3.3.3 求出1-5之间数据之和
public class Demo03For {
public static void main(String[] args) {
//1.定义一个初始化变量,记录累加求和,默认值为0
int sum = 0;
//2.使用for循环获取1-5之间的数据
for (int i = 1; i <= 5; i++) {
//3.把每一次for循环获取到的数据累加起来
/*
* 第一次:sum = 0 + 1 = 1
* 第二次:sum = 1 + 2 = 3
* 第三次:sum = 3 + 3 = 6
* 第四次:sum = 6 + 4 = 10
* 第五次:sum = 10 + 5 = 15
*/
//sum = sum + i;
sum += i;
}
//4.循环结束之后,打印累加结果
System.out.println("sum:"+sum);
}
}
3.3.3.4 求出1-100之间偶数和
public class Demo04For {
public static void main(String[] args) {
//1.定义一个初始化变量,记录累加求和,初始值为0
int sum = 0;
//2.利用for循环获取1-100之间的数字
for (int i = 1; i <= 100; i++) {
//3.判断获取的数组是奇数还是偶数
if(i%2==0){
//4.如果是偶数就累加求和
sum += i;
}
}
//5.循环结束之后,打印累加结果
System.out.println("sum:"+sum);
}
}
3.3.3.5 在控制台输出所有的“水仙花数”
所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
举例：153就是一个水仙花数。
153 = 1*1*1 + 5*5*5 + 3*3*3
public class Demo05For {
public static void main(String[] args) {
//使用for循环获取所有的三位数
for (int i = 100; i < 1000; 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){
System.out.println(i);
}
}
}
}
3.3.3.6 统计“水仙花数”共有多少个
public class Demo06For {
public static void main(String[] args) {
//1.定义一个统计变量,初始值为0
int count = 0;
//2.使用for循环获取所有的三位数
for(int x=100; x<1000; x++) {
//3.拆分三位数的百位,十位,个位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//4.利用公式判断这个三位数是否为水仙花数,如果是,统计变量++
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
}
//5.循环结束之后,打印统计结果
System.out.println("水仙花数共有："+count+"个");
}
}
3.4 循环结构_while
3.4.1 while循环语句使用语法格式
基本格式
while(布尔表达式) {
循环体语句;
}
扩展格式
初始化表达式①
while(布尔表达式②){
循环体③
步进表达式④
}
执行流程
执行顺序： ①②③④>②③④>②③④… ②不满足为止。
①负责完成循环变量初始化。
②负责判断是否满足循环条件，不满足则跳出循环。
③具体执行的语句。
④循环后，循环变量的变化情况。
流程图
3.4.2 练习
3.4.2.1 输出10次HelloWorld
public class Demo01While {
public static void main(String[] args) {
//使用for循环打印10次HelloWorld
for (int i = 1; i <=10; i++) {
System.out.println("HelloWorld");
}
System.out.println("--------------------");
//while循环实现打印10次HelloWorld
int i = 1;
while(i<=10){
System.out.println("HelloWorld");
i++;
}
}
}
3.4.2.2 求出1-100之和
public class Demo02While {
public static void main(String[] args) {
//回顾for循环 求1-100之和
//定义一个变量,记录累加求和
int sum = 0;
//利用for循环获取1-100之间的数字
for (int i = 1; i <= 100; i++) {
//累加求和
sum += i ;
}
//打印求和的变量
System.out.println("1-100的和是："+sum);
//使用while循环实现
//定义一个变量,记录累加求和
sum = 0;
//定义初始化表达式
int i = 1;
//使用while循环让初始化表达式的值变化
while(i<=100){
//累加求和
sum += i ;
//步进表达式改变变量的值
i++;
}
//打印求和的变量
System.out.println("1-100的和是："+sum);
}
}
3.4.2.3 While统计水仙花数有多少个(学生自己练习)
package StudyJavaSE;
public class WhileShuiXianhuashu {
public static void main(String[] args) {
//1.定义一个统计变量,初始值为0
int count = 0;
//2.使用for循环获取所有的三位数
for(int x=100; x<1000; x++) {
//3.拆分三位数的百位,十位,个位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//4.利用公式判断这个三位数是否为水仙花数,如果是,统计变量++
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
}
System.out.println("水仙花数共有："+count+"个");
count = 0;
//1.定义一个统计变量,初始值为100
int x = 100;
//2.使用while循环获取所有的三位数
while (x<1000) {
//3.拆分三位数的百位,十位,个位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//4.利用公式判断这个三位数是否为水仙花数,如果是,统计变量++
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
x++;
}
//5.循环结束之后,打印统计结果
System.out.println("水仙花数共有："+count+"个");
}
}
3.4.3 while循环注意事项
与for循环的循环变量作用域不同，for循环的循环变量其作用域仅限于循环体内，而while循环的循环变量作用域不局限在循环体内。
与for循环的循环条件为空是是死循环不同，while循环的循环条件不能为空。
我们经常会使用while(true)的方式根据需求完成一个死循环。
3.4.4 do while循环语句语法格式
基本格式
do {
循环体语句;
}while(布尔表达式);
扩展格式
初始化表达式①
do{
循环体③
步进表达式④
}while(布尔表达式②);
执行流程
执行顺序： ①③④>②③④>②③④… ②不满足为止。
①负责完成循环变量初始化。
②负责判断是否满足循环条件，不满足则跳出循环。
③具体执行的语句
④循环后，循环变量的变化情况
流程图
3.4.5 do while循环注意事项
do while循环的使用特点为无论是否满足条件，均至少会执行一次。
do while循环在日常开发中遇到的较少。
3.4.6 练习
3.4.6.1 输出10次HelloWorld
public class Demo01DoWhile {
public static void main(String[] args) {
//输出10次 HelloWorld
/*
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
*/
//do...while改写
int x=1;
do {
System.out.println("HelloWorld");
x++;
}while(x<=10);
}
}
3.4.6.2 求出1-100之和(学生自己练习)
package StudyJavaSE;
/**
* do while 循环求出1-100之和。
* @author 奋斗蒙
*
*/
public class WhileBaiSum {
public static void main(String[] args) {
int sum = 0;
//使用while循环实现
//定义一个变量,记录累加求和
sum = 0;
//定义初始化表达式
int i = 1;
//使用while循环让初始化表达式的值变化
while(i<=100){
//累加求和
sum += i ;
//步进表达式改变变量的值
i++;
}
//打印求和的变量
System.out.println("1-100的和是："+sum);
do {
System.out.println("1-100的和是："+sum);
//累加求和
sum += i;
//步进表达式改变变量的值
i++;
} while (i<=100);
}
}
3.4.6.3 统计水仙花数有多少个(学生自己练习
package StudyJavaSE;
/**
* do while求水仙花数有多少个
* @author 奋斗蒙
*/
public class DoWhile {
public static void main(String[] args) {
int count = 0;
// 1.定义一个统计变量,初始值为100
int x = 100;
// 2.使用while循环获取所有的三位数
while (x < 1000) {
// 3.拆分三位数的百位,十位,个位
int ge = x % 10;
int shi = x / 10 % 10;
int bai = x / 10 / 10 % 10;
// 4.利用公式判断这个三位数是否为水仙花数,如果是,统计变量++
if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == x) {
count++;
}
x++;
}
// 5.循环结束之后,打印统计结果
System.out.println("水仙花数共有：" + count + "个");
do {
// 5.循环结束之后,打印统计结果
System.out.println("水仙花数共有：" + count + "个");
// 3.拆分三位数的百位,十位,个位
int ge = x % 10;
int shi = x / 10 % 10;
int bai = x / 10 / 10 % 10;
// 4.利用公式判断这个三位数是否为水仙花数,如果是,统计变量++
if ((ge * ge * ge + shi * shi * shi + bai * bai * bai) == x) {
count++;
}
x++;
} while (x< 1000);
}
}
3.4.7 While与do_while比较
3.4.7.1 需求:打印5次我爱java
/*
需求:打印5次我爱java
*/
public class Demo09WhileAndDoWhile{
public static void main(String[] args){
//while
//int i = 0;
int i = 5;
while(i < 5){
System.out.println("我爱java"+(i+1));
i++;
}
//System.out.println(i);
System.out.println("----------------------------------");
//do while
//int j = 0;
int j = 5;
do{
System.out.println("我爱java"+(j+1));
j++;
}while(j < 5);
}
}
3.5 循环嵌套
循环嵌套并不是一个新的知识点。只是在循环格式中嵌套使用了循环。
如for循环可以嵌套for循环：
for(初始化表达式; 循环条件; 操作表达式) {
………
for(初始化表达式; 循环条件; 操作表达式) {
执行语句
………
}
………
}
3.5.1 循环嵌套练习:
3.5.1.1 3排同学进行报数,每组5名同学,打印出我是第x排,第x个!
/*
循环嵌套:循环里边嵌套一个循环
最常用的格式:
for(){
for(){
}
}
需求:3排同学进行报数,每排5名同学,打印出我是第x排,第x个!
大毛,二毛,三毛,四毛,小明
小芳,杨幂,赵丽颖,高圆圆,杨颖
c罗,梅西,大罗,内马尔,柳岩
我是第1排,第1个!
我是第1排,第2个!
我是第1排,第3个!
我是第1排,第4个!
我是第1排,第5个!
我是第2排,第1个!
我是第2排,第2个!
我是第2排,第3个!
我是第2排,第4个!
我是第2排,第5个!
我是第3排,第1个!
我是第3排,第2个!
我是第3排,第3个!
我是第3排,第4个!
我是第3排,第5个!
*/
public class Demo10ForFor{
public static void main(String[] args){
for(int i=0; i<3; i++){//外层循环可以控制打印的行数
//System.out.println("我是第"+(i+1)+"排");
for(int j=0; j<5; j++){//内层循环可以控制每行打印几个
//System.out.println("我是第"+(j+1)+"个");
System.out.println("我是第"+(i+1)+"排,第"+(j+1)+"个!");
}
}
}
}
3.6 三种循环的区别
虽然可以完成同样的功能，但是还是有小区别：
do…while循环至少会执行一次循环体。
for循环和while循环只有在条件成立的时候才会去执行循环体
for循环语句和while循环语句的小区别：
使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
循环使用推荐for -- while -- do..while
public class Demo02DoWhile {
public static void main(String[] args) {
/*
int x = 3;
while(x<3) {
System.out.println("我爱柳岩");
x++;
}
System.out.println("--------------");
int y = 3;
do {
System.out.println("我爱柳岩");
y++;
}while(y<3);
*/
for(int x=1; x<=10; x++){
System.out.println("爱生活，爱Java");
}
//这里的x无法继续访问
//System.out.println(x);
System.out.println("-----------------");
int y = 1;
while(y<=10) {
System.out.println("爱生活，爱Java");
y++;
}
System.out.println(y);
}
}
3.7 无条件分支跳转
在loop/switch选择或者循环过程中，我们总是满足布尔表达条件才能执行对应的代码，然而在这些逻辑过程中，可以使用一些关键字直接跳出正在执行的代码，去执行后边或者指定位置的代码，这些关键字一旦出现就可以跳转语句执行顺序。
break 中断
continue 继续
3.7.1 break关键字
用来跳出switch语句和循环语句
break使用方式
无法单独使用，必须将break关键字置于switch或循环语句中。
break运行规律
不需要判断任何条件，只要遇到break便直接跳出执行后续代码。会完全跳出选择或者循环结构。
break只能跳出最近的代码块，不能跨越多级代码块。
如：
for(int i=0; i<10; i++) {
if(i==5) {
break;
}
System.out.println(“我爱Java”+i);
}
//会从0-4输出5次“我爱Java”
/*
break语句:可以实现跳出循环
break使用方式
无法单独使用，必须将break关键字置于switch或循环语句中。
break运行规律
不需要判断任何条件，只要遇到break便直接跳出执行后续代码。会完全跳出选择或者循环结构。
break只能跳出最近的代码块，不能跨越多级代码块(多层循环)。
*/
public class Demo11Break{
public static void main(String[] args){
//无法单独使用，必须将break关键字置于switch或循环语句中。
//break;// 错误: 在 switch 或 loop 外部中断
//打印10次我想有个女同桌
//打印10次我想有个女同桌 在打印完第三次的时候跳出循环
/*
for(int i=0; i<10; i++){
if(i==3){
System.out.println("重要是事情说三遍就够了");
break;
}
System.out.println("我想有个女同桌"+(i+1));
}
System.out.println("程序结束");
*/
//需求:就让第一排同学报数
for(int i=0; i<3; i++){//外层循环可以控制打印的行数
//System.out.println("我是第"+(i+1)+"排");
for(int j=0; j<5; j++){//内层循环可以控制每行打印几个
//System.out.println("我是第"+(j+1)+"个");
if(i==1){
break;
}
System.out.println("我是第"+(i+1)+"排,第"+(j+1)+"个!");
}
}
}
}
3.7.2 continue关键字
continue使用方式
无法单独使用，必须将continue关键字置于循环语句中。
continue运行规律
不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环。
如：
for(int i=0; i<10; i++) {
if(i==5) {
continue;
}
System.out.println(“我爱Java”+i);
}
//会从0-4、6-9输出9次“我爱Java”
/*
continue语句:跳出本次循环,执行下一次循环
continue使用方式
无法单独使用，必须将continue关键字置于循环语句中。
continue运行规律
不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环。
*/
public class Demo12Continue{
public static void main(String[] args){
//continue;//错误: continue 在 loop 外部
/*
我想有个女同桌1
我想有个女同桌2
我想有个女同桌3
重要是事情说三遍就够了
我想有个女同桌5
我想有个女同桌6
我想有个女同桌7
我想有个女同桌8
我想有个女同桌9
我想有个女同桌10
*/
/*
for(int i=0; i<10; i++){
if(i==3){
System.out.println("重要是事情说三遍就够了");
continue;
}
System.out.println("我想有个女同桌"+(i+1));
}
System.out.println("程序结束");
*/
//需求:打印1-10之间的奇数
/*
1
3
5
7
9
*/
for(int i=0; i<10; i++){
if(i % 2 ==0){
continue;
//break;
}
System.out.println(i);
}
}
}
3.7.3 练习: 按要求分析结果，并验证
public class Demo03BreakAndContinue {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) {
// 分别写break，continue，说说输出几次
//break;//输出2次
continue;//输出7次
}
System.out.println("我爱Java!"+i);
}
}
}
3.7.4 标号语句(标签)跳转
当在双层循环或者循环内有switch选择语句时，我们发现，使用break或者continue所作用的对象均是内层语句，无法直接跳出外层循环，这时就需要使用标号语句跳转了。
表达语句跳转的使用方式
在外层循环外的某行前边，使用后边跟有冒号”:”的标识符，即定义完毕。
使用时当在内层循环使用break或continue时后边紧跟之前定义的标号即可。
表达语句跳转的运行规律
当外层循环外定义了标号
内层使用break，终止内外双层循环。
内层使用continue，终止内层循环，继续外层循环。
/*
标号:可以实现跳出多层循环
使用格式:
break 标号;
表达语句跳转的使用方式
在外层循环外的某行前边，使用后边跟有冒号”:”的标识符，即定义完毕。
使用时当在内层循环使用break或continue时后边紧跟之前定义的标号即可。
表达语句跳转的运行规律
当外层循环外定义了标号
内层使用break，终止内外双层循环。
内层使用continue，终止内层循环，继续外层循环。
continue标号
使用格式:
continue 标号;
*/
public class Demo13Break{
public static void main(String[] args){
//需求:就让第一排同学报数
/*
break
我是第1排,第1个!
我是第1排,第2个!
我是第1排,第3个!
我是第1排,第4个!
我是第1排,第5个!
第一排同学报数结束
continue
我是第1排,第1个!
我是第1排,第2个!
我是第1排,第3个!
我是第1排,第4个!
我是第1排,第5个!
第一排同学报数结束
我是第3排,第1个!
我是第3排,第2个!
我是第3排,第3个!
我是第3排,第4个!
我是第3排,第5个!
*/
itcast:for(int i=0; i<3; i++){//外层循环可以控制打印的行数
//System.out.println("我是第"+(i+1)+"排");
for(int j=0; j<5; j++){//内层循环可以控制每行打印几个
//System.out.println("我是第"+(j+1)+"个");
if(i==1){
System.out.println("第一排同学报数结束");
//break itcast;
continue itcast;
}
System.out.println("我是第"+(i+1)+"排,第"+(j+1)+"个!");
}
}
}
}
第4章 综合案例---猜数字小游戏
4.1 案例介绍与演示
完成猜数字小游戏：
后台预先生成一个随机数1-100，用户键盘录入猜数字
如果猜对了，打印“恭喜您，答对了”
如果猜错了
猜大了：打印“sorry，您猜大了!”
猜小了：打印“sorry，您猜小了!”
直到数字猜到为止
最多只能猜5次，否则提示“sorry，您没有机会了!”
4.2 案例分析
猜数字小游戏案例共需要三个部分：生成随机数、进行逻辑判断、循环输入并且完成次数限制。
4.2.1 生成随机数
使用算法完成随机数生成的过于复杂，Java已经提供好的完成随机数相关操作的引用数据类型Random。
import导入Random所在包：java.util.Random
创建实例格式：Random random = new Random ();
调用方法，生成1-100随机数int randomNumber= random.nextInt(100) + 1;
4.2.2 进行逻辑判断
需求：
如果猜对了，打印“恭喜您，答对了”
如果猜错了
猜大了：打印“sorry，您猜大了!”
猜小了：打印“sorry，您猜小了!”
分析以上逻辑：
猜数字的核心逻辑是两个数字的比较，即用户输入的数字与给定的随机数的大小比较。使用三元运算符可以完成，但是三元运算符只能完成简单的二选一。想完成更复杂的需求需要使用到if语句。
4.2.3 循环输入并且完成次数限制
我们需要在用户输错时，让用户再次输入，让用户输入的动作循环执行。这时需要使用到循环语句，这里选择for循环完成循环输入并且完成次数限制。
循环过程中，循环体包含提示用户输入，用户键盘录入，数字大小判断。
分析需求：最多只能猜5次，否则提示“sorry，您没有机会了!”
循环满足条件为两个：
只要答对即可跳出循环(使用break)
循环次数超出5次(for循环的5次循环判断)
/*
猜数字小游戏:
分析:
后台预先生成一个随机数1-100 -->Random类
用户键盘录入猜数字 -->Scanner类
if语句
如果猜对了，打印“恭喜您，答对了”
如果猜错了
猜大了：打印“sorry，您猜大了!”
猜小了：打印“sorry，您猜小了!”
循环的知识-->for
直到数字猜到为止
最多只能猜5次，否则提示“sorry，您没有机会了!”
*/
import java.util.Random;
import java.util.Scanner;
public class GuessNumber{
public static void main(String[] args){
//后台预先生成一个随机数1-100 -->Random类
Random r = new Random();
int randomNumber = r.nextInt(100)+1;//1-100
System.out.println("1-100之间的随机数已经产生,开始我们的猜数字小游戏!");
System.out.println("randomNumber = " + randomNumber);
//用户键盘录入猜数字 -->Scanner类
Scanner sc = new Scanner(System.in);
//直到数字猜到为止,最多只能猜5次
for(int i=0 ;i<5; i++){
System.out.println();
System.out.println("请输入一个1-100之间的整数: ");
int guessNumber = sc.nextInt();//获取键盘输入的整数
/*
if语句
如果猜对了，打印“恭喜您，答对了”
如果猜错了
猜大了：打印“sorry，您猜大了!”
猜小了：打印“sorry，您猜小了!”
*/
if(guessNumber == randomNumber){//如果猜对了，打印“恭喜您，答对了”
System.out.println("恭喜您，答对了");
break;//猜对了,跳出循环
}else{
if(guessNumber > randomNumber){//猜大了：打印“sorry，您猜大了!”
System.out.println("sorry，您猜大了!");
}else{//猜小了：打印“sorry，您猜小了!”
System.out.println("sorry，您猜小了!");
}
}
// 最多只能猜5次，否则提示“sorry，您没有机会了!”
if(i==4){
System.out.println("您已经猜了"+(i+1)+"次了,sorry，您没有机会了!");
}else{
System.out.println("您还剩"+(4-i)+"次机会,请好好把握!");
}
}
}
}
第5章 本日自习作业：
5.1 知识点相关题
5.1.1 题目：Scanner输入并打印变量值
定义类：Test1，定义main()方法，按以下步骤编写代码：
A. 导入Scanner类；
B. 在main()方法中实例化Scanner对象；
C. 打印：请输入你的姓名：
D. 定义变量，接收用户输入(调用next()方法)；
E. 打印：请输入你的年龄：
F. 定义变量，接收用户输入(调用nextInt()方法)；
G. 打印：请输入你的身高(单位：米)：
H. 定义变量，接收用户输入(调用nextDouble()方法)；
I. 分三行打印三个变量的值；
代码实现：
public class Test {
@SuppressWarnings("resource")
public static void main(String[] args) {
// A.导入Scanner类；
// B.在main()方法中实例化Scanner对象；
Scanner sc = new Scanner(System.in);
// C.打印：请输入你的姓名：
System.out.println("请输入你的姓名：");
// D.定义变量，接收用户输入(调用next()方法)；
String ss = sc.next();
// E.打印：请输入你的年龄：
System.out.println("请输入你的年龄:");
// F.定义变量，接收用户输入(调用nextInt()方法)；
int age = sc.nextInt();
// G.打印：请输入你的身高(单位：米)：
System.out.println("请输入你的身高(单位：米)：");
// H.定义变量，接收用户输入(调用nextDouble()方法)；
int hegiht = sc.nextInt();
// I.分三行打印三个变量的值；
System.out.println(ss);
System.out.println(age);
System.out.println(hegiht);
}
}
5.1.2 题目：判断18岁以上为成年
定义类：Test2，定义main()方法，按以下步骤编写代码：
A. 导入Scanner类；
B. 在main()方法中实例化Scanner对象；
C. 打印：请输入你的年龄：
D. 定义变量，接收用户输入；
E. 判断此变量：
如果18岁以上，打印：你成年了
否则，打印：你未成年
代码实现：
public class Test {
@SuppressWarnings("resource")
public static void main(String[] args) {
// A.导入Scanner类；
// B.在main()方法中实例化Scanner对象；
Scanner sc = new Scanner(System.in);
// C.打印：请输入你的年龄：
System.out.println("请输入你的年龄：");
// D.定义变量，接收用户输入；
int ii = sc.nextInt();
// E.判断此变量：
// 如果18岁以上，打印：你成年了
// 否则，打印：你未成年
if (ii>18) {
System.out.println("你成年了");
}else{
System.out.println("你未成年");
}
}
}
5.1.3 判断1—100之间（包含1不包括100）的数字，将此数字打印
定义类：Test3，定义main()方法，按以下要求编写代码：(此例需要Scanner，不再列出具体步骤)
A. 请用户输入一个数字；
B. 判断这个数字：
如果是1—100之间（包含1不包括100）的数字，将此数字打印；
否则，提示用户：请输入1—100之间的数字；
代码上实现：
public class Test {
@SuppressWarnings("resource")
public static void main(String[] args) {
// A.请用户输入一个数字；
Scanner sc = new Scanner(System.in);
int ii = sc.nextInt();
// B.判断这个数字：
// 如果是1—100之间的数字，将此数字打印；
// 否则，提示用户：请输入1—100之间的数字；
if (ii>=1&&ii<100) {
System.out.println("这个数值是"+ii);
}else{
System.out.println("请输入1—100之间的数字；");
}
}
}
5.1.4 题目：判断年龄段，婴儿，少儿，少年，青年，中年，老年
定义类：Test5，定义main()方法，按以下要求编写代码：(此例需要Scanner)
A. 请用户输入一个年龄；
B. 判断年龄：
1—3岁：打印：婴儿
4—9岁：打印：少儿
10—17岁：打印：少年
18—45岁：打印：青年
46—60岁：打印：中年
60以上：打印：老年
否则：错误的年龄！
代码实现：
public class Test {
@SuppressWarnings("resource")
public static void main(String[] args) {
// A.请用户输入一个数字：
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个年龄：");
int int1 = sc.nextInt();
// B.判断年龄：
// 1—3岁：打印：婴儿
// 4—9岁：打印：少儿
// 10—17岁：打印：少年
// 18—45岁：打印：青年
// 46—60岁：打印：中年
// 60以上：打印：老年
// 否则：错误的年龄！
if (int1>0&&int1<4) {
System.out.println("婴儿");
}else if(int1>3&&int1<10){
System.out.println("少儿");
}else if(int1>9&&int1<18){
System.out.println("少年");
}else if(int1>17&&int1<46){
System.out.println("青年");
}else if(int1>45&&int1<61){
System.out.println("中年");
}else if(int1>60){
System.out.println("老年");
}else{
System.out.println("错误的年龄！");
}
}
}
5.1.5 1：熟练使用switch，完成下边练习：
一年有12个月，当输入3-5时，输出春天，6-8时，输入夏天，以此类推
package StudyJavaSE;
import java.util.Scanner;
/**
* 一年有12个月，当输入3-5时，输出春天，6-8时，输入夏天，以此类推
* @author 奋斗蒙
*
*/
public class Switch {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入月份：（1-12的整数）");
int x = sc.nextInt();
switch (x) {
case 12:
case 1:
case 2:
System.out.println(x+"月份是冬天，注意保暖");
break;
case 3:
case 4:
case 5:
System.out.println(x+"月份是春天，注意防风");
break;
case 6:
case 7:
case 8:
System.out.println(x+"月份是夏天，注意防晒");
break;
case 9:
case 10:
case 11:
System.out.println(x+"月份是秋天，好吃的可多了");
default:
System.out.println("请输入1——12的整数，谢谢。");
break;
}
}
}
5.1.6 附加题：根据工龄判断员工薪资（学生做）
分析以下需求，并用代码实现：
根据工龄(整数)给员工涨工资(整数),工龄和基本工资通过键盘录入
涨工资的条件如下：
[10-15) +5000
[5-10) +2500
[3-5) +1000
[1-3) +500
[0-1) +200
例如:用户输入的工龄为10，基本工资为3000，程序运行后打印格式:
您目前工作了10年，基本工资为 3000元, 应涨工资 5000元,涨后工资 8000元"
------------------------------------------------------------------
package StudyJavaSE;
import java.util.Scanner;
/**
* 根据工龄(整数)给员工涨工资(整数),工龄和基本工资通过键盘录入
* 涨工资的条件如下：
* [10-15) +5000
* [5-10) +2500
* [3-5) +1000
* [1-3) +500
* [0-1) +200
* 例如:用户输入的工龄为10，基本工资为3000，程序运行后打印格式:
* 您目前工作了10年，基本工资为 3000元, 应涨工资 5000元,涨后工资 8000元"
*/
public class Emp {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入查询员工的工龄：");
int x = sc.nextInt();
int jMoney = 3000;
if (x >= 10 & x < 15) {
// 应该涨工资
int zMoney = 5000;
// 涨后工资
int zhMoney = jMoney + zMoney;
System.out.println("您输入的工龄是 " + x + " 年，基本工资为3000，应涨工资" + zMoney + ",涨后工资为" + zhMoney);
}
if (x >= 5 & x < 10) {
// 应该涨工资
int zMoney = 2500;
// 涨后工资
int zhMoney = jMoney + zMoney;
System.out.println("您输入的工龄是 " + x + " 年，基本工资为3000，应涨工资" + zMoney + ",涨后工资为" + zhMoney);
}
if (x >= 3 & x < 5) {
// 应该涨工资
int zMoney = 1000;
// 涨后工资
int zhMoney = jMoney + zMoney;
System.out.println("您输入的工龄是 " + x + " 年，基本工资为3000，应涨工资" + zMoney + ",涨后工资为" + zhMoney);
}
if (x >= 1 & x < 3) {
// 应该涨工资
int zMoney = 500;
// 涨后工资
int zhMoney = jMoney + zMoney;
System.out.println("您输入的工龄是 " + x + " 年，基本工资为3000，应涨工资" + zMoney + ",涨后工资为" + zhMoney);
}
if (x >= 0 & x < 1) {
// 应该涨工资
int zMoney = 200;
// 涨后工资
int zhMoney = jMoney + zMoney;
System.out.println("您输入的工龄是 " + x + " 年，基本工资为3000，应涨工资" + zMoney + ",涨后工资为" + zhMoney);
}
}
}
5.2 代码题
5.2.1 熟练使用Random生成指定区间M-N的随机数(选做)
package StudyJavaSE;
//1.导包
import java.util.Random;
/**
* 生成Random随机数，范围在M-N之间
* 这里生成99-999之间的随机数
* @author 奋斗蒙
*
*/
public class RandomMN {
public static void main(String[] args) {
//2.创建Random对象，为Random变量赋值
Random r = new Random();
//通过 变量名.方法，获取Random类中的方法
int Min = 99;
int Max = 999;
int result = (int) (Min + (Math.random() * ((Max - Min) + 1)));
System.out.println("随机数是："+result);
}
}
5.2.2 使用for循环，完成求1-999之间的偶数和
package StudyJavaSE;
/**
* for循环
* @author 奋斗蒙
*
*/
public class For1 {
public static void main(String[] args) {
//1.定义一个初始化变量,记录累加求和,初始值为0
int sum = 0;
//2.利用for循环获取1-199之间的数字
for (int i = 1; i <= 999; i++) {
//3.判断获取的数组是奇数还是偶数
if(i%2==0){
//4.如果是偶数就累加求和
sum += i;
}
}
//5.循环结束之后,打印累加结果
System.out.println("sum:"+sum);
}
}
5.2.3 使用while循环，完成求1-999之间3的整数倍的和
要求：
使用while循环，完成求1-999之间3的整数倍的累加和，最后打印累加和的值
/*
使用while循环，完成求1-999之间3的整数倍的和
*/
public class Demo01{
public static void main(String[] args){
int sum = 0;//用来记录累加和
int i = 1;
while(i<=999){
if(i % 3 == 0){
sum += i;//累加求和
}
i++;
}
System.out.println("1-999之间3的整数倍的和为: " + sum);
}
}
要求：
写一个程序输入3个整数a,b,c，按从小到大顺序输出。
答案：
import java.util.Scanner;
public class Demo02{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a, b, c;
System.out.println("请输入三个数");
a = sc.nextInt();
b = sc.nextInt();
c = sc.nextInt();
int e;//用于两个数交换的中间数
//求出a,b中最小的数
if (a > b) {
e = a;
a = b;
b = e;
}
//求出a,c中最小的数
if (a > c) {
e = a;
a = c;
c = e;
}
//求出b,c中最小的数
if (b > c) {
e = b;
b = c;
c = e;
}
System.out.println("三个数由小到大为：" + a + " " + b + " " + c);
}
}
5.2.4 写一个程序判断-10到10的数是奇数还是偶数
要求：
写一个程序判断-10到10的数是奇数还是偶数,打印出如下效果
-10 是负偶数
-9 是负奇数
-8 是负偶数
-7 是负奇数
-6 是负偶数
-5 是负奇数
-4 是负偶数
-3 是负奇数
-2 是负偶数
-1 是负奇数
0 既不是奇数也不是偶数!
1 是正奇数
2 是正偶数
3 是正奇数
4 是正偶数
5 是正奇数
6 是正偶数
7 是正奇数
8 是正偶数
9 是正奇数
10 是正偶数
答案：
public class Demo03 {
public static void main(String[] args) {
for (int i = -10; i <= 10; i++) {
if (i == 0) {
System.out.println("0 既不是奇数也不是偶数!");
} else if (i % 2 == 0) {
if (i < 0) {
System.out.println(i + " 是负偶数");
} else {
System.out.println(i + " 是正偶数");
}
} else {
if (i < 0) {
System.out.println(i + " 是负奇数");
} else {
System.out.println(i + " 是正奇数");
}
}
}
}
}
