01引用类型简单了解--使用方法
* A: 创建引用类型变量公式
* a： 创建引用类型变量前，需要先导包
导包必须导到该引用类的最后一级文件夹。
导包快捷键：shift+o
* b: 创建引用类型的变量
* 与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。
* 数据类型 变量名 = new 数据类型();
* c: 引用数据类型的使用
* 每种引用数据类型都有其功能，我们可以调用该类型实例的功能。
* 变量名.方法名();
02引用类型Scanner类的使用
我们要学的Scanner类是属于引用数据类型
* A: Scanner类的使用
* a: 导包import java.util.Scanner;
* b：创建键盘录入对象 Scanner sc = new Scanner(System.in);
* c: 调用方法：
* int enterNumber = sc.nextInt();//读取键盘录入的一个整数
* int num =sc.nextDouble();//读取键盘录入的一个浮点数
* String enterString = sc.next();//读取键盘录入的字符串
* B: 案例代码
import java.util.Scanner;
public class Demo05Scanner{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int enterNumber = sc.nextInt();
System.out.println("用户输入的整数为"+enterNumber);
String enterString = sc.next();
System.out.println("用户输入的字符串为"+enterString);
}
}
*Scanner类常用方法：
Scanner sc = new Scanner (System.in);
int a = sc.nextInt();//接受int型。 注意：输入字符串会异常
double b = sc.nextDouble();//接受double型。 注意：输入字符串会异常
String s = sc.next()//接受String型 输入的数字，会转化为字符串，不会异常
接受符号和空格，回车之外的所有字符，光标指向本行
sc.nextLin()//接受除回车外的所有字符和符号，光标指向下一行
03Random随机数类的使用
* A: Random随机数类的使用_1
* a: 功能
* 生成随机数需要使用到引用类型随机数Random类
* b: 使用方式
* import导包：所属包java.util. Random
* 创建实例格式：Random random = new Random ();
* 调用方法
* nextInt(int maxValue) 产生[0,maxValue)范围的随机数,包含0不包含maxValue
* nextDouble() 产生[0,1)范围的随机数
如：
Random random = new Random ();
int myNumber = random.nextInt(100);//结果为0-99的一个数
* B: 案例代码
import java.util.Random;
public class RandomDemo{
public static void main(String[] args){
Random ran = new Random();
// Random类中的,产生随机[0,100)的功能
int i = ran.nextInt(100);//产生0-99的整数，不包括100
System.out.println(i);
// 产生[0,1)范围的随机数
double j = ran.nextDouble();//产生[0,1)范围的随机数
System.out.println(j);
//问题? 产生随机数,范围 1-100之间
// nextInt(100) 0-99 + 1
}
}
04Random随机数类的伪随机
java中产生的随机数都成为伪随机数，即不是正真的随机数，而是虚拟机根据人写的算法，生成出来的。
产生随机数的规律根据算法而定（编写该随机数算法的人，必然知道随机数产生的规律）
05程序的执行流程
程序流程可以分为以下三种：
顺序结构：程序从上向下逐行逐条执行，只能向下；
分支结构：选择结构，判断语句
循环结构：重复执行一段或一条语句
06选择结构：基本if语句
一般用于一次条件判断
A: if语句格式第一种
a: 书写格式if(比较表达式) {
语句体;
}
b：执行流程：
先计算比较表达式的值，看其返回值是true还是false。
如果是表达式为true，就执行语句体；
如果是表达式为false，就不执行语句体；
B: 案例代码public class IfDemo{
public static void main(String[] args){
int i = 5 ;
//对变量i进行if判断
if(i > 5){
System.out.println("if中的条件是true");
i++;
}
System.out.println(i);//5
}
}
*if中的表达式可以用逻辑运算符进行连接，表示：要同时满足多个条件
案例代码：如果java成绩大于98，并且音乐成绩大于80，获得奖励；此外，如果java成绩等于100，并且音乐成绩大于70，也 可以获得奖励。
int j = 90; int m = 80; if((j>98&&m>80)||(j==100&&m>70)){ System.out.println("奖励");
}
*注意：
if后面的表达式必须是布尔类型
如果if语句的执行体只有一句，大括号可以省略,但是不建议省略
07选择结构：if_else语句
一般用于双重条件判断
A: if语句格式第二种
a: 书写格式if(比较表达式) {
语句体1;
}else {
语句体2;
}
b：执行流程：
首先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体1；
如果是false，就执行语句体2；
B: 案例代码public class IfElseDemo{
public static void main(String[] args){
int i = 16 ;
//判断变量,是奇偶数, 除以2,看余数是0还是1
if( i % 2 == 0 ){
System.out.println(i+" 是偶数");
}else{
System.out.println(i+" 是奇数");
}
}
}*注意： if...else 选择结构也可以用if第一种格式进行多次判断，但是运行速度减慢
if_else不会同时执行，只会执行一个
08选择结构：多重if语句
一般用于多重条件判断
A: if语句格式第三种
a: 书写格式if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}
b：执行流程：
首先计算比较表达式1看其返回值是true还是false，
如果是true，就执行语句体1，if语句结束。
如果是false，接着计算比较表达式2看其返回值是true还是false，
如果是true，就执行语句体2，if语句结束。
如果是false，接着计算比较表达式3看其返回值是true还是false，
如果都是false，就执行语句体n+1。
B: 案例代码
public class IfElseIfDemo{
public static void main(String[] args){
//成绩判断要求 ,成绩>80 成绩>70 成绩>60 不及格
//定义变量,保存成绩
int grade = 90;
//使用if else if 语句对成绩判断
if( grade > 80 ){
System.out.println(grade+" 成绩是优");
}else if ( grade > 70){
System.out.println(grade+" 成绩是良");
}else if ( grade > 60){
System.out.println(grade+" 成绩是中");
}else{
System.out.println(grade+" 成绩是差");
}
}
}
这里的执行结果就是优
*注意点：
if多重条件必须按顺序，从大到小或者从小到大，顺序不可以乱写
if的执行顺序是自上而下的，所以在条件判断的时候，会在第一个满足的地方停下并执行，后面的条件就不会 再判断执行了。
举例：
int grade = 90;
//使用if else if 语句对成绩判断
if( grade > 70 ){
System.out.println(grade+" 成绩是良");
}else if ( grade > 80){
System.out.println(grade+" 成绩是优");
}else if ( grade > 60){
System.out.println(grade+" 成绩是中");
}else{
System.out.println(grade+" 成绩是差");
}
这里的执行结果是良
这个案例中90>70,就执行了第一个语句，不再进行判断，执行后面的语句
09if语句的嵌套
*当有多个条件需要满足，才能执行某个操作时，可以使用if嵌套
*if嵌套一般可以优化，用逻辑运算符将多个条件进行连接，使用一个if进行判断
*代码案例：
需求：英雄数目>=5个，玩家等级>=15,才可以参加排位
Scanner sc = new Scanner (System.in);
System.out.println("请输入您的英雄等级");
int lv = sc.nextInt();
System.out.println("请输入您拥有的英雄数目");
int heroNum = sc.nextInt();
int a = 0;//作为一个开关，控制能否打排位赛
------------------------
if(lv>=15){ if(lv>=15&&heroNum>=5){
if(heroNum>=5){ ...>>>优化 a = 1;
a = 1; }
}
}
-----------------------------
if(a==1){
System.out.println("尽情上分吧");
}else{
System.out.println("请购买英雄");
}
本案例的另一个重点：
在判断或循环的外面，定义个开关，默认一个初始值
然后再判断或循环中达到某个条件时，改变开关的状态，即改变开关的初始值。
最后再判断或循环结束后的外面，再判断开关的值，根据不同的值，执行不同的结果。
10if语句和三元运算符的互换
* A: 三元运算符
* a: 概念
* 用来完成简单的选择逻辑，即根据条件判断，从两个选择中选择一种执行
* b: 使用格式
* (条件表达式)？表达式1：表达式2；
* c: 运算规则
* 1: 判断条件表达式，结果为一个布尔值
* 2: true，运算结果为表达式1
* 3: false，运算结果为表达式2
* B: 案例代码
public class IfElseDemo_1{
public static void main(String[] args){
int j = 6;
int i = 15;
//使用if语句,判断出最大值
if(i>j){
int j = 6;
System.out.println(i+" 是最大值");
}else{
System.out.println(j+" 是最大值");
}
//使用三元运算实现
int k = i>j ? i : j;
System.out.println(k+" 是最大值");
}
}
* C: if和三元的区别：
* if可以判断多条件，而三元一般只能判断一个条件
* 三元,必须有结果的, if 可以没有结果的（执行体）
*三元格式相对if更简单，在三元if都可以的情况下，推荐使用三元
11选择结构:switch语句
* A:switch语句解构
* a:switch只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。
b:格式如下:
swtich(表达式){ case 常量1 : 要执行的语句; break; case 常量2 : 要执行的语句; break; case 常量3 : 要执行的语句; break; default: 要执行的语句; break;
}
* c: 执行流程: 表达式,会自上而下进行匹配。和case后面的常量进行比较和哪个case后的常量相同,就执行哪个 case后面的程序,遇到break,就全结束。如果和所有的case后面的常量都不匹配，就执行 default后面的语句
* d: 关键字: switch case default break
*switch语句如何结束？a.遇到break结束
b.整个语句块执行完
12switch语句的星期判断案例
*要求
如果等于1，则输出星期一
如果等于2，则输出星期二
如果等于3，则输出星期三
如果等于4，则输出星期四
如果等于5，则输出星期五
如果等于6，则输出星期六
如果等于7，则输出星期天
* A: switch语句的星期判断
* a: 明确需求
需求:初始化int类型变量(1-7)代表星期几,使用switch语句进行判断,并打印出该整数对应的星期.
* b: 代码实现
public class SwitchDemo01 {
public static void main(String[] args) {
int week = 5;
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;
}
}
}
13switch语句接受的数据类型
* a:注意事项
switch语句中的表达式的数据类型,是有要求的
JDK1.0 - 1.4 数据类型接受 byte short int char
JDK1.5 数据类型接受 byte short int char enum(枚举)
JDK1.7 数据类型接受 byte short int char enum(枚举), String
14switch语句的特点
1、switch用于多重分支且条件判断是等值判断的情况
2、switch结束有两种情况：遇到 break; 执行到switch语句结束
3、case和default是没有前后顺序的，但是执行时先执行case语句，如果没有符合的会执行default语句；如果default放在了前面，则一定要加上break。 Default语句一般是放在最后，可以省略break，但是不建议省略
15switch语句中case穿透
* A:case穿透
* a: 在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即 可，这是一种简写的方式。
* b: 例如，要判断一周中的某一天是否为工作日，同样使用数字1~7来表示星期一到星期天，当输入的数字为1、 2、3、4、5时就视为工作日，否则就视为休息日。
*代码举例
public class SwitchDemo01 {
public static void main(String[] args) {
int week = 5;
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;
}
}
}
*注意点： deafult可以写在switch语句执行体的前面，也可以写在后面，但是习惯放在最后
default如果放在最上面，则一定要加break，否则会一直向下执行，直达遇到break为止
default如果放在最后，break可以省略，但是最好写上
16switch和if的比较
1.相同点：
都可以用来处理多分支结构
2.区别：
if多用于区间判断，如：i>=2&&i<=5
switch用于等值条件的判断
3.做等值判断时if能做的switch都能做，并且switch代码更简洁。
反之不行
17循环的概念：
概念：循环时一直重复做的事情，且有开始有结束的事情。
18为什么使用循环和什么时候使用循环
在达到同样的效果，同时可以用较简洁的代码完成。如：写100遍好好学习
直接使用输出语句，写100遍
第一：代码繁琐较长，影响计算机性能
第二：易错
可以使用循环输出100遍
怎样使用循环：
* 分析循环条件和循环操作
* 套用语法格式，写出循环
* 判断循环是否能够正常结束
19补充：==和equals的比较以及同时声明多个变量：
*==： 可以用来比较基本数据类型的的数值类型，此时比较的具体的数值
也可以用来比较引用数据类型，此时比较的时地址值。
*equals：只能用来比较引用数据类型，如果equals方法没有被重写，比较的是地址值，如果equals方法被重写
了，比较的就是重写后的内容
* 两个变量同时声明：
int a,b;
int a=1,b=2;
20循环的特征
* 循环条件：有开始有结束的点
* 循环操作：一只重复做的事情
* 循环变量：能够对循环结果产生影响的量
21循环结构：while循环
* A: while循环结构
* a: 使用格式
初始化表达式；
while(boolean类型表达式，也就是条件){
循环体
}
* b: 执行顺序
当条件是true,就执行循环体,执行完循环体后
程序再次执行while中的条件,如果条件还是true,继续执行循环体
直到条件是false的时候,循环就结束
*B:while循环步骤：
先判断条件，后执行循环体
如果一开始条件为假，一次都不会执行循环体
* C: 案例代码
public class WhileDemo{
public static void main(String[] args){
//输出 1-4之间的整数
//定义变量,整数类型, 循环的条件
int i = 1;
while( i < 5 ){
System.out.println(i);
i++;
}
}
}
22循环结构：for循环格式
*为什么使用for循环：相比while循环，代码更加简洁
*使用场景：通常用于循环次数已知固定的情况
* A: for循环_1
* a: 使用格式
for(初始化变量 ; 条件 ; 增量){
循环体;
}
* b: 各模块解释
初始化变量: 定义变量,作用是用来控制循环的次数
条件: 当条件是true,执行循环体,条件是false,结束循环
增量: 变量自增情况
* B: 案例代码
public class ForDemo{
public static void main(String[] args){
//for循环,输出0-10
for(int i = 0 ; i < 11 ; i++){
System.out.println(i);
}
}
}
*for循环易错点：
初始化变量可以省略，但是必须定义在for的上面
正常情况下，条件和增量不可以省略
如果初始化变量和条件和增量都省略，就是最简单的死循环。
分号不能省略，不能写错成逗号
23for循环执行流程
* A: for循环的执行流程
for（① ; ② ; ③）{
④
}
第一步，执行①
第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
第三步，执行④
第四步，执行③，然后重复执行第二步
第五步，退出循环
24for循环案例
* A: 案例
* a: 利用for循环,计算1+4的结果
* 案例代码：
public class ForDemo_1{
public static void main(String[] args){
// 定义变量,记录求和后的数据
int sum = 0;
// 利用循环,将变量从1变化到4
for(int i = 1 ; i <= 4 ; i++){
//对变量进行求和
sum = sum + i;
}
System.out.println(sum);
}
}
*B：案例（初始变量有两个）
*用户输入一个数字，打印出这个数字的加法表
*代码实现：
Scanner sc =new Scanner (System.in);
System.out.print("请输入一个数");
int num = sc.nextInt();
for(int i =0,j=num;i<=num;i++,j--){
System.out.println(i+"+"+(j)+"="+(i+j));
*C:案例：
*输入一个学生的姓名然后输入该学生的5门课成绩的成绩，并求平均分，如果输入成绩为负数，
终止输入并提示输入错误
*代码实现：
System.out.print("请输入姓名");
String name = sc.next();
double socre = 0;
double sum = 0;
boolean flag =true;
for(int i =1;i<=5;i++){
System.out.print("请输入成绩");
socre = sc.nextDouble();
sum=sum+socre;
if(socre<0){
flag = false;
break;
}
}
if(flag){
System.out.println("5门课成绩的成绩的平均分为"+sum/5);
}else {
System.out.println("输入错误");
}
*本题重点：相当于循环外定义开关，循环中达到某个条件时，开关状态改变
然后在循环结束后，用if判断,根据开关状态，选择是否执行某个语句
25循环结构：do_while循环
* A: do_while循环
* a: 使用格式
do{
循环体;
}while(条件);
* b: 执行顺序
先执行一次循环体，然后再判断条件，如果条件为true，继续执行循环体，
如果条件为false，循环结束。
* c: 特点
* 无条件先执行一次
* B: 案例代码
public class DoWhileDemo{
public static void main(String[] args){
int i = 0;
do{
System.out.println(i);
i++;
}while( i < 5);
}
}
*执行特点：先执行后判断
如果循环条件一次都不满足的话，循环体至少执行一次
*注意：do{ }while（）; 循环最后的分号不能少
while循环和do_while循环的区别
*while循环时先判断后循环，do_while循环是先循环后判断
*如果一开始体哦阿健就不满足，while一次都不会循环，do_while会循环一次
*do_while循环后面有个分号
26死循环
* A: 死循环概述
* 无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环
* 当缺少判断条件或缺少增量的时候，会导致死循环。
* B: 简单的死循环格式
* while(true){}
* for(;;){} 或 for(;true;){}
27嵌套之一：嵌套for循环
* A: 嵌套循环的概述
* 嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。
while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，
如最常见的在for循环中嵌套for循环。
* B: 嵌套循环的格式
for(初始化表达式; 循环条件; 操作表达式) {
………
for(初始化表达式; 循环条件; 操作表达式) {
执行语句
………
}
………
}
* C: 各模块解释
* 总的循环次数 = 内循环次数 * 外循环的次数
* 内循环,是外循环的循环体
* 可理解为外循环,控制的是行数
* 可理解为内循环,控制的是每行的个数
*执行顺序：外循环执行一次，内循环执行一圈
28嵌套for循环案例
* 打印正三角形
public class ForForDemo{
public static void main(String[] args){
for(int i = 0 ; i < 9 ; i++){
for(int j = 0; j < i+1 ;j++){
System.out.print("* ");
}
System.out.println();
}
}
}
*打印倒立直角三角形
System.out.print("请输入行数");
int num = sc.nextInt();
for (int i = 1; i <=num; i++) {
for (int j = num-i+1; j>0; j--) {
System.out.print("*");
}
System.out.println();
}
*打印等腰三角形
System.out.print("请输入行数");
int num = sc.nextInt();
for (int i = 1; i <=num; i++) { //外循环控制行数
for (int k = num-i; k >0; k--) { //不换行打印空格
System.out.print(" ");
}
for (int j = 1; j <= (2*i)-1; j++) { //不换行打印*
System.out.print("*");
}
System.out.println();
}
29break语句
* A: break语句
* a: 作用
* 跳出所在的当前循环体
*跳出switch语句
* b: 书写位置
* 必须出现在循环或选择结构switch语句内
* c: 举例
for(int i=0; i<10; i++) {
if(i>5) {
break;
}
System.out.println(“我爱Java”+i);
}
//会从0-5输出6次“我爱Java”
* B: break详细解释
* a: 作用
* 在loop/switch选择或者循环过程中，我们总是满足布尔表达条件才能执行对应的代码，然而在这些逻辑 过程中，可以使用一些关键字直接跳出正在执行的代码，去执行后边或者指定位置的代码，这些关键字一 旦出现就可以跳转语句执行顺序。
* b: 使用方式
* 无法单独使用，必须将break关键字置于switch或循环语句中
* c: 运行规律
* 不需要判断任何条件，只要遇到break变直接跳出执行后续代码。会完全跳出选择或者当前循环结构
* 只能跳出最近的代码块，不能跨越多级代码块
* C：循环标号
* a: 为什么使用循环标号
* 当在双层循环或者循环内有switch选择语句时，我们发现，使用break或者continue所作用的对象均是内层语句，无法直接跳出外层循环，这时就需要使用标号语句跳转了.
* b: 使用方式
* 在外层循环外的某行前边，使用后边跟有冒号”:”的标识符，即定义完毕。
使用时当在内层循环使用break或continue时后边紧跟之前定义的标号即可
*代码案例
i:for(int a = 0;a<9;a++){
for(int b =0;b<=a;b++){
System.out.print("* ");
if(b>=3){
break i;
}
}
System.out.println();
}
这里的输出结果如下
*
* *
* * *
* * * *
* c: 运行规律
* 当外层循环外定义了标号
* 内层使用break，终止内外双层循环。
* 内层使用continue，终止内层循环，继续外层循环。
30continue语句
* A: continue语句
* a: 作用
* 提前结束本次循环，继续进行下次循环
* b: 使用方式
* 无法单独使用，必须将continue关键字置于循环语句中
* c：运行规律
* 不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环
* d：案例代码
public class ContinueDemo{
public static void main(String[] args){
for(int i = 0 ; i < 10 ; i++){
if(i%2==0){
continue;
}
System.out.println(i);
}
}
}
//会把0-9之间所有的奇数打印到控制台上
break和return的区别
break:
*跳出当前循环，继续执行循环结构下面的语句
*如果break出现在嵌套循环的内循环中，只能跳出内循环，无法跳出外循环。此时若想跳出外循环，只能逐层 break或者在外循环的位置定义循环标号，break后面接循环标号
*在switch语句中出现，作用是跳出switch语句的执行体
return:
*从当前方法中退出，返回该调用方法的语句处
*方法中，return后面如果接参数，返回一个值给调用者。该值的类型必须于方法中声明的返回值类型相同
*方法中，return后面不带参数，就相当于返回空，作用是中断方法，返回调用者处
*如果方法的返回值时void。在方法中，如果从某个判断中跳出方法，或者中途退出方法，时用return
简单理解：（1）返回方法指定类型的值（前提是方法的返回值类型不是void）。
（2）方法的结束，它会导致当前的方法退出。
（3）使用的两种形式：方法有返回值类型，格式：return 返回值;
方法没返回值类型，格式：return;
31猜数字小游戏
* A: 猜数字小游戏
* a: 分析
* 用户给的数可能大于、小于、或等于被猜的数，这样就会出现三种情况，用前面讲的三元运算符可以实现，
但是得用三元运算符的嵌套，比较麻烦！可以用更简单的方式if条件判断，可以有三个以上的条件
* b: 需求分析
* 后台预先生成一个随机数1-100，用户键盘录入猜数字
* 如果猜对了，打印“恭喜您，答对了”
* 如果猜错了
* 猜大了：打印“sorry，您猜大了!”
* 猜小了：打印“sorry，您猜小了!”
直到数字猜到为止
最多只能猜5次，否则提示“sorry，您没有机会了!”
* B: 案例代码
/*
猜数字小游戏
完成猜数字小游戏：
1、产生随机数
后台预先生成一个随机数1-100，用户键盘录入猜数字
2、通过if语句对用户猜的数与随机数进行比较
如果猜对了，打印“恭喜您，答对了”
如果猜错了
猜大了：打印“sorry，您猜大了!”
猜小了：打印“sorry，您猜小了!”
3、通过for循环完成用户猜数的循环
直到数字猜到为止
最多只能猜5次，否则提示“sorry，您没有机会了!”
*/
import java.util.Random;
import java.util.Scanner;
//通过*的方式可以一次导入该包下所有的类，但是不建议使用。建议使用哪个导哪个。
//import java.util.*;
public class GuessNumber{
public static void main(String[] args) {
//1、产生随机数
//后台预先生成一个随机数1-100，用户键盘录入猜数字
//创建随机数对象
Random random = new Random();
//产生一个1-100的随机数
int randomNumber = random.nextInt(100)+1;
//System.out.println("我产生的随机数是："+randomNumber+"你猜猜是多少？"); 作弊专用
//产生控制台录入的Scanner对象
Scanner sc = new Scanner(System.in);
//3、通过for循环完成用户猜数的循环
//通过for循环完成猜数字逻辑
for(int i=1; i<=5; i++){
//提示用户输入要猜的数，用变量接收
System.out.println();
System.out.println("请您输入一个1-100的数：");
int guessNumber = sc.nextInt();
//2、通过if语句对用户猜的数与随机数进行比较
//如果猜对了
if(guessNumber==randomNumber) {
//打印猜对后的提示
System.out.println("恭喜您，猜对了！");
//跳出循环，不用再猜了
break;
}else {//如果猜错了
//如果猜大了
if(guessNumber>randomNumber) {
System.out.println("sorry，您猜大了!");
}else {//如果猜小了
System.out.println("sorry，您猜小了!");
}
}
//如果猜到了最后的第5次仍然没有猜对就跳出循环
if(i==5) {
System.out.println("对不起，点太背，下次再来吧！");
break;
}
//每次猜错后，都提示还有多少次机会
System.out.println("请注意，您还有"+(5-i)+"次机会，请慎重作答！");
}
}
}
