Day04笔记
课程内容
1、循环结构剩余部分
2、嵌套循环
3、方法
一、循环结构剩余部分
（一）do...while循环
1、定义格式：
do {
循环语句体;
步进表达式;
} while(逻辑表达式);
2、执行流程：
（1）执行do的大括号中的循环语句体和步进表达式
（2）执行while小括号中的逻辑表达式
（3）逻辑表达式判断为true，就继续循环执行循环语句体和步进表达式
（4）如果逻辑表达式判断为false，则直接结束do...while循环
3、while循环和for循环，都是先判断，如果能执行循环语句体再去执行，如果不能执行，就有可能一次都不循环。但是do...while循环，先做一次，再去判断能否继续循环，如果能，就接着循环，如果不能就停止。
代码示例
package com.offcn.demos;
public class Demo01_Do_While {
public static void main(String[] args) {
int num = 10;
do {
System.out.println(num);
num++;
} while(num < 1);
}
}
（二）死循环
1、死循环：无限循环。永远都不停止。
2、定义格式：
（1）for循环的死循环：
for(;;) {
循环语句体;
}
（2）while循环的死循环：
while(true) {
循环语句体;
}
3、使用场景：
（1）配合跳转语句使用，如果条件某有达到跳转的条件，就一直循环，如果达到了跳转的条件，就结束循环跳转至其他位置
（2）在服务器的设计中，服务器永远不会停，需要永远运行，所以可以使用死循环来控制
代码示例
package com.offcn.demos;
public class Demo02_Infinite {
public static void main(String[] args) {
/*for(;;) {
System.out.println("呵呵");
}*/
while(true) {
System.out.println("忌问客曰:吾与城北徐公shu美?客曰：忌你太美！");
}
}
}
（三）跳转语句
1、跳转语句：在循环结构中，用于结束循环，控制循环使用的语句
2、分类：
（1）continue语句：
结束本次循环，继续下次循环
（2）break语句：
结束当前层次的循环
（3）return语句：
结束当前方法
代码示例1
package com.offcn.demos;
public class Demo03_Continue {
public static void main(String[] args) {
//打印1-10的数字，遇到3的倍数跳过
for(int i = 1; i <= 10; i++) {
if(i % 3 == 0) {
continue;//结束本次循环继续下次循环
}
System.out.println(i);
}
}
}
代码示例2
package com.offcn.demos;
public class Demo04_Break {
public static void main(String[] args) {
//打印1-10的数字，如果遇到7，直接停止打印
for(int i = 1; i <= 10; i++) {
if(i == 7) {
break;
}
System.out.println(i);
}
System.out.println("abc");
}
}
代码示例3
package com.offcn.demos;
public class Demo05_Return {
public static void main(String[] args) {
/*return;
System.out.println("abc");*/
/*for (int i = 1; i <= 10; i++) {
if(i == 7) {
return;
}
System.out.println(i);
}
System.out.println("abc");*/
}
}
二、嵌套循环
（一）嵌套循环
1、在一次大的循环中，每次循环有是一轮复杂的操作，大循环也在重复，每一次大循环中小的复杂操作也在重复，于是定义一个循环，循环的循环语句体又是一个循环，就成为嵌套循环。
2、定义格式：
for(初始化变量1; 逻辑表达式1; 步进表达式1) {
for(初始化变量2; 逻辑表达式2; 步进表达式2) {
循环语句体；
}
}
3、执行流程：
（1）执行初始化变量1
（2）执行逻辑表达式1，如果为true就执行内层循环，如果为false，就直接结束嵌套循环
（3）如果逻辑表达式1执行结果为true，就执行内层循环
（4）执行初始化变量2
（5）执行逻辑表达式2，如果为true就执行循环语句体，之后按照for循环的规则执行，如果执行为false
内层循环直接结束，外层循环进入下一轮
（6）外层循环逻辑表达式判断为false，整个嵌套循环结束
4、图示：
代码示例
package com.offcn.demos;
public class Demo06_Nesting {
public static void main(String[] args) {
//外层循环循环一次，内层循环循环一轮
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 5; j++) {
System.out.println("i=" + i + ", j=" + j);
}
}
}
}
（二）嵌套循环练习
1、练习1
使用嵌套循环，打印5行5列的星星矩阵
代码示例
package com.offcn.demos;
/*
* 使用嵌套循环，打印5行5列的星星矩阵
* *****
*****
*****
*****
*****
*
* */
public class Demo07_PrintSquare {
public static void main(String[] args) {
//外层循环控制行，内层循环控制列
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
2、练习2
使用嵌套循环，打印5行5列的直角三角形
代码示例
package com.offcn.demos;
/**
* 使用嵌套循环，打印5行5列的直角三角形
*
* *
* **
* ***
* ****
* *****
*
*/
public class Demo08_Exercise2 {
public static void main(String[] args) {
//外层控制行，内层控制列
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
3、练习3
打印99乘法表
代码示例
package com.offcn.demos;
public class Demo09_Exercise3 {
public static void main(String[] args) {
/*
* java中 表示制表符，就是我们平时写代码代码缩进时使用的tab键
*
* 在java中叫做转义字符，就是将一个字符的含义进行转换
* 例如：t，本身的意义是英文的小写字母，加上反斜杠后，
* 意义就产生了变化，变为了制表符，就不再是英文字母t了
*
* */
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + (i * j) + " ");
}
System.out.println();
}
}
}
三、方法
（一）概述
1、具有特定功能一段代码
2、如果某一段代码经常使用，所以使用大括号，将这段代码包围起来，起一个名字，加上一些修饰，从此只要书写这段代码的名字就能够使用这一段具有特定功能的代码
3、方法也叫作函数（实际上就是一段功能）
4、方法的好处：
（1）提高了代码的复用性
（2）提高了代码的封装性（安全性），外界想要访问方法中的内容无法访问，从而就保障了方法中代码的安全
（3）降低了代码的设计思路难度
（二）方法的定义
1、方法的定义格式：
修饰符 返回值类型 方法名称(参数列表) {
方法体语句;
return语句;
}
2、说明：
（1）修饰符：在面向对象学习之前，所有的方法修饰符全部写成public static
（2）返回值类型：方法具有特定的功能，有些功能执行完毕后会有结果产出，有些功能执行完毕后没有结果产出。对于有结果产出的方法而言，结果属于什么类型，返回值类型就是什么类型。如果方法没有产出，也就是没有返回值类型，使用void表示，void的含义：无返回值类型。
（3）方法名称：只要是合法标识符即可（遵循小驼峰原则）
（4）参数列表：方法具有特定的功能，有些功能在执行的时候，可能会需要一些资源。在参数列表中，需要定义一些变量，来表示方法需要的资源。
（5）方法体语句：表示具体功能的代码
（6）return语句：结束方法并将方法的运行结果返回给调用者。如果方法的结果不用给调用者，return语句就不用返回结果。
代码示例
package com.offcn.demos;
public class Demo10_MethodDefinition {
public static void main(String[] args) {
/*
* 修饰符 返回值类型 方法名称(参数列表) {
* 方法体语句;
* return语句;
* }
*
* */
}
//计算两个int类型数据的和
public static void getSum(int a, int b) {
int sum = a + b;
System.out.println(sum);
}
//计算两个double类型的数据的和，并且将结果返回给调用者
public static double getResult(double a, double b) {
double result = a + b;
return result;
}
}
（三）方法的调用
1、调用格式：直接书写方法名称即可
方法名称(实际参数列表);
2、方法调用的分类：
（1）直接调用：某些方法没有返回值类型，对于这些方法，使用直接调用，可以直接让其功能运行
（2）输出调用：某些方法有返回值，这些方法会将具体的执行结果返回给调用者，对于这些方法，我们可以将其执行的结果进行获取并且输出打印
（3）赋值调用：某些方法有返回值，这些方法会将具体的执行结果返回给调用者，获取到返回的结果后，如果后续还要对这个结果进行其他处理，我们可以先将这个结果进行存储（例如赋值给一个变量），以便后续处理
代码示例
package com.offcn.demos;
public class Demo11_UseMethod {
public static void main(String[] args) {
//实际参数：在方法被调用的时候，实实在在参与运算的数据
getSum(2, 3);//方法的调用
getSum(10, 20);//方法的调用
//System.out.println(getSum(11, 22));
/*System.out.println(getResult(2.2, 3.3));//输出调用
double dou = getResult(1.1, 2.9);
System.out.println(dou);*/
getResult(5.5, 5.5);
}
//定义一个方法，计算两个int类型数据的结果，并且将结果进行输出打印
public static void getSum(int a, int b) {//形式参数：方法在定义之后，只是向外界宣称我需要什么类型的数据
int sum = a + b;
System.out.println(sum);
//return;
}
//计算两个double类型的数据的和，并且将和返回给调用者
public static double getResult(double a, double b) {
double result = a + b;
return result;
}
}
（四）方法的注意事项
1、方法的定义：
（1）方法不能嵌套定义
（2）方法与方法之间的定义是平行（平级）的关系
（3）方法可以嵌套调用
（4）方法定义的先后顺序没有区别，方法调用的先后顺序有区别（先调用哪个方法，就先执行哪个方法）
2、参数列表：
（1）形式参数：方法在声明定义的时候，方法体在执行的时候需要使用那些数据，形式参数就向外界声明需要那些数据
（2）实际参数：方法在调用的时候，按照形式参数列表的声明，进行实际参数的传递。实际参数是实实在在参与运行的数据
（3）实参和形参的对应关系：形参的参数列表的数据类型是怎么排列的，实际参数传递的数据类型就要和形参的数据类型保持完全对应，顺序都不能错
（4）形式参数的情况：
a.形式参数的数量可以是无穷多个
b.形式参数的数量可以是0个，0个参数的形参列表叫做：空参
3、return语句：
（1）return语句表示结束方法，并且将方法产出的结果进行返回
（2）如果方法没有具体的返回内容，可以写成return;，表示结束方法，一般情况下，可以省略，因为方法执行遇到右大括号也可以结束
（3）如果方法有具体的返回内容，return语句后面要跟上具体要返回的那个数据，返回的数据属于什么数据类型，方法声明上的返回值类型就是什么数据类型
（4）return语句如果有数据可以返回，是将数据返回给方法的调用者。哪个来调用方法，就将结果返回给哪个
代码示例
package com.offcn.demos;
public class Demo12_MethodNotice {
public static void main(String[] args) {
/*System.out.println(getResult(2.2, 3.3));
getSum(10, 5);*/
/*getSum1(3, 2.5);
int a = 3;
double b = 4.4;
getSum1(a , b);*/
//getSum1(3.5, 2);
}
public static void printStr() {
System.out.println("HelloWorld!");
}
/*public static void getSum(int a, int b, int c, int d) {
}*/
/*public static void getSum1(int a, double b) {
System.out.println(a + b);
}*/
/*public static void getSum2(double a, int b) {
System.out.println(a + b);
}*/
/*public static void getSum(int a, int b) {
System.out.println(a + b);
}
public static double getResult(double a, double b) {
double result = a + b;
return result;
}*/
}
（五）方法在内存中的理解
代码示例
package com.offcn.demos;
public class Demo13_MethodPicture {
public static void main(String[] args) {
int x = 3;
int y = 2;
int sum = getSum(x, y);
System.out.println(sum);
}
//计算两个int类型数据的和并且将结果返回
public static int getSum(int a, int b) {
int sum = a + b;
return sum;
}
}
（六）方法的练习
1、练习1
定义一个方法getMax，可以获取两个整数的较大的值
在主方法中，键盘录入两个整数，调用方法获取两个数中较大的那一个数进行打印
代码示例
package com.offcn.demos;
import java.util.Scanner;
/**
* 定义一个方法getMax，可以获取两个整数的较大的值
在主方法中，键盘录入两个整数，调用方法获取两个数中较大的那一个数进行打印
*
* @author Administrator
*
*/
public class Demo14_MethodExercise1 {
public static void main(String[] args) {
//导包快捷键Ctrl + shift + O
Scanner sc = new Scanner(System.in);
int num1 = sc.nextInt();
int num2 = sc.nextInt();
System.out.println(getMax(num1, num2));;
}
/*public static void getMax(int a, int b) {
int result = a > b ? a : b;
System.out.println(result);
System.out.println(a > b ? a : b);
}*/
public static int getMax(int a, int b) {
/*int result = a > b ? a : b;
return result;*/
return a > b ? a : b;
}
}
2、练习2
定义一个方法isEqual，可以判断两个小数是否相等。
在主方法中，键盘录入两个整数，自动提升为两个小数，调用方法比较两者是否相等
代码示例
package com.offcn.demos;
import java.util.Scanner;
/**
* 定义一个方法isEqual，可以判断两个小数是否相等。
在主方法中，键盘录入两个整数，自动提升为两个小数，调用方法比较两者是否相等
*
*/
public class Demo15_MethodExercise2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num1 = sc.nextInt();
int num2 = sc.nextInt();
System.out.println(isEqual(num1, num2));
}
public static boolean isEqual(double a, double b) {
return a == b;
}
}
3、练习3
定义一个方法，可以打印指定的行数和列数的星星矩阵
在主方法中，键盘录入两个整数，作为行数和列数，调用方法打印对应的矩阵
代码示例
package com.offcn.demos;
import java.util.Scanner;
/**
* 定义一个方法，可以打印指定的行数和列数的星星矩阵
在主方法中，键盘录入两个整数，作为行数和列数，调用方法打印对应的矩阵
*
*/
public class Demo16_MethodExercise3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入行数：");
int row = sc.nextInt();
System.out.println("请输入列数：");
int col = sc.nextInt();
printSquare(row, col);
}
public static void printSquare(int row, int col) {
for (int i = 1; i <= row; i++) {
for (int j = 1; j <= col; j++) {
System.out.print("*");
}
System.out.println();
}
}
}