Java方法
方法的定义
方法就是完成某种功能的一段代码，相当于c语言中的函数。
定义一个方法：
修饰符 返回值类型 方法名（参数）{
方法体；
}
如：
public static int add(int a, int b){
return a+b;
}方法的使用是通过 对象名.方法名；若要想直接在main方法中使用某方法 ，可以在方法名前面加修饰符static。
（在某个类定义的变量前加上static会使变量变成类变量，在main中可以直接使用）
static 方法 可以通过 类名.方法名进行直接使用
方法的重载
方法重载满足的条件
- 方法名必须相同
- 方法中的参数必须不同（参数个数不同，参数类型不同等）
- 方法的返回值类型可以相同也可以不相同（参数相同，返回值类型不同不叫重载）
可变参数
当不确定方法中要用到多少参数时，可以使用可变参数。
使用方法：在指定参数的类型后面加一个省略号（…）；
可变参数的本质是将所有的参数放入一个数组之中
如一个可以传递任意参数的累加求和方法：
public int add(int... a){
int sum = 0;
for (int i = 0; i < a.length; i++) {
sum = sum + a[i];
}
return sum;
}注意：可变参数必须放在参数列表的最后的一个位置。
public int add(int... a，int i){} // ×
public int add(int i,int... a){} // √函数递归
定义： 一个函数在函数体中调用自己。
递归结构包含两个部分：
- 递归头：什么时候不调用自身；若没有递归头，将陷入死循环。（递归出口）
- 递归体：什么时候调用自身。
静态方法和非静态方法
在方法前加上 static 修饰符方法会变成一个静态方法。
一个类中的静态方法可以通过 类名.方法名 直接进行调用。而非静态方法必须通过对象实例化进行调用，即 new 一个具体的对象 ， 通过 对象名.方法名 进行调用。
静态方法随着类的加载也被同时加载，而非静态方法只有创建一个具体对象时才会加载。
数组
数组的定义
数组就是存放一组相同数据类型的一种数据结构。
数组的声明和创建
数组声明的两种方法：
int array[]; // 第一种
int[] array; // 第二种数组的创建（为声明的数组分配内存空间）
array = new int[10];声明和创建可以合在一起
int[] array = new int[10];数组三种初始方法
- 静态初始化
int[] array = {1,2,3}; // 创建+赋值- 动态初始化
int[] array = new int[10]; //此时 已经默认初始化
array[0] = 0;- 默认初始化：当数组内存空间被分配时，自动进行默认初始化。
数组本身就是对象，数组在声明时会存放在栈中，通过new建立出来的对象或数组都存放在堆中。
数组的使用
- 增加for循环遍历数组
int[] arrays = {1,2,3,4,5};
for(int array : arrays) // 遍历数组， 将arrays数组中的每一个元素 赋值给 遍历 array
{
system.out.println(arry+" ");
}- 数组可以作为方法中的参数
public int arraysSum(int[] arrays){} //参数为数组类型- 数组可以作为返回类型进行返回
public int[] arraysReverse(int[] arrays){} //返回值为数组二维数组
int[][] arrays{{1,2,3},{4,5,6}; //两行三列数组稀疏数组
若一个数组的中的元素大多数为 0 或者 相同的元素时， 可以用一个稀疏数组来表示该数组。
稀疏数组如何存储：第 0 行 记录 原始数组 有几行 ，几列， 多少个不同的值。
稀疏数组有三列 第一列记录原始数组中数据的行，第二列记录 列，第三列 记录 值。
稀疏数组的创建：
- 遍历原数组，用sum记录原数组中共有多少个不同的值；
- 创建稀疏数组，稀疏数组的行数为 sum+1，列数为 3；
- 为稀疏数组的第一行赋值，通过原数组的长度和sum值；
- 设置一个 count = 0 变量来控制稀疏数组的行数；
- 遍历原数组，判断数组中的每一个值是否为不同值；
- 若是，count+1 (表示稀疏数组的第 count行)，通过此时循环中的原数组的下标，对稀疏数组赋值。
稀疏数组的还原：
- 通过稀疏数组的第 0 行 创建还原数组；
- 除去第一行，遍历稀疏数组的每一行，通过每一行的第 0 1 2 三个元素确定 还原数组的下标和值；
稀疏数组的代码举例：
// 创建一个初始数组 大多数值为0的数组
int[][] array1 = new int[5][6];
array1[1][1] = 1;
array1[3][4] = 2;
array1[4][4] = 1;
//打印该初始数组
System.out.println("原始数组为：");
for (int[] arrays : array1){
for (int array : arrays){ // 增强for的嵌套使用
System.out.print(array + " ");
}
System.out.println();
}
// 为初始数组建立一个稀疏数组
//1.首先得到稀疏数组的第0行数据
int sum = 0;
for (int[] arrays : array1){
for (int array : arrays) {
if(array != 0) {
sum++;
}
}
}
System.out.println("原始数组中有多少数据："+ sum);
//2.建立压缩数组array2，为数组第一行赋值
int[][] array2 = new int[sum+1][3]; //稀疏数组的行数为 sum + 1；
array2[0][0] = array1.length;
array2[0][1] = array1[0].length;
array2[0][2] = sum; // 稀疏数组的第一行第一列赋值
// 3. 遍历初始数组，为稀疏数组赋值
int count = 0; //控制稀疏数组的行数
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if(array1[i][j] != 0) { //当值不为0时 count++
count++;
array2[count][0] = i; //将原始数组的行数赋值给 稀疏数组的第一列
array2[count][1] = j; //将原始数组的列数赋值给 稀疏数组的的二列
array2[count][2] = array1[i][j]; //将原始数字的对应值赋值给 稀疏数组的的三列
}
}
}
// 4 .打印稀疏数组
System.out.println("稀疏数组为：");
for (int[] arrays : array2){
for (int array : arrays){
System.out.print(array + " ");
}
System.out.println();
}
//还原稀疏数组
//1.创建一个新数组 行数列数 为 稀疏数组的第0行 第0列 数据；
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.遍历稀疏数组
for (int i = 1; i < array2.length; i++){
array3[array2[i][0]][array2[i][1]] = array2[i][2]; // 稀疏数组 第i行的 0 1 2 下标的值 对应 还原数组的 下标和值
}
//3.打印还原数组
System.out.println("还原过后的数组为");
for (int[] arrays : array3){
for (int array : arrays){
System.out.print(array + " ");
}
System.out.println();
}
