Java数组和方法

---

---

前言

“衣带渐宽终不悔，为伊消得人憔悴”     ----- 柳永的《凤栖梧》

Java数组和方法

1 一维数组

       指的是一种容器，可以同来存储同种数据类型的多个值。

1.1 数组的定义

       数据类型[] 数组名

       例如：int[] array

1.2 数组的初始化

1.2.1 数组的静态初始化

       数据类型[] 数组名 = {元素1，元素2，元素3，元素4…};

       例如：int[] array = {1,2,3,4,5};

1.2.2 数组的动态初始化

       数据类型[] 数组名 = new 数据类型[数组的长度];

       例如：int[] arr = new int[3];

1.2.3 数组的默认初始化值

数据类型	默认初始值
整数	0
小数	0.0
布尔	false
字符类型	‘\u0000’
引用类型	null

1.3 地址值和索引

       1. 数组的地址值：就表示数组在内存中的位置。

int[] arr = {1,2,3,4,5};
System.out.println(arr);  //[I@6d03e736

       2. 地址值解析

       以[I@6d03e736为例：

[：表示现在打印的是一个数组。

I：表示现在打印的数组是int类型的。

@：仅仅是一个间隔符号而已。

6d03e736：就是数组在内存中真正的地址值。（十六进制的）

       但是，习惯性会把[I@6d03e736这个整体称之为数组的地址值。

       3. 索引

       特点：从0开始，连续不间断，逐个+1增长

1.4 数组元素访

       数组名[索引];

       代码示例：

package com.syh;

public class Esther {
    public static void main(String[] args) {
        // 1.定义数组
        int[] arr = {1, 2, 3, 4, 5};
        // 2.获取数组中3索引上的值
        System.out.println(arr[3]);
        // 3.修改数组中3索引上的值
        arr[3] = 10;
        System.out.println("修改之后为:" + arr[3]);
    }
}

1.5 数组的遍历

       数组的长度：数组名.length;

for(int i = 0; i < arr.length; i++){
    // 数组的遍历
    System.out.println(arr[i]);
}

1.6.数组两种初始化方式的区别

       静态初始化：数组的长度和值都确定时使用

       动态初始化：数组的长度确定，值不确定时使用

2 二维数组

2.1 静态数组

       1. 静态数组定义

数据类型[][] 数组名 = {{行1}, {行2}};

       2.代码示例

package com.syh;

public class Esther {
    public static void main(String[] args) {
        // 1.定义二维数组
        int[][] arr = {{1, 2, 3}, {4, 5, 6}};
        // 2.遍历数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }
}

2.2 动态数组

       1. 动态数组定义

数据类型[][] 数组名 = new 数据类型[行数][列数];

       2. 代码示例

package com.syh;

public class Esther {
    public static void main(String[] args) {
        // 1.定义二维数组
        int[][] arr = new int[2][3];
        // 2.赋值
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = 1;
            }
        }
    }
}

3 方法

       方法（method）是程序中最小的执行单元

3.1 无参方法

3.1.1 方法定义

public static void 方法名 (   ) {
    方法体;
}

3.1.2 方法调用

方法名();

3.1.3 代码示例

package com.syh;

public class Esther {
    // 方法必须先定义，后调用
    public static void main(String[] args) {
        // 2.调用无参方法
        print();
    }
    // 1.无参方法定义
    public static void print(){
        System.out.println("hello world");
    }
}

3.2 有参方法

3.2.1 方法定义

       参数范例：int a

public static void 方法名 (参数1, 参数2...) {
	方法体;
}

3.2.2 方法调用

方法名(参数1,参数2);

3.2.3 代码示例

package com.syh;

public class Esther {
    public static void main(String[] args) {
        // 2.调用有参方法
        int result = sum(10, 20);
        System.out.println(result);
    }
    
    // 1.有参方法定义
    public static int sum(int a, int b) {
        int c = a + b;
        return c;
    }
}

3.2.4 形参和实参

       1. 形参：方法定义中的参数

              例如：int a，int b

       2. 实参：方法调用中的参数

              例如： int result

3.2.5 方法的通用格式

public static 返回值类型 方法名(参数) {
   方法体; 
   return 数据 ;
}

3.3. 方法重载

在Java中，方法重载（Overloading）是指在同一类中存在多个同名方法，但这些方法的参数列表必须不同（参数的数量、类型或顺序）

代码示例

package com.syh;

public class Esther {
    public static void main(String[] args) {
        // 方法重载
        int result1 = sum(10, 20);
        System.out.println(result1);   // 30

        double result2 = sum(10.5, 20.5);
        System.out.println(result2);   // 31.0
    }

    public static int sum(int a, int b) {
        int c = a + b;
        return c;
    }

    public static double sum(double a, double b) {
        double c = a + b;
        return c;
    }
}