第三天 引用类型&选择结构&循环结构【悟空教程】

第三天 引用类型&选择结构&循环结构【悟空教程】

第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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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. 分三行打印三个变量的值；

代码实现：

publicclassTest {

@SuppressWarnings("resource")

public static voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 voidmain(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 + "是正奇数");

}

}

}

}

}