程序员入门之嵌套循环和方法

嵌套循环和方法

1. 嵌套循环

嵌套循环
	为了让大家能够更好的理解循环嵌套之后的一个操作，后期代码中，一些算法中，都会使用到嵌套循环。
	以下练习题我们需要学会推导过程！！！

1.1 入门

/*				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 再入门

/*				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 再再入门

/*			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 稍稍的难度一丢丢

/*              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 加一点佐料

/*				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 加点辣椒

/*				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 思考题【麻辣】不做强制要求

/*
     A
    BBB
   CCCCC
  DDDDDDD
 EEEEEEEEE
FFFFFFFFFFF
 EEEEEEEEE
  DDDDDDD
   CCCCC
    BBB
     A
*/

1.8 思考题【重辣】不做强制要求

/*
     A
    ABA
   ABCBA
  ABCDCBA
 ABCDEDCBA
ABCDEFEDCBA
*/

1.9思考题【魔鬼辣】不做强制要求

/*
     A
    ABA
   ABCBA
  ABCDCBA
 ABCDEDCBA
ABCDEFEDCBA
 ABCDEDCBA
  ABCDCBA
   ABCBA
    ABA
     A
*/

1.1 ~ 1.6 要求学会，1.7 ~ 1.9 拔高题，选做题

2. 方法【重点】

2.1 为什么使用方法

	生活中使用的工具，螺丝刀，锤子，扳手。
		1. 复用，重复使用
		2. 提高效率
	
	开发中，存在代码需要复用的情况。虽然循环可以解决一部分代码复用的问题，但是无法从根本上解决需要多处使用的情况。
	这里需要用到方法
	代码中使用循环解决复用的问题
		1. 代码冗余！！！
		2. 维护性极差！！！
		3. 阅读性极差！！！

https://blog.csdn.net/qq_16733389/article/details/105639231

2.2 比葫芦画瓢

// 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 方法分析过程

需求:
	使用方法展示一个Hello World	

方法分析：
	固定格式: public static 不要问
	返回值类型:
		这里不需要返回值类型，采用void
	方法名:
		printHelloWorld
		见名知意，动宾结构，小驼峰命名法
	形式参数列表:
		 当前方法没有任何的外来数据需求，不需要参数
		 ()
【方法声明】
	public static void printHelloWorld()

2.3.2 方法实现过程

/**
* 文档注释
*		1. 对于方法的功能解释
*		2. 方法所需参数介绍
*		3. 方法返回值类型介绍和含义
*		4. 方法处理过程中出现的异常
*/

/**
* 展示打印到控制台一个Hello World
*/
public static void printHelloWorld() {
    // 方法体
    System.out.println("Hello World");
}

2.3.3 方法在代码中实现的位置

方法存放的位置
	1. class大括号以内[目前的要求]
	2. 其他方法之外

/* 自定义实现第一个方法 */
class Method1 {
	public static void main(String[] args) {
		
	}
	
	/**
	* 展示打印到控制台一个Hello World
	*/
	public static void printHelloWorld() {
		// 方法体
		System.out.println("Hello World");
	}
}

2.3.4 自定义方法调用过程

记住一句话
	方法是条狗，哪里需要哪里吼

	1. 在需要调用方法的位置，使用方法名调用方法
	2. 方法和变量的最大区别
		方法后面一定有小括号！！！

/* 自定义实现第一个方法 */
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. 目前我们有且只考虑在main方法中来调用其他方法
2. main方法是目前我们现在程序的唯一入门，如果想要哪一个代码执行，哪一个方法被调用，都需要经过main方法完成
3. 方法书写一定要注意代码格式
4. 方法位置在class以内，其他方法之外

2.4 无形式参数无返回值的方法

/*
需求:
	在控制台打印展示10个烤羊排！！！

方法分析:
	固定格式: 
		public static 不要问
	返回值类型:	
		在控制台展示输出，这里不需要返回值
		void
	方法名:
		BBQ 烧烤
	形式参数列表:
		当前方法没有一个对于外来数据的需求
		() 没有参数

【方法声明】
	public static void BBQ()
*/

/**
* 展示10次烧烤内容
*/
public static void BBQ() {
    for (int i = 1; i <= 10; i++) {
        System.out.println("烤羊肉串...");
    }
}

/* 无形式参数无返回值类型的方法 */
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 方法实现过程

/*
需求：
	展示用户告知的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);   
}

/* 有参数无返回值方法演示 */
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. 方法如果在调用的过程中给定的参数个数，不是方法所预期的参数个数，报错！！！编译不通过

2.6 形式参数和实际参数是什么?

形式参数:
	我要做菜
	烤羊排:	
		材料列表：
			羊排，孜然粉，烧烤料，辣椒粉，葱姜蒜，洋葱
			以上就是做烤羊排需要的材料！！！【形式参数列表】
			
	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 一顿操作猛如虎

/*				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;
        }
	}
}