1.Java方法详解
1.什么是方法
System.out.println() 解析：
System是类，out是对象，println()是方法
方法用static修饰后可以直接在主函数调用
方法在程序中被创建，在其他地方被引用
一个方法只完成一个功能，这样有利于后期扩展
2.方法的定义和调用
方法的定义：
java
修饰符 返回值类型 方法名 (参数类型 参数名){
方法体
...
return 返回值;
}形参与实参 ：形参起定义的作用，实参是调用方法时传入的参数
return 传递方法返回值，会结束方法
方法的调用 ：
有返回值时：方法调用被当作一个值
java
int larger = max(30,40);无返回值时：方法调用一定是一条语句
java
System.out.println("xxxx")
// 对象名.方法名课后扩展 ：什么是值传递，什么是引用传递？
值传递：传递的是数据的副本。函数内部修改参数，不会影响原始数据。Java属于值传递
引用传递：传递的是数据的内存地址（引用）。函数内部修改参数，会直接影响原始数据。
3.方法重载
重载就是同一个类中，方法名相同，但是参数列表必须不同 （参数类型、参数多少、参数排列顺序），返回值可以相同也可以不同
java
public static void main(String[] args) {
int sum = add(1,2);
int sum2 = add(1,2,3);
System.out.println(sum);
System.out.println(sum2);
}
public static int add(int a, int b){
return a+b;
}
public static int add(int a, int b, int c){
return a+b+c;
}4.命令行传参
可以在程序运行时给主函数传参
主函数的参数本质上就是一个名为args的String数组
在主函数中通过接收args数组中的内容可以做一些输出
通过javac编译代码为class文件，运行class文件时传递字符串数组参数，命令行运行后即可得到输出
注意如果java文件中有包名，运行class文件时，需要回退到文件夹后调用包名.文件名
流程演示
- 编写main函数
java
public class Cmd {
public static void main(String[] args) {
for (String arg : args){
System.out.println(arg);
}
}
}-
代码处打开命令行
-
命令行输入
5.可变参数
可变参数也叫不定项参数，是指函数或方法可以接受不定数量的参数的特性。也就是说，你在调用函数时，可以传 0 个、1 个、2 个，甚至任意多个参数给同一个参数位置
在方法声明中，在指定参数类型后加一个省略号(...)
一个方法只能指定一个可变参数，它必须是方法的最后一个参数
是一个数组，需要取出数组中具体的值才能看到参数，否则输出是地址
java
public void printAll(String... strings) {
for (String s : strings) {
System.out.println(s);
}
}
// 调用
printAll("a", "b", "c");
printAll(); // 可以传0个6.递归
递归就是A方法调用A方法自己
递归调用不当会造成栈溢出 StackOverflowError
递归包含两部分 ：
递归头： 什么时候不调用自身方法，如果没有递归头，将陷入死循环
递归体： 什么时候调用自身方法
递归实现阶乘方法：
java
public class Factorial {
public static void main(String[] args) {
// 实现5的阶乘
int n = 5;
int result = factorialRecursive(n);
System.out.println(n + "! = " + result); // 输出: 5! = 120
}
public static int factorialRecursive(int n) {
// 递归出口：0! = 1, 1! = 1
if (n <= 1) {
return 1;
}
// 递归调用：n! = n * (n-1)!
return n * factorialRecursive(n - 1);
}
}方法执行过程：
factorialRecursive(5)
= 5 * factorialRecursive(4)
= 5 * (4 * factorialRecursive(3))
= 5 * (4 * (3 * factorialRecursive(2)))
= 5 * (4 * (3 * (2 * factorialRecursive(1))))
= 5 * (4 * (3 * (2 * 1)))
= 120能不用递归就不用递归，基数小可以用递归，快，大基数用递归会崩，栈溢出
2.数组
数组是一种最基础的数据结构，用于在内存中连续存储一组相同类型的数据元素
1.数组的定义
java
int[] arr; //声明arr数组
arr = new int[5]; //创建长度为5的数组，固定长度，创建后长度不可变
int[] arr = new int[5]; //直接创建数组也可以
arr[0] = 1;//给数组元素赋值
arr[0] = 2;
//... 不赋值默认为0
int length = arr.length;//arrays.length可以获取数组长度2.Java内存分析
认识堆栈 ：
数组定义创建赋值过程 ：
3.数组的三种初始化
1.静态初始化
java
int[] arr2 = {1, 2, 3};2.动态初始化
java
int[] arr = new int[5]; // 此时 arr 中元素全是 0
arr[0] = 10; // 手动赋值
arr[1] = 20;
动态初始化包含默认初始化3.默认初始化
java
int[] arr = new int[5]; // 此时 arr 中元素全是 04.数组的四个基本特点
-
长度固定
数组一旦创建，其元素个数就不能改变。如果需要可变长度，需使用集合类（如 ArrayList）
-
元素类型相同
一个数组中的所有元素必须是同一种数据类型（可以是基本类型或引用类型），不允许混合存储不同类型的数据
-
内存连续
数组中的元素在内存中按顺序连续存储。这是实现快速随机访问的基础
-
引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象实在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
5.多维数组
多维数组本质上就是"数组的数组"。即一个数组中的每个元素，本身又是一个数组，从而形成多个维度
java
int[][] arr = {{1, 2, 3},{4, 5, 6},{7, 8, 9}，{2，3，4}};图片理解 ：
遍历取数：
java
for (int i = 0; i < matrix.length; i++) { // 遍历行
for (int j = 0; j < matrix[i].length; j++) { // 遍历列
System.out.print(matrix[i][j] + "\t");
}6.数组工具类Arrays
Arrays 是 Java 提供的一个工具类，位于 java.util 包，包含大量静态方法，用于对数组进行常见操作，如排序、搜索、比较、填充、转换为字符串等，可以通过导包后查看源码进行学习
1.打印数组
直接打印数组输出的是数组对象的hashcode
java
int[] array = {1,2,3,4,5,6};
System.out.println(array);
// 输出：[I@4eec7777Arrays.toString( )方法
java
int[] array = {1,2,3,4,5,6};
System.out.println(Arrays.toString(array));
// 输出：[1, 2, 3, 4, 5, 6]工具类没必要过度依赖，自己也是可以写工具类的
2.数组排序
Arrays.sort( )方法
java
int[] array = {1,2,3,4,5,6,2,4,5};
Arrays.sort(array);
System.out.println(Arrays.toString(array));
// 输出：[1, 2, 2, 3, 4, 4, 5, 5, 6]3.数组填充
Arrays.fill( )方法
java
int[] array = {1,2,3,4,5,6,2,4,5};
Arrays.fill(array,0,4,10);
System.out.println(Arrays.toString(array));
// 输出：[10, 10, 10, 10, 5, 6, 2, 4, 7.冒泡排序
java
// 冒泡排序（自己写的）
public static void mysort(int[] array) {
for (int j = 0; j < array.length; j++) {
for (int i = array.length - 1; i > j; i--) {
if (array[i - 1] > array[i]) {
int temp = array[i];
array[i] = array[i - 1];
array[i - 1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
public static void main(String[] args) {
int[] array = {7,4,3,2,5,6,2,4,5};
mysort(array);
}8.稀疏数组
稀疏数组是一种针对大部分元素值相同（通常为0或null）的数组的压缩存储方式，用于节省内存空间
稀疏数组含义：
自己写的代码：
java
// 稀疏数组
// 1.先存储原始的二维数组
public static void printarray(int[][] array){
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]+"\t");
}
System.out.println();
}
}
public static int[][] sparsearray(int[][] array){
//1.获得有效值个数，确定稀疏数组的size
int count = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if(array[i][j]!=0){
count++;
}
}
}
int[][] result = new int[count+1][3];
result[0][0] = array.length;
result[0][1] = array[1].length;
result[0][2] = count;
//2.获取有效值，填入稀疏数组
int newcount = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if(array[i][j]!=0){
newcount++;
result[newcount][0] = i;
result[newcount][1] = j;
result[newcount][2] = array[i][j];
}
}
}
return result;
}
public static int[][] reverse(int[][] array){
int a = array[0][0];
int b = array[0][1];
int[][] result = new int[a][b];
// int[][] result = new int[array[0][0]][array[0][1]]
for (int i = 1; i < array.length; i++) {
int x = array[i][0];
int y = array[i][1];
int value = array[i][2];
result[x][y] =value;
// result[array[i][0]][i][1]] = array[i][2];
}
return result;
}
public static void main(String[] args) {
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//printarray(array1);
//printarray(sparsearray(array1));
printarray(reverse(sparsearray(array1)));
}