switch语句；for/while循环；死循环；跳转语句；嵌套循环；方法及方法的调用（Java Day04）

一、选择语句【switch语句】：

​        概述：提前把一些结果对应的处理方式写好，执行的时候根据表达式的结果去和罗列好的结果去匹配，对应执行匹配的结果的处理方式的语句体。

​        格式：

​        switch（表达式）{

​        case 常量1：语句体1；

​        break；

​        case 常量2：语句体2；

​        break；

​        ......

​        case 常量n：语句体n；

​        break；

​        default: 语句体n+1；

​        break；

       ​ }

​       格式解释：

​       switch：选择的意思 做选择

​       表达式：他的结果表示所作出的选择

​       case项：供给我们来选择的选项

​       语句体：每一项对应要干的事

​       break：用来结束选择。

​       执行流程：

​       1、执行表达式得到表达式的结果

​       2、使用结果去和下面的case项一一的匹配一直到匹配上结果值执行对应的语句体

​       3、执行break中断选择语句

       代码示例

import java.util.Scanner;
public class Demo01 {
    public static void main(String[] args) {
        //键盘录入一个时间值表示游戏技能的冷却
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入冷却的时间：");
        int time = sc.nextInt();
        //switch语句来选择技能
        switch (time) {
        case 10:
            System.out.println("技能是：大杀四方");
            break;
        case 15:
            System.out.println("技能是：崩山裂地斩");
            break;
        case 20:
            System.out.println("技能是：血魔弑天");
            break;
        case 30:
            System.out.println("技能是：诸神献祭");
            break;
        case 40:
            System.out.println("技能是：暗天波动眼");
            break;

        default:
            System.out.println("没有找到对应的技能");
            break;
        }
    }
}

   注意事项：

​           1、表达式结果类型：

​               jdk1.5版本前：byte、short、char、int

​               jdk1.5版本：增加了枚举类型

​               jdk1.7版本：增加了String

​           2、case项后只能跟常量，不能跟变量

​           3、case项中的break，一般情况下不能省略，他是结束选择语句的。

​                如果省略了break，就不会及时的结束选择语句会继续执行下一个case项的语句体

​                这样的现象我们叫做case的穿透性。

​                如果多个case项的语句体是一样的，那就可以利用穿透性

​           4、default项表示表达式的结果没有对应的匹配case项来执行的语句体；

​               永远都是最后一个区匹配。

    练习

• 键盘录入一个月份，输出这个月份的季节，

• 说明：345月为春季，678为夏季 ，9、10、11为秋季，12、1、2为冬季 其他数字没有任何季节录入错误

           代码示例

import java.util.Scanner;
public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new  Scanner(System.in);
        System.out.println("请输入月份值：");
        int month = sc.nextInt();
        switch (month) {
        case 3:
        case 4:
        case 5:
            System.out.println("春天");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println("夏天");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println("秋天");
            break;
        case 12:
        case 1:
        case 2:
            System.out.println("冬天");
            break;
      default:
            System.out.println("您输入的月份不合法");
            break;
        }
    }
}

二、循环结构

• 概述：就是使用固定的格式来重复做一件事情的格式语句，叫做循环结构语句。
• 常用语句分类：for循环结构；while循环结构

    for循环

• ​格式：for（初始化变量；循环条件；初始化变量的自增）{循环体}
• 解释：

1. for：关键字 代表循环
2. 初始化变量：决定循环从什么地方开始【可以初始化多个变量，变量于变量之间使用逗号隔开】
3. ​循环条件：决定循环的事什么情况下可以做
4. 初始化变量的自增：决定循环的次数【频率】
5. 循环体：循环要做的那件事【重复做的那件事情】

       

      1、练习1

​            打印数字1-5

​            分析：动作是不是就是打印 这是一个重复动作所以就可以使用循环

​            从哪里开始打印：从内容1开始打印 初始化变量就是int 变量值就是1 ，变量就是打印的内容

​            明确循环条件：内容 1到5 不是这范围的内容就不打印 变量小于等于5就可以

​            打印：

​            初始化变量的自增：第二次打印的内容比第一次的内容增加了1，变量加1

​            循环体：打印内容值 输出语句输出变量

            代码示例

public class For_Test01 {
    public static void main(String[] args) {
        //打印1到5
        for (int i = 1; i < = 5; i++) {
            //打印内容值  i就表示是内容值
            System.out.println(i);
        }
    }
}

​       2、练习2

​             打印数字5-1

​             分析：动作是不是就是打印 这是一个重复动作所以就可以使用循环

​             从哪里开始打印：从内容5开始打印 初始化变量就是int 变量值就是5 ，变量就是打印的内容

​             明确循环条件：内容 5到1 不是这范围的内容就不打印 变量大于0就可以打印

​             初始化变量的自增：第二次打印的内容比第一次的内容减少了1，变量减去1

​             循环体：打印内容值 输出语句输出变量

             代码示例

public class For_Test02 {
    public static void main(String[] args) {
        //打印5到1
        for (int i = 5; i > 0; i--) {
            //打印内容值  i就表示是内容值
            System.out.println(i);
        }
    }
}

​         3、练习3

​               计算1+2+3+...+100的和

​               分析：累加必须是两个数相加后使用结果去加第三个数，然再用新的结果去加第四个数，依次去加下个数，加完最后一个数得到结果是不是就是     最终的累和结果。

​               每次相加都是结果加下一个数：这个动作要做多次 重复的动作，使用循环从数1开始加 初始化变量就是数1，操作的内容就应该是数，现在使用变量来表示

​               初始化变量自增：变量只需要加1

​               循环条件：数不大于100 变量小于等于100；

​               循环体：使用结果去加数 但是没有结果，在循环外定义一个结果。从1开始加的时候结果就是0.

​               代码示例

public class For_Test03 {
    public static void main(String[] args) {
        //定义一个变量来存放每次相加得到的结果
        int sum = 0;
        //重复做结果加数字的动作
        for (int i = 1; i <= 100; i++) {
            //每次使用结果值加数字把新的结果存放到结果的变量sum
            sum = sum + i;
        }
        System.out.println("1到100的累和是："+sum);
    }
}

          4、练习4

​               计算1-100的偶数和

              分析：

​              累加之前对数进行判断；是偶数我才加，不是偶数跳过累加必须是两个数相加后使用结果去加第三个数，然再用新的结果去加第四个数，依次去加下个数，加完最后一个数得到结果是不是就是最终的累和结果。

​              每次相加都是结果加下一个数：这个动作要做多次 重复的动作，使用循环从数1开始加 初始化变量就是数1，操作的内容就应该是数，现在使用变量来表示

​              初始化变量自增：变量只需要加1

​              循环条件：数不大于100 变量小于等于100；

​              循环体：使用结果去加数 但是没有结果，在循环外定义一个结果。从1开始加的时候结果就是0.

              代码示例

public class For_Test04 {
    public static void main(String[] args) {
        //定义一个变量来存放每次相加偶数得到的结果
        int sum = 0;
        //重复做结果加数字的动作
        for (int i = 1; i <= 100; i++) {
            //i变量代表的就是数字 要数字进行判断 判断i是不是偶数就可以了
            if (i % 2 == 0) {
                //每次使用结果值加数字偶数把新的结果存放到结果的变量sum
                sum = sum + i;
            }
        }
        System.out.println("1到100之间偶数的累和是："+sum);
    }
}

        5、练习5

​               列举所有的“四叶玫瑰数”，并统计四叶玫瑰数的个数

​               四叶玫瑰数：是一个四位数，各个位的数字的四次方的和，为该数字本身

               分析：

​               四叶玫瑰数他是存在什么范围的数字，四位数：1000到9999

​               操作的数的范围就是1000到9999

​               获取四叶玫瑰数：需要一个数一个数去判断，对每个数的判断重复的动作使用循环语句。初始化变量：从1000开始判断，初始化变量就是从1000开始，这个变量就表示操作的数，循环条件就是数的范围 变量大于1000同时小于等于9999，初始化变量的自增：就是数加一。

​               循环体：就是判断数是不是四叶玫瑰数

​          1、先获取四位数每一位上面的数字

​              个位：数%10 结果就是个位的数

            ​  十位：数/10%10就是十位上的数

​              百位：数/100%10就是百位上的数

​              千位：数/1000

​         2、求取四个数的四次方和

​         3、判断和是否等于数本身

​         4、条件成立，进行计数。

​              如何来计数：使用唯一的容器来记录次数最后的次数就是最终的次数在循环的外面定义一个唯一的变量，初始值是0.每记录一次就更新一下变量中的值【就是最新的次数】

          代码示例

public class For_Test05 {
    public static void main(String[] args) {
        //定义一个变量来存储每次出现四叶玫瑰数的次数
        int count = 0;
        //判断所有的四位数
        for (int i = 1000; i < = 9999; i++) {
            //对数字进行判断
            //获取每一个位上的数据
            int g = i%10;//个位 1234  1234%10  余数  ：4
            int s = i/10%10;//十位  1234 1234/10 =123%10 余数  3
            int b = i/100%10;//百位
            int q = i/1000;//千位
            //求取四个数的四次方的和
            int sum = g*g*g*g+s*s*s*s+b*b*b*b+q*q*q*q;
           if (sum == i) {
                System.out.println("四叶玫瑰数是："+i);
                //条件满足i就是四叶玫瑰数 进行计数
                count++;
            }
        }
        System.out.println("四叶玫瑰数的个数为"+count);
    }
}

  while循环

• ​概述：它是循环结构一种，它也有自己的固定格式，它的执行流程和for循环的执行流程一样，所以把while循环理解为是for循环的一种。
• ​格式：

1. ​初始化变量；
2. ​ while（循环条件）{循环体；初始化变量的自增}

• 解释：while：关键字 含义和for的含义基本一样。表示循环

​            

            练习1

​             使用while循环，统计1-100范围内，有多少数字可以被7整除

             分析：操作1到100的数字，对每一个数字进行判断，是否被7整除，从1开始做，初始化变量就是定义为1，变量就是代表操作的数字。

             循环条件：数字在1到100之间 就进行判断。

              循环体：对数字[变量]进行判断。使用数对7 进行取余数，余数为0意味着整除，对能整除的数字进行个数的计数[就是循环外面定义一个唯一的变量来计数]

             初始化变量的自增：每次增加1

             代码示例package com.ujiuye.demo; public class Demo_While {

public static void main(String[] args) {
//操作的是1到100数从1开始操作
//定义一个初始化变量1
int num = 1;
//定义一个唯一的变量来记录个数
int count = 0 ;
while (num <= 100) {
//对数进行判断是否被7整除

if (num % 7 == 0) {

//进行计数 
count++;} 
//初始化变量的自增【特别容易丢】
num++; } //循环完成之后count当中存放的就是能被7 整除的数的个数
System.out.println("1到100之间能被7整数的数的个数："+count); } }

        练习2

           珠穆拉玛峰的高度为8848米，一张纸的厚度为0.01米，请问折叠多少次，纸张能达到珠穆拉玛峰的高度。

          分析：

          纸对折一次厚度翻倍*=2

          什么时候不用对折了？纸的厚度>=8848 [循环条件就是<8848]

          循环体：对纸进行对折 [纸的厚度翻倍]

          初始化变量就是纸的厚度，

          初始化变量的自增：每次都是翻倍，*=2；

          代码示例：

public class While_Test02 {
public static void main(String[] args) {
//定义珠穆拉玛峰高度
int heigth = 8848;
//定义一个纸的厚度
double num = 0.01;
//定义一个变量来进行计数
int count = 0 ;
while (num<heigth) {
//对折纸
num*=2;
System.out.println(num);
//执行一次高度没有珠穆拉玛峰高进行一次计数
count++;
}
//循环完成之后count中就是 折的次数对
System.out.println("纸的厚度超越珠穆拉玛峰的高度需要对折"+count+"次");
}
}

   死循环

•  概述：就是循环条件永远成立，循环体会一致执行下去的现象，叫做死循环。
• 使用场景：要做的事不想停止，一致做下去。
• for循环结构： for ( ; ture ; ) {循环体}
• while 循环结构 ：[常用] while （true）{循环体}
• 弊端：一直执行不停止，容易产生内存溢出的异常出现。

代码示例

public class Demo01 {
public static void main(String[] args) {
/*for(;;) {
System.out.println("情人节快乐");
}*/ while(true) {
System.out.println("情人节快乐");
}
}
}

  跳转语句

• 概述：在循环执行过程中，我想人为的干预循环的过程使用的工具，工具叫做跳转语句。
• break：停止整个循环语句体
•  continue：停止当前[本次] 循环，继续下一次循环。

             代码示例

public class Demo {
public static void main(String[] args){ 

for(int i = 1;i<=5; i++) {
//当打印到三的 候就不打印时/*if (i>=3) {break;//结束整个循环体
}*/
//当i是3的时候不打印3，其他正常打印if (i==3) {
continue; //跳过本次循环继续执行后面的循环
}
System.out.println(i);
}
}
}

        综合练习

              模拟用户登录，正确的用户名是123，密码是987

              提示用户录入用户名和密码，进行判断，如果录入正确就提示“登录成功”；如果录入错误就提示“登录失败，请重新录入”

              如果登录失败，就继续录入，直到登录成功为止

              分析：

              使用到循环 [死循环]

              只有输入对了，结束录入 [结束死循环 break]

              循环体：

                     1，键盘录入用户名和密码

                     2，判断录入的信息和正确信息是否一致

                     3，对，结束登录 [结束循环体]

                     4，不对，重新登录

              代码示例

import java.util.Scanner;
public class Login {
public static void main(String[] args) {
//先定义正确的用户名和密码
int username = 123;
int password =987;
//开启键盘录入功能   
Scanner sc = new Scanner(System.in);
//书写死循环
while(true) {
//友好提示录入用户名
System.out.println("请输入您的用户名：");
int uname = sc.nextInt(); 
System.out.println("请输入您的密码：");
 int upassWord = sc.nextInt();
//验证
if (uname==username && upassWord == password) {
//验证成功提示登录成功信息
System.out.println("恭喜您，来到天堂");
//结束整个循环体
break;
} else 
{
System.out.println("您的信息有误，请重新登录！");
}
}
}
}

    嵌套循环

• 概述：就是一个循环的循环体是另一个循环体。

      举例：教练员要求运动员跑3次1500米，操场500米一圈，运动员1500米需要跑3圈 教练员的要求 跑3次事重复指令 使用到循环。

                  指令是循环体同时也是运动员要干的事

         运动员干的事：跑3圈，也是一个循环。

         运动员的循环作为教练员循环的循环体出现，这样的现象就是嵌套式循环。

         代码示例

public class Demo02 {
public static void main(String[] args) {
//书写教练员的指令3次指令
for(int i = 1 ; i <= 3; i++) {
//指令的内容【运动员跑1500米需要跑3圈一圈一圈的跑】
for(int j = 1; j <= 3; j++){
System.out.println("每次跑一圈500米");
}
System.out.println("完成第"+i+"指令");
}
}
}

   嵌套循环练习

          1、练习1

        使用嵌套循环，打印四行五列星星矩形
        *****
        *****
        *****
        *****
        提示：打印不换行，使用print方法，不要加ln
        分析：
           1，先把整行看成一个整体内容是一个a提议就变成打印4行a使用循环打印
           2，把a的内容替换成*****五个*也是一个一个打印出来 [使用循环来打印]

       代码示例

public class Test01 {
public static void main(String[] args) {
//先打印4行a
for(int i = 1; i <=4 ;i++) {
//System.out.println("a");//内容a
//内层循环【外层循环的循环体】打印的就是*****
for (int j = 1; j <= 5; j++){ System.out.print("*");
}
//打印完一行***** 之后换行
System.out.println();
}
}
}
解释：
println()：打印完内容自动换行 print(): 打印完内容不会换行

          2、练习2

      使用嵌套循环，打印5行5列的直角三角形
	*
	**
	***
	****
	*****
      分析：
         1，把每一行的内容看做一个相同元素 首先打印5行相同的元素
         2，把每行的内容换成真实的内容
         第一行：*
         第二行：**
         第三行：***
         每行打印的*的个数和行数是相等。
     代码示例

public class Test02 {
public static void main(String[] args) {
//打印5行内容
for (int i = 1; i <= 5; i++) {
//打印每一行的内容每行* 个数小于等于对应的行数就打印
for (int j = 1; j <= i; j++) {
// 打印* System.out.print("*");
}
//打印完一行需要 行换System.out.println();
}
}
}

  

三、方法

• 概述：就是一段具有特殊功能的代码段

• 表现为：使用固定格式把特殊功能的代码封装起来，并起个名，下次使用的时候直接找这个名字，就能使用这段代码，这个叫做方法。

• ​本质：就是一点具有特殊功能的代码段。
•  好处：

​              1、简化了代码的重复性，提高了代码的复用性；

​              2、提高了代码的安全性

​              3、提升了开发效率，维护性提升

方法的定义

• ​格式：修饰符 返回值类型 方法名称（参数列表）{方法体}
• 修饰符：目前情形下 public static
• 返回值类型：代码段执行完毕得到的结果的数据类型 [基本数据类型] ，如果代码段执行完毕没有数值，相当于没有数据类型，返回值类型使用void来 代替数据类型。void 不是数据类型。
• ​方法名：就是特殊代码段起的名字 [为了将来使用代码段好找]
• （参数列表）：就是特殊代码段执行的时候会使用到一些数据，用来存放这些数据的一个变量空间。
• ​方法体：就是我们那段特殊功能的代码。
• 没有返回值：直接就是方法体 [执行完毕只是一种效果，没有值]
• 有返回值：写完方法体，return语句；[执行完毕有一个数值，值需要使用return 返回给调用者]
• 定义位置：类中方法外

          代码示例

public class Test02 {
public static void main(String[] args) {
}
//类中方法外
public static void printStar() {
//打印5行内容
for (int i = 1; i <= 5; i++) {
//打印每一行的内容每行* 个数小于等于对应的行数就打印
for (int j = 1; j <= i; j++){
// 打印* 
System.out.print("*");
}
//打印完一行需要 行换
System.out.println();
}
}
}

​          练习：

​               创建一个求取两个int类型的数的和的方法

//定义好了一个求和的方法
public static int getSum(int a,int b) {
 int c = a+b;
 return c ;
}

  方法的调用

• ​格式：方法名称（实际参数）
• ​表现方式：

​             (1)  直接调用： 方法名称（实际参数）

​             (2)  输出调用： 把方法调用放到输出语句中：System.out.println(getSum(12,23))

​                                   注意事项：调用的方法必须要有返回值

​             (3)  赋值调用：把方法调用赋值给一个变量 int sum = getSum(12,23)；

​             (4)  注意事项：调用的方法必须要有返回值

• 方法的注意事项

1. 方法定义：

            （1）方法不能嵌套定义，方法都是定义在主方法的下面。
          （2）方法的先后没有区别
          （3）方法的定义是平级关系
          （4）方法可以嵌套调用，甚至可以自己调用自己

  参数列表

•  形式参数

• 概述：就是存在于方法的定义中，是一个没有被赋值的变量，具有数据类型修饰的

• ​特点：

1. 存在方法的定义参数列表中
2. 是变量的声明 [没有被赋值的变量]
3. 肯定有数据类型的修饰【变量有数据类型】

 比如：

 getSum(int a,int b){}
//int a 和int b就是形式参数。

实际参数

•  概述：方法调用的时候传入的值【对方法形式参数的回应（对变量赋值）】存在方法的调用中，是一个常量值或者是一个对象 [具体的东西]
• 特点：

1. 存在于方法的调用中
2. 是一个常量
3. 没有数据类型修饰

​             比如：getSum(34,56) 34 和56 就是实际参数

 四，方法在内存中的理解

• 寄存器：与CPU打交道的
• 本地方法栈：与操作系统打交道的
• 栈内存：与方法 ，局部变量打交道的
• 堆内存：与对象，成员变量打交道
• 方法区：与类，接口，枚举等数据打交道的

  过程：

​         1、加载字节码文件到方法区

​         2、调用main方法进栈开始执行

​         3、main方法中调用其他方法，到方法区找对应的方法进栈开始执行

​         4、方法执行完弹栈并把值弹给main方法

 

方法练习

1、练习1

• 定义一个方法getMax，可以获取两个整数的较大值
•  在主方法中，键盘录入两个整数，调用方法获取两者最大值

代码示例

import java.util.Scanner;
public class Method_Test01 {
//定义一个求取两个数的最大值的一个方法
public static int getMax(int a, int b) { 
int max = a>b ? a : b ;
return max ;
}
public static void main(String[] args) {  //主方法
//键盘录入整数
Scanner sc = new Scanner(System.in);
//友好提示输入整数
System.out.println("请输入第一个整数：");
int num1 = sc.nextInt(); 
System.out.println("请输入第二个整数："); 
int num2 = sc.nextInt();
//调用方法获取num1和num2的最大值
int max = getMax(num1, num2);
System.out.println("您输入的两个数的最大值是："+max);
}
}

 2、练习2

• 定义一个方法isEqual，可以判断两个小数是否相等
• 在主方法中，键盘录入两个整数，自动提升为小数，调用方法比较两者是否相等
•  代码示package com.ujiuye.demo; import java.util.Scanner; public class Method_Test02 {

public static void main(String[] args){
//键盘录入整数
Scanner sc = newScanner(System.in);
//友好提示输入整数
System.out.println("请输入第一个整数：");
int num1 = sc.nextInt(); 
System.out.println("请输入第二个整数："); 
int num2 = sc.nextInt();
//整数提升为double的数小  转大
double a = num1; 
double b = num2; 
System.out.println(a);
System.out.println(b);
//调用方法比较这两个数
boolean c = isEqual(a, b); 
System.out.println("输入的两个数是否相等"+c);
}


//定义一个方法isEqual，可以判断两个小数是否相等

public static boolean isEqual(doublea,doubleb){

//判断a 和b 里面的数 
if (a == b ) { 
return true; 
}else {
 return false; 
} 
} 
}

 3、练习3

• 定义一个方法，可以打印指定行数和列数的矩形
• 在主方法中，键盘录入两个整数，作为行数和列数，调用方法打印对应规模的矩形

代码示例

public static void main(String[] args) {
/*//先打印4行a
//for(int i = 1; i <=4 ;i++) {
//System.out.println("a");
//内容a//内层循环【外层循环的循环体】打印的就是*****
//for (int j = 1; j <= 5; j++) {
// System.out.print("*");
}
//打印完一行***** 之后换行
//System.out.println();
}*/ printStar(6,6);
}
//定义方法打印n行m列的巨型*
public static void printStar(int n ,int m) {
//先打印n行a
for(int i = 1; i <=n ;i++) {
//System.out.println("a");//内容a
//内层循环【外层循环的循环体】打印的就是*****
for (int j = 1; j <= m; j++){
 System.out.print("*");
}
//打印完一行***** 之后换行
System.out.println();
}
}
}

​