# zb_java0721

**Repository Path**: Fsj0803/zb_java0721

## Basic Information

- **Project Name**: zb_java0721
- **Description**: 方法与数组
- **Primary Language**: Java
- **License**: GPL-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 5
- **Created**: 2018-07-21
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# zb_java0721

# 教学目标
	1.方法（函数）
# 课堂笔记
## 1 方法
### 1.1 方法概念
	方法就是以函数的形式封装起来的语句块，用于完成特定的功能。也叫作函数。
	语法：
		访问控制修饰符  其他是修饰符 返回值类型 方法名(形参列表){
			方法体;
		}
	解析：
		（1）访问控制修饰符可以使用  public protected 默认的 private。 
		（2）其他修饰符 static final abstract default等。
		（3）返回值类型就是java的数据类型（基本类型和对象类型）和void类型。
			void表示没有返回值。
		（4）方法名，命名规范：动名词形式，第一个单词首字母小写，后面的首字母大写；
		（5）形参列表中多个形参之间采用逗号分隔，每个形参采用变量声明的方式进行定义。
			例如： int age,int score   
		（6）{}中的内容是该方法的方法体
		（7）如果方法的返回值类型不是void，则需要在程序中覆盖每个分支，
			使用 “return 表达式”; 形式将该方法需要返回的值进行返回处理；
			如果方法的返回值类型为void，则可以使用 return;返回上层方法调用者。【注意，return后面没有表达式】
		（8）return关键字使用用于从子方法中返回到主方法作用。在主程序流程中，return语句到方法体结束的部分是无法到达的代码；
	代码[com.yuw.fun.Test01]:		
		```
		/**
	 * 计算两个数相加之和
	 * 
	 * @param x
	 *            形参：加数1
	 * @param y
	 *            形参：加数2
	 * @return 相加之和
	 */
	private static int add(int x, int y) {
		// 返回值
		int sum = 0;
		// 业务逻辑处理
		sum = x + y;
		return sum;
	}

	/**
	 * void方法中使用return void返回值类型，return语句不需要覆盖所有的分支
	 * 
	 * @param flag
	 */
	private static void showMe(int flag) {
		if (flag == 1) {
			System.out.println("形参的值为：" + flag);
			return;
		}

		if (flag != 1) {
			System.out.println("你没有猜对！");
			return;
		}
		System.out.println("游戏结束");
	}

	/**
	 * 非void返回值类型，return语句需要覆盖所有的分支
	 * 
	 * @param flag
	 * @return
	 */
	private static int showMe2(int flag) {
		if (flag == 1) {
			System.out.println("形参的值为：" + flag);
			return flag;
		}

		if (flag != 1) {
			System.out.println("你没有猜对！");
			return flag;
		}

		// 如果两个if都不执行时，也需要有返回值
		return flag;
	}

	/**
	 * 非void返回值类型，return语句需要覆盖所有的分支
	 * 
	 * @param flag
	 * @return
	 */
	private static int showMe3(int flag) {
		if (flag == 1) {
			System.out.println("形参的值为：" + flag);
			return flag;
		} else {
			System.out.println("你没有猜对！");
			return flag;
		}
		// System.out.println();
		// 如果两个if都不执行时，也需要有返回值
		// return flag;
	}
		```

### 1.1 方法调用和方法重载
* 1 方法调用
	方法调用是通过 方法名(实参列表)的形式进行调用；
	方法调用时，要求实参列表和形参列表在个数、类型一一对应。
	方法调用时实参变量的值会传递给形参，然后执行被调用方法的方法体，并根据要求返回结果；
	注意：
		实参列表和形参列表不同：
			实参只是变量名，没有参数类型；
			形参有参数类型；
		实参和形参一一对应；
		
* 2 方法重载
	方法重载就是在一个类中具有一系列同名的方法，这些方法之间就构成了重载关系；	
	方法重载要求：方法名相同，形参不同。
	 
		
* 3 重载方法调用
	重载方法调用时要求实参列表和形参列表一一对应；
	重载方法调用时，具体调用那个重载方法取决于给定什么样实参列表；	
	
	代码[com.yuw.fun.Test02]:
	```
			public static void main(String[] args) {
		// 重载方法调用
		String strF = "林黛玉"; // 实参
		double money = 1000; // 实参
		// shopping("林黛玉", 1000); // 匿名变量的实参列表
		shopping(strF, money);
	}

	/**
	 * 购物
	 */
	private static void shopping() {
		System.out.println("I am shopping..");
	}

	/**
	 * 购物
	 * 
	 * @param strFrieds
	 *            形参
	 */
	private static void shopping(String strFrieds) {
		System.out.println("I am shopping with " + strFrieds);
	}

	/**
	 * 购物
	 * 
	 * @param strFrieds
	 *            形参
	 */
	private static void shopping(double costMoney) {
		System.out.println("I am shopping with money of " + costMoney);
	}

	/**
	 * 购物
	 * 
	 * @param strFrieds
	 * @param costMoney
	 */
	private static void shopping(String strFrieds, double costMoney) {
		System.out.println("I am shopping with girlfriend " + strFrieds + ",and costing Money of " + costMoney);
	}

	/**
	 * 购物
	 * 
	 * @param strFrieds
	 * @param costMoney
	 */
	private static void shopping(double costMoney, String strFrieds) {
		System.out.println("I am shopping with boyfriend " + strFrieds + ",and costing Money of " + costMoney);
	}

	/**
	 * 购物
	 * 
	 * @param strFrieds
	 * @param costMoney
	 */
	public static String shopping(String strFrieds, String strFrieds2) {
		System.out.println("I am shopping with friend " + strFrieds + ", " + strFrieds2);
		return "";
	}

	/**
	 * 购物
	 * 
	 * @param strFrieds
	 * @param costMoney
	 */
	// 形参列表都是同一种类型时，顺序不同构不成重载；
	// private static void shopping( String strFrieds2,String strFrieds) {
	// System.out.println("I am shopping with friend " + strFrieds + ", " +
	// strFrieds2);
	// }
	```
		
* 4 变长参数

## 2 数组
### 2.1 一维数组概念
* 1 数组概念

	数组：是一组类型相同的、连续存储的数的集合；
	数组是java数据类型中的一种，具有和对象类型相同特性；
	解析：
		类型相同；
		连续存储；		
* 2 数组的声明和定义

	数组的声明：
		语法：
			数据类型[] 变量名;// java习惯，推荐写法
			数据类型  变量名[]; // c语言习惯
		
		初始化：
			变量名 = new 数据类型[数组长度];
			变量名 = new 数据类型[]{逗号分隔的值列表};
	数组的声明和初始化可以合并：
		语法：
			数据类型[] 变量名 = new 数据类型[数组长度];
			数据类型[] 变量名 = new 数据类型[]{逗号分隔的值列表}; // 数组的长度由{}中元素的个数确定
			
			// 以下写法，声明和初始化不能分开
			数据类型[] 变量名 = {逗号分隔的值列表};
	解析：
		（1）数据类型可以是java的任何数据类型(基本类型和对象类型)
		（2）数组在初始化时使用了new关键字进行内存分配；【new关键字是用于分配内存的】
		（3）数组的内存一旦分配完成，就不能在改变。【数组的长度一旦分配完内存之后，是不允许改变的】
			数组的长度是不能改变的；
		（4）数组的变量名是数组在内存中的入口地址；
		（5）数组变量名.length 属性可以获取数组的长度；
		（6）数组的所有的元素在内存中是连续存储的，所有数组的每个元素都有下标，且下标从0开始；
			数组变量名[下标] 这种方式可以获取或设值该下标对应的元素的值； 
		（7）数组在new分配完内存之后，就会有默认值。
			各种数据类型的默认值：
			byte		short	int long float double char boolean  对象类型	String  
			0		 0		0    0     0.0  0.0     '\0' false     null    null
			
	代码[com.yuw.arr.Test03]:
		```
			/**
	 * 数组的声明和初始化
	 */
	private static void test01() {
		// 声明
		int[] arr0;
		int arr1[];
		// 初始化
		arr0 = new int[5];
		arr1 = new int[] { 1, 2, 3, 4, 5 };
		// 声明和初始化可以合并写
		// 以下方式，声明和初始化不能够分开写
		int[] arr2 = { 1, 2, 3, 4, 5 };

		// 编译错误
		// int[] arr3;
		// arr3={1,2,3,4,5};
		
		int[][] arr10;
	}
		```		
* 2 数组的遍历

	因为数组有下标，所有可以通过下标循环的方式遍历数组中每个元素的值；
* 2.1 for循环遍历数组

	代码[com.yuw.arr.Test03]:
	```
		/**
	 * 数组的for循环遍历
	 */
	private static void test02() {
		// 声明并初始化一个数组
		int[] arr0 = new int[] { 9, 8, 7, 6, 5, 43, 2, 1 };
		// for循环遍历数组
		for (int i = 0; i < arr0.length; i++) {
			// 取出数组小标为i的元素的值
			int temp = arr0[i];
			System.out.print(" " + temp);
		}
		// 换行
		System.out.println();
	}
	```
* 2.2 增强型for循环遍历数组

	是标准for循环的简写形式。
	增强型的for循环遍历数组：
	代码[com.yuw.arr.Test03]:
	```
		/**
	 * 数组的增强型的for循环遍历
	 */
	private static void test021() {
		// 声明并初始化一个数组
		int[] arr0 = new int[] { 9, 8, 7, 6, 5, 43, 2, 1 };
		// 增强型的for循环:标准for循环的简写形式
		for (int temp : arr0) {
			// 遍历temp的值为每次循环时取出的元素的值
			System.out.print(" " + temp);
		}
		// 换行
		System.out.println();
	}
	```

### 2.2 二维数组概念

* 1 二维数组概念

	二维数组可以表示二维关系。例如，行和列的关系；
	在二维数组中，每个元素有两种下标，一种是行标，一种列标；【行标在前，列标在后】

* 2 二维数组的声明和定义

	数组的声明：
		语法：
			数据类型[][] 变量名;// java习惯，推荐写法
			数据类型  变量名[][]; // c语言习惯
		
		初始化：
			变量名 = new 数据类型[行数][列数];
			// 内层{}个数决定行数；最内层值列表中值的个数决定列数；
			变量名 = new 数据类型[][]{{逗号分隔的值列表1},{逗号分隔的值列表2},{逗号分隔的值列表n}};
	数组的声明和初始化可以合并：
		语法：
			数据类型[][] 变量名 = new 数据类型[行数][列数];
			数据类型[][] 变量名 = new 数据类型[][]{{逗号分隔的值列表1},{逗号分隔的值列表2},{逗号分隔的值列表n}}; 
			
			
			// 以下写法，声明和初始化不能分开
			数据类型[] 变量名 = {{逗号分隔的值列表1},{逗号分隔的值列表2},{逗号分隔的值列表n}};
	
	数组的行和列可以分开进行声明定义：
		语法：
			// 第一步：声明定义时，只指定了行数，列数进行单独声明初始化；
			数据类型[][] 变量名 = new 数据类型[行数][];
			// 第二部：单独对每行进行声明初始化
			变量名[0] = new 数据类型[列数];
			变量名[1] = new 数据类型[]{逗号分隔的值列表};
			......
			变量名[n] = new 数据类型[列数];
			
	解析：
		（1）数组变量名.length属性获取行数；数组变量名[行标].length属性获取的是当前行的列数；
		（2）数组变量名[i][j]获取的是行标为i的，列标为j所对应的元素的值；
		（3）
* 3 二维数组的遍历

	二维数组需要使用双层嵌套循环来进行遍历，外层for循环遍历行；内层for遍历列；
	
	代码[]:
	```
		/**
	 * 二维数组定义和遍历
	 */
	private static void test03() {
		// 二维数组的声明和定义
		// 形式1
		int[][] arr0;
		arr0 = new int[3][3];
		// 形式2
		int[][] arr1 = new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
		// 形式3
		int[][] arr2 = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
		// 形式4
		int[][] arr3 = new int[3][];
		arr3[0] = new int[3];
		arr3[1] = new int[] { 3, 4, 5 };
		arr3[2] = new int[3];

		// 二维数组的遍历
		// 外层for循环遍历行数
		for (int i = 0; i < arr1.length; i++) {
			// 内层for循环遍历列数
			for (int j = 0; j < arr1[i].length; j++) {
				// 使用行标和列标取出对应元素的值
				int temp = arr1[i][j];
				System.out.print(" " + temp);
			}
			// 换行
			System.out.println();
		}

		System.out.println("=====================");
		// 外层for循环遍历行数
		for (int[] tempArr : arr1) {
			// 外层for循环的临时变量 tempArr获取的是二维数组的一行【一维数组】
			for (int temp : tempArr) {
				System.out.print(" " + temp);
			}
			// 换行
			System.out.println();
		}
	}
	```	
#### 使用说明

1. xxxx
2. xxxx
3. xxxx

#### 参与贡献

1. Fork 本项目
2. 新建 Feat_xxx 分支
3. 提交代码
4. 新建 Pull Request


#### 码云特技

1. 使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
2. 码云官方博客 [blog.gitee.com](https://blog.gitee.com)
3. 你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解码云上的优秀开源项目
4. [GVP](https://gitee.com/gvp) 全称是码云最有价值开源项目，是码云综合评定出的优秀开源项目
5. 码云官方提供的使用手册 [http://git.mydoc.io/](http://git.mydoc.io/)
6. 码云封面人物是一档用来展示码云会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)