嵌套循环和方法
1. 嵌套循环
复制代码
1
2
3
4嵌套循环 为了让大家能够更好的理解循环嵌套之后的一个操作，后期代码中，一些算法中，都会使用到嵌套循环。 以下练习题我们需要学会推导过程！！！
1.1 入门
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42/* L * ***** 1 5 ***** 2 5 ***** 3 5 ***** 4 5 ***** 5 5 */ class Demo1 { public static void main(String[] args) { System.out.println("********"); System.out.println("********"); System.out.println("********"); System.out.println("********"); System.out.println("********"); System.out.println("********"); System.out.println("********"); System.out.println("********"); System.out.println("----------------------------------------"); // 需要展示5行数据 for (int i = 1; i <= 8; i++) { System.out.println("********"); } System.out.println("----------------------------------------"); // 外层循环控制总行数 int line = 20; for (int i = 1; i <= line; i++) { // 星星个数 = 最大行号 for (int j = 1; j <= line; j++) { System.out.print("*"); } System.out.println(); } } }
1.2 再入门
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23/* L * * 1 1 ** 2 2 *** 3 3 **** 4 4 ***** 5 5 ****** 6 6 */ class Demo2 { public static void main(String[] args) { int line = 30; // 外层循环控制总计6行 for (int i = 1; i <= line; i++) { // 每一行星星个数 == 行号 for (int j = 1; j <= i; j++) { System.out.print('*'); } System.out.println(); } } }
1.3 再再入门
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31/* L _ * * 1 4 1 ** 2 3 2 *** 3 2 3 **** 4 1 4 ***** 5 0 5 _下划线表示空格 _ = 总行数 - 当前行号; * = 当前行号 */ class Demo3 { public static void main(String[] args) { int line = 30; // 外层循环控制总行数 for (int i = 1; i <= line; i++) { // 内层循环1: 控制空格的个数 for (int j = 1; j <= line - i; j++) { System.out.print(' '); } // 内层循环2: 控制星星的个数 for (int k = 1; k <= i; k++) { System.out.print('*'); } System.out.println(); } } }
1.4 稍稍的难度一丢丢
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31/* L _ * * 1 5 1 *** 2 4 3 ***** 3 3 5 ******* 4 2 7 ********* 5 1 9 *********** 6 0 11 _ = 总行数 - 当前行号; * = 2 * 当前行号 - 1; */ class Demo4 { public static void main(String[] args) { int line = 20; // 外层循环控制总行数，这里是6行 for (int i = 1; i <= line; i++) { // 内层循环1：控制空格的个数 for (int j = 1; j <= line - i; j++) { System.out.print(' '); } // 内层循环2:控制星星的个数 星星 = 2 * 当前行号 - 1; for (int k = 1; k <= 2 * i - 1; k++) { System.out.print('*'); } System.out.println(); } } }
1.5 加一点佐料
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37/* L _ 字符 个数 A 1 6 A 1 BBB 2 5 B 3 CCCCC 3 4 C 5 DDDDDDD 4 3 D 7 EEEEEEEEE 5 2 E 9 FFFFFFFFFFF 6 1 F 11 GGGGGGGGGGGGG 7 0 G 13 _个数 = 总行数 - 当前行号; 字符个数 = 2 * 当前行号 - 1; 字符本身的递增过程 */ class Demo5 { public static void main(String[] args) { // 定义一个字符变量，变量初始化为字符'A' char ch = 'A'; // 外层循环控制总行数，总行数7行 for (int i = 1; i <= 26; i++) { // 内存循环1: 控制空格的个数 for (int j = 1; j <= 26 - i; j++) { System.out.print(' '); } // 内存循环2: 控制字符个数 for (int k = 1; k <= 2 * i - 1; k++) { System.out.print(ch); } System.out.println(); // 字符变量需要在每一次展会完毕之后，进行自增 ch += 1; } } }
1.6 加点辣椒
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62/* L _ * * 1 5 1 *** 2 4 3 ***** 3 3 5 ******* 4 2 7 ********* 5 1 9 *********** 6 0 11 ********* 1 1 9 ******* 2 2 7 ***** 3 3 5 *** 4 4 3 * 5 5 1 下半部分 第一行星星个数为9，如何计算得来 凑！！！ 总行数5 5 * 2 - (i * 2 - 1) --> 5 * 2 - i * 2 + 1 => (5 - i) * 2 + 1 (5 - i) * 2 + 1 10 - 1 = 9; 10 - 3 = 7; 10 - 5 = 5; */ class Demo6 { public static void main(String[] args) { // 菱形总行数 ，一旦是单数 int line = 25; // 图形一分为二，上半部分为line / 2 + 1行 // 外层循环控制总行数，这里是line / 2 + 1行 for (int i = 1; i <= line / 2 + 1; i++) { // 内层循环1：控制空格的个数 for (int j = 1; j <= line / 2 + 1 - i; j++) { System.out.print(' '); } // 内层循环2:控制星星的个数 星星 = 2 * 当前行号 - 1; for (int k = 1; k <= 2 * i - 1; k++) { System.out.print('*'); } System.out.println(); } // 下半部分一共line / 2行 // 外层循环控制总行数，总计line / 2行 for (int i = 1; i <= line / 2; i++) { // 内层循环1: 展示空格个数 for (int j = 1; j <= i; j++) { System.out.print(' '); } // 内层循环2: 控制星星的个数 for (int k = 1; k <= (line / 2 - i) * 2 + 1; k++) { System.out.print('*'); } System.out.println(); } } }
1.7 思考题【麻辣】不做强制要求
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14/* A BBB CCCCC DDDDDDD EEEEEEEEE FFFFFFFFFFF EEEEEEEEE DDDDDDD CCCCC BBB A */
1.8 思考题【重辣】不做强制要求
复制代码
1
2
3
4
5
6
7
8
9/* A ABA ABCBA ABCDCBA ABCDEDCBA ABCDEFEDCBA */
1.9思考题【魔鬼辣】不做强制要求
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14/* A ABA ABCBA ABCDCBA ABCDEDCBA ABCDEFEDCBA ABCDEDCBA ABCDCBA ABCBA ABA A */
1.1 ~ 1.6 要求学会，1.7 ~ 1.9 拔高题，选做题
2. 方法【重点】
2.1 为什么使用方法
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13生活中使用的工具，螺丝刀，锤子，扳手。 1. 复用，重复使用 2. 提高效率 开发中，存在代码需要复用的情况。虽然循环可以解决一部分代码复用的问题，但是无法从根本上解决需要多处使用的情况。 这里需要用到方法 代码中使用循环解决复用的问题 1. 代码冗余！！！ 2. 维护性极差！！！ 3. 阅读性极差！！！ https://blog.csdn.net/qq_16733389/article/details/105639231
2.2 比葫芦画瓢
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28// main方法 Java中主方法格式 public static void main(String[] args) { } /* public static : 不要问！！！固定格式 void: 返回值类型 void 表示当前方法没有返回值 返回值类型是当前方法运行完成之后对方法外的一个返回数据 main: 方法名，方法名是一个名字，要求符合命名规范 小驼峰命名法，见名知意，动宾结构 (形式参数列表): 当前方法运行所需的外来数据，这里需要告知调用者数据类型 {}: 方法体 方法格式: public static 返回值类型 方法名(形式参数列表) { 方法体 } public static returnType methodName(Arguments) { Method Body } */
2.3 第一次自定义实现方法
2.3.1 方法分析过程
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17需求: 使用方法展示一个Hello World 方法分析： 固定格式: public static 不要问 返回值类型: 这里不需要返回值类型，采用void 方法名: printHelloWorld 见名知意，动宾结构，小驼峰命名法 形式参数列表: 当前方法没有任何的外来数据需求，不需要参数 () 【方法声明】 public static void printHelloWorld()
2.3.2 方法实现过程
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16/** * 文档注释 * 1. 对于方法的功能解释 * 2. 方法所需参数介绍 * 3. 方法返回值类型介绍和含义 * 4. 方法处理过程中出现的异常 */ /** * 展示打印到控制台一个Hello World */ public static void printHelloWorld() { // 方法体 System.out.println("Hello World"); }
2.3.3 方法在代码中实现的位置
复制代码
1
2
3
4方法存放的位置 1. class大括号以内[目前的要求] 2. 其他方法之外
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15/* 自定义实现第一个方法 */ class Method1 { public static void main(String[] args) { } /** * 展示打印到控制台一个Hello World */ public static void printHelloWorld() { // 方法体 System.out.println("Hello World"); } }
2.3.4 自定义方法调用过程
复制代码
1
2
3
4
5
6
7记住一句话 方法是条狗，哪里需要哪里吼 1. 在需要调用方法的位置，使用方法名调用方法 2. 方法和变量的最大区别 方法后面一定有小括号！！！
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21/* 自定义实现第一个方法 */ class Method1 { public static void main(String[] args) { // 方法是条狗，哪里需要哪里吼 // 调用方法一定要有小括号，如果没有参数，小括号内没有内容 printHelloWorld(); printHelloWorld(); printHelloWorld(); printHelloWorld(); printHelloWorld(); } /** * 展示打印到控制台一个Hello World */ public static void printHelloWorld() { // 方法体 System.out.println("烤羊排~~"); } }
2.3.5 自定义方法小总结
复制代码
1
2
3
4
51. 目前我们有且只考虑在main方法中来调用其他方法 2. main方法是目前我们现在程序的唯一入门，如果想要哪一个代码执行，哪一个方法被调用，都需要经过main方法完成 3. 方法书写一定要注意代码格式 4. 方法位置在class以内，其他方法之外
2.4 无形式参数无返回值的方法
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29/* 需求: 在控制台打印展示10个烤羊排！！！ 方法分析: 固定格式: public static 不要问 返回值类型: 在控制台展示输出，这里不需要返回值 void 方法名: BBQ 烧烤 形式参数列表: 当前方法没有一个对于外来数据的需求 () 没有参数 【方法声明】 public static void BBQ() */ /** * 展示10次烧烤内容 */ public static void BBQ() { for (int i = 1; i <= 10; i++) { System.out.println("烤羊肉串..."); } }
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19/* 无形式参数无返回值类型的方法 */ class Method2 { public static void main(String[] args) { // 方法是条狗，哪里需要哪里吼 // 方法调用一定有小括号 BBQ(); } // 注释颜色 /** * 展示10次烧烤内容 */ public static void BBQ() { for (int i = 1; i <= 10; i++) { System.out.println("烤羊排..."); } } }
2.5 有参数无返回值的方法
2.5.1 方法实现过程
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40/* 需求： 展示用户告知的int类型数据 用户调用该方法，传入一个int类型，在控制台打印展示int类型数据 方法分析： 固定格式： public static 不要问 返回值类型: 展示打印一个int类型数据，不需要返回值！！！ void 方法名: printIntNumber 小驼峰命名法，见名知意，动宾结构 形式参数列表： 该方法需要展示的数据是用户传入的，而且是int类型 (int num) 参数声明 int 是参数的数据类型 num 是参数的名字，可以认为是方法内的一个变量，可以供方法使用 【方法声明】 public static void printIntNumber(int num) */ /* 文档注释细节 1. @param num 是告知编译器，这里在解释方法参数num 2. 方法功能概述和之后的参数解释，返回值解释需要空一行，标准格式代码 3. 文档注释可以帮助我们后期更好的阅读代码 */ /** * 展示用户传入的int类型数据 * * @param num 这里需要一个int类型数据 */ public static void printIntNumber(int num) { // 用户调用该方法时，会将数据存储于num中，展示num中的数据就OK了 System.out.println(num); }
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20/* 有参数无返回值方法演示 */ class Method3 { public static void main(String[] args) { // 方法是条狗，哪里需要哪里吼 // 当前方法需要参数，这里调用时调用者必须给他参数 printIntNumber(10); } /** * 展示用户传入的int类型数据 * * @param num 这里需要一个int类型数据 */ public static void printIntNumber(int num) { // 用户调用该方法时，会将数据存储于num中，展示num中的数据就OK了 System.out.println(num); } }
2.5.2 调用带有参数的方法注意事项
复制代码
1
2
3
4
51. 方法如果需要参数，必须在调用过程中给予对应的参数 2. 方法如果没有给定参数，报错！！！编译不通过 3. 方法如果给定的实际参数，数据类型不符合形式参数列表要求的数据类型，报错！！！编译不通过，数据类型一致化问题！！！ 4. 方法如果在调用的过程中给定的参数个数，不是方法所预期的参数个数，报错！！！编译不通过
2.6 形式参数和实际参数是什么?
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25形式参数: 我要做菜 烤羊排: 材料列表： 羊排，孜然粉，烧烤料，辣椒粉，葱姜蒜，洋葱 以上就是做烤羊排需要的材料！！！【形式参数列表】 public static void printIntNumber(int num) int num 只是告诉调用者，这里需要的是一个int类型数据 实际参数: 从菜市场，JD上采购羊排 买了2斤羊排 孜然粉 100G 烧烤料 100G 辣椒粉 50G 葱一根 姜 50G 蒜 5-6瓣 洋葱一个 这里是实实在在，采购回来的物料，【实际参数】 printIntNumber(10); 10 就是一个当前方法，所需的实际参数，符合方法要求的数据类型
2.7 练一练
2.7.1 一顿操作猛如虎
复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63/* L _ 字符 个数 A 1 6 A 1 BBB 2 5 B 3 CCCCC 3 4 C 5 DDDDDDD 4 3 D 7 EEEEEEEEE 5 2 E 9 FFFFFFFFFFF 6 1 F 11 GGGGGGGGGGGGG 7 0 G 13 _个数 = 总行数 - 当前行号; 字符个数 = 2 * 当前行号 - 1; 字符本身的递增过程 这里需要一个方法，封装这样的实现效果 方法分析： 固定格式： public static 不要问 返回值类型: 这里就是展示一个图形，不需要返回值 void 方法名： printPic 展示图像 形式参数列表： 图形展示过程中最主要的就是有多少行数据 需要给用户一个控制方法的途径 (int line) 【方法声明】 public static void printPic(int line) */ class Method4 { public static void main(String[] args) { printPic(42); } /** * 展示一个等腰梯形字符图形 * * @param line 控制图形展示的行数 */ public static void printPic(int line) { // 定义一个字符变量，变量初始化为字符'A' char ch = 'A'; // 外层循环控制总行数，总行数7行 for (int i = 1; i <= line; i++) { // 内存循环1: 控制空格的个数 for (int j = 1; j <= line - i; j++) { System.out.print(' '); } // 内存循环2: 控制字符个数 for (int k = 1; k <= 2 * i - 1; k++) { System.out.print(ch); } System.out.println(); // 字符变量需要在每一次展会完毕之后，进行自增 ch += 1; } } }
最后
以上就是怕黑萝莉最近收集整理的关于程序员入门之嵌套循环和方法的全部内容，更多相关程序员入门之嵌套循环和方法内容请搜索靠谱客的其他文章。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复