Java学习总结（方法、数组）

最新推荐文章于 2024-01-07 11:56:33 发布

Qinqin.J

最新推荐文章于 2024-01-07 11:56:33 发布

阅读量713

点赞数

文章标签：学习 java

本文链接：https://blog.youkuaiyun.com/2202_75688394/article/details/129749207

版权

本文介绍了Java中方法的基本概念，包括无返回值和有返回值的方法定义与调用，以及方法的重载。接着详细讲解了数组的定义、初始化、遍历、最值获取和排序，特别提到了数组索引异常和空指针异常。最后，文章讨论了二维数组的定义和使用案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

（1）错误：ArrayIndexOutOfBoundsException

（2）错误空指针异常NullPointerException

选中所要使用方法调用的代码 ctrl + Alt +m 就能得到方法的调用

输入sout+回车键就可以得到打印代码

学习Java的方法、数组

一、方法

1、什么是方法

方法就是一段可以重复调用的代码。

定义方法的语法格式

修饰符 返回值类型 方法名 (参数类型 参数名1, 参数类型 参数名2, ... ){
      执行语句
      ...
      return 返回值;
}

对于方法的语法格式，具体说明如下：

修饰符：方法的修饰符比较多，例如，对访问权限进行限定的修饰符、static 修饰符、final修饰符等。
返回值类型：用于限定方法返回值的数据类型。
参数类型：用于限定调用方法时传入参数的数据类型。
参数名：是一个变量，用于接受调用方式时传入参数的数据类型。
return关键字：用于返回方法指定类型的值并结束方法。
返回值：被return语句返回的值，该值会返回给调用者。

需要注意的是，方法中的“ 参数类型参数名1，参数类型参数名2 ”称为参数列表，参数列表用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即( )内不写任何内容。方法的返回值类型必须是方法声明的返回值类型，如果方法没有返回值，返回值类型要声明为void，此时，方法中returm语句可以省略。

演示方法的定义与调用的案例

public class A3 {
    public static void main(String[] args) {
        printRectangle(3,5);
        printRectangle(2,4);
        printRectangle(6,10);
      // 调用printRectangle（）方法实现打印
    }
    // 下面定义了一个打印矩形的方法，接收两个参数，其中height为高，width为宽
    public static void printRectangle (int height, int width){
        // 下面使用for循环实现 * 打印矩形
        for (int i = 0; i < height; i++){
            for (int j = 0; j < width; j++){
                System.out.print("*"); // 打印的时候不换行
            }
            System.out.println(); //打印的时候换行
        }
        System.out.println(); // 打印的时候换行
    }
}

第8~17行代码定义了一个方法 printRectangle()，内实现打印矩形的代码是方法体，printRectangle是方法名，方法名后面()中的height和width是方法的参数，方法名前面的void表示方法没有返回值。第3～5行代码调用 printRectangle()方法传入不同的参数，分别打印出3行5列、2行4列和6行10列的矩形。

演示有返回值方法的定义与调用

public class Example20 {
    public static void main(String[] args) {
        int area = getArea(3,4); // 调用getArea方法
        System.out.println("这个矩形的面积是：" +area);
    }
    // 下面定义了一个求矩形面积的方法，接收两个参数，其中x为高，y为宽
    public static int getArea(int x ,int y){
        int s = x * y; // 使用变量 s 记住运算结果
        return s;  // 将变量 s 的值返回
    }
}

getArea( ) 方法的完整调用过程

四则运算的案例

public class Exc02 {
    public static void main(String[] args) {
        // 四则运算 x ， y 为值 ，ch 为运算符号
        int result = szys(3,4,'+');
        System.out.println("结果为" + result);
    }
    public static int szys(int x ,int y,char ch){
        if (ch == '+'){
            return x + y;
        }if (ch == '-'){
            return x - y;
        }if (ch == '*'){
            return x * y;
        }if (ch == '/'){
            return x / y;
        }
        System.out.println("符合错误");
        return 0;
    }
}

2、方法的重载

方法重载，就是在同一个作用域内方法名相同但参数个数或者参数类型不同的方法。例如，在同一个作用域内同时定义3个add()方法，这3个add()方法就是重载函数。

public class Example21 {
    public static void main(String[] args) {
        // 下面是针对求和的方法调用
        int sum1 = add(1,2);
        int sum2 = add(1,2,3);
        double sum3 = add(1.2,2.3);
        // 下面的代码是打印求和的结果
        // System.out.println("sum1=" +sum1 +"sum2=" +sum2 +"sum3=" +sum3);
        System.out.println("sum1=" +sum1);
        System.out.println("sum2=" +sum2);
        System.out.println("sum3=" +sum3);
    }
    // 下面的方法实现了两个整数相加
    public static int add(int x ,int y){
        return x + y;
    }
    // 下面的方法实现了三个整数相加
    public static int add(int x ,int y,int z){
        return x + y;
    }
    // 下面的方法实现了两个小数相加
    public static double add(double x ,double y){
        return x + y;
    }
}

二、数组

数组，是指一组类型相同的数据的集合，数组中的每个数据称为元素。数组可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。数组可分为一维数组和多维数组。

1、数组的定义

在Java中，声明数组的方式有以下两种。

第一种方式：

数据类型 [ ] 数组名 = null ；

第二种方式：

数据类型 [ ] 数组名；

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

这两种语法本身没有任何区别，下面以第二种方式声明一个数组，如下示例：

int [ ] x ;  // 声明一个int [ ] 类型的变量
x = new int [ 100 ] ; // 为数组下分配100个元素空间

上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x [1]，依次类推，第100个变量的名称为x[99]，这些变量的初始值都是0。
第一行代码声明了一个变量x，该变量的类型为int[ ]，即声明了一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。

变量x的内存状态

第二行代码x=new int [100]；创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x引用数组。

变量x在内存中的状态变化

上述图片中描述，变量x引用数组的情况。该数组中有100个元素，初始值都为0。数组中的每个元素都有一个索引(也可称为角标)，可以通过x [0]，x [1]，···，x [98]，x[99]的形式访问数组中的元素。需要注意的是，数组中最小的索引是0，最大的索引是“ 数组的长度-1 ”。在Java中，为了便于获得数组的长度，提供了一个length属性，在程序中可以通过“ 数组名.length ”的方式获得数组的长度，即元素的个数。

示例：

public class Example22 {
    public static void main(String[] args) {
/*        int [] arr;  // 声明变量
        arr =new int[3];  //创建数组对象
        System.out.println("arr[0]=" + arr[0]);  // 访问数组中的第一个元素
        System.out.println("arr[1]=" + arr[1]);  // 访问数组中的第二个元素
        System.out.println("arr[2]=" + arr[2]);  // 访问数组中的第三个元素
        System.out.println("数组的长度是：" + arr.length);  // 打印数组长度
        */
        float [] arr;  // 声明变量
        arr =new float[3];  //创建数组对象
        System.out.println("arr[0]=" + arr[0]);  // 访问数组中的第一个元素
        System.out.println("arr[1]=" + arr[1]);  // 访问数组中的第二个元素
        System.out.println("arr[2]=" + arr[2]);  // 访问数组中的第三个元素
        System.out.println("数组的长度是：" + arr.length);  // 打印数组长度
    }
}

不同数据类型的数组元素的默认值初始值

在定义数组只指定数组的长度，由系统自动为元素赋初值的方式称为动态初始化。在初始化数组时还有一种方式称为静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式，

具体格式如下：

类型 [ ] 数组名 = new 类型 [ ] { 元素，元素， ... } ；

类型 [ ] 数组名 = { 元素，元素，元素，... } ；

public class Example24 {
    public static void main(String[] args) {
        int [] arr = {1,2,3,4}; // 静态初始化
        // 依次访问数组中的元素
        System.out.println("arr[0] = " + arr[0]);
        System.out.println("arr[1] = " + arr[1]);
        System.out.println("arr[2] = " + arr[2]);
        System.out.println("arr[3] = " + arr[3]);
    }
}

采用静态初始化的方式为每个元素赋初值，其值分别是1，2，3，4。需要注意的是，文件中的第3行代码千万不能写成“ int [ ] x = new int [4]{1，2，3，4} ; ”，否则编译器会报错。原因在于编译器会认为数组限定的元素个数[4]与实际存储的元素{ 1,2，3，4}个数有可能不一致，存在一定的安全隐患。

数组索引

（1）错误：ArrayIndexOutOfBoundsException

数组是一个容器，存储到数组中的每个元素都有自己的自动编号，最小值为0，最大值为数组长度-1，如果要访问数组存储的元素，必须依赖于索引。在访问数组元素时，索引不能超出0~length-1的范围，否程序会报错。

示例：

public class Example25 {
    public static void main(String[] args) {
        int [] arr = new int[4]; // 定义一个长度为4的数组
        System.out.println("arr[0]=" + arr[4]); // 通过索引4访问数组元素
    }
}

运行结果中所提示的错误信息“ArrayIndexOutOfBoundsException”表示数组越界异常，出现这个异常的原因是数组的长度为4，索引范围为0～3，文件2-25中的第4行代码使用索引4访问元素时超出了数组的索引范围。

（2）错误空指针异常NullPointerException

在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常。

public class Example26 {
    public static void main(String[] args) {
        int [] arr = new int[3] ;  //定义一个长度为3的数组
        arr[0] = 5;  // 为数组的第一个元素赋值
        System.out.println("arr[0]=" + arr[0]);  // 访问数组的元素
        arr = null;  // 将变量arr置为null
        System.out.println("arr[0]=" + arr[0]);  // 访问数组的元素
    }
}

第4～5行代码都能通过变量arr正常地操作数组。第6行代码将变量置为null，第7行代码再次访问数组时就出现了空指针异常“NullPointerException”。

2、数组的常见操作

（1）数组的遍历

在操作数组时，经常需要依次访问数组中的每个元素，这种操作称为数组的遍历。

使用for循环遍历数组

public class Example27 {
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5};
        // 使用for循环遍历数组的元素
        for (int i = 0; i < arr.length; i++){
            System.out.println(arr[i]); // 通过索引访问元素
        }
    }
}

（2）最值的获取

public class Example28 {
    public static void main(String[] args) {
        int [] arr = {4,1,6,3,9,8};  //定义一个数组
        int max = getMax (arr);  //调用获取元素最大值的方法
        System.out.println("max=" + max); //打印最大值
        int min = getMin(arr);  //调用获取元素最大值的方法
        System.out.println("Min=" +min); //打印最小值
    }
    // 最小值
    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int x = 1; x < arr.length; x++){
            if (arr[x] < min){ //比较arr[x]的值是否小于min
                min = arr[x]; //条件成立，将arr[x]的值赋给min
            }
            //这里放的打印语句会把每次循环结果打印出来
        }
        return min;  //返回最小值
    }
    //最大值
    public static int getMax (int[] arr){
        int max = arr[0]; // 定义变量max用于记住最大数，首先假设第一个元素为最大值
        //通过for循环遍历数组中的元素
        for (int x =1 ; x < arr.length;x++){
            if (arr[x] > max){ //比较arr[x]的值是否大于max
                max = arr[x]; //条件成立，将arr[x]的值赋给max
            }
        }
        return max; //返回最大值
    }
}

（3）数组的排序

在操作数组时，经常需要对数组中的元素进行排序。下面为读者介绍一种比较常见的排序算法——冒泡排序。在冒泡排序的过程中，不断地比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程与水中气泡上升的原理相似。
下面通过几个步骤分析冒泡排序(以升序为例)的整个过程，具体如下。
第一步：从第一个元素开始，将相邻的两个元素依次进行比较，如果前一个元素比后一个元素大，则交换它们的位置，直到最后两个元素完成比较。整个过程完成后，数组中最后一个元素自然就是最大值，这样也就完成了第一轮比较。
第二步：除了最后一个元素，将剩余的元素继续进行两两比较，过程与第一步相似，这样就可以将数组中第二大的元素放在倒数第二个位置。
第三步：依次类推，持续对越来越少的元素重复上面的步骤，直到没有任何一对元素需要比较为止。

public class Example29 {
    public static void main(String[] args) {
        int [] arr ={9,8,3,5,2};
        System.out.println("冒泡排序前：");
        printArray(arr);  //打印数组元素
        bublleSort(arr);  //调用排序方法
        System.out.println("冒泡排序后：");
        printArray(arr);  //打印数组元素
    }
    //定义打印数组元素的方法
    public static void printArray(int[] arr) {
        //循环遍历数组的元素
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " "); //打印元素和空格
        }
        System.out.println();  //换行
    }
    //定义对数组排序的方法
    private static void bublleSort(int[] arr) {
        //定义外层循环
        for (int i = 0; i < arr.length-1; i++){  //i表示轮数，-1是因为每一轮的最后一个元素不用比较
            //定义内层循环
            for (int j = 0; j < arr.length-i-1; j++){  //-i是因为每一轮的最后一个元素不用比较
                if (arr[j] > arr[j + 1]){  //比较相邻元素
                    //下面的三行代码用于交换两个元素
                    int temp = arr[j];  //不能不定义一个变量因为arr[j]和arr[j+1]都有值
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("第" + (i + 1) +"轮排序后：");
            printArray(arr); //每轮比较结束打印数组元素
        }
    }
}

冒泡排序执行过程

变量temp交换过程

3、二维数组

需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组，即数组的元素是一个数组。

二维数组的定义有很多方式。

（1）第一种方式

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

下面以第一种方式声明一个数组：

int [] [] xx = new int [3] [4] ;

二维数组xx [ 3 ] [ 4 ]

（2）第二种方式

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

下面以第二种方式声明一个数组：


int [] [] xx = new int [3] [] ;

二维数组xx [ 3 ] [ ]

（3）第三种方式

数据类型 [ ] [ ] 数组名 = { { 第0行初始值} ， { 第1行初始值 } ， ... ， { 第n行初始值 } } ;

下面以第二种方式声明一个数组：

int [ ] [ ] xx = { {1,2} ,{3,4,5,6} ,{7,8,9} };

二维数组xx

二维数组中元素的访问呢也是通过索引的方式。例如：访问二维数组的arr中的第一个元素数组的第二个元素，代码如下：

arr [0] [1] ;

二维数组的案例

public class Example30 {
    public static void main(String[] args) {
        int [] [] arr = new int[3][] ; //定义一个长度为3的二维数组
        arr[0] = new int[] {11,12};  // 为数组的元素赋值
        arr[0] = new int[] {21,22,23};
        arr[0] = new int[] {31,32,33,34};
//        int [] [] arr = {{11,12}, {21,22,23}, {31,32,33,34}};
        int sum = 0; //定义变量记录总销售额
        for (int i = 0; i < arr.length; i++){  //遍历数组元素 i控制组数
            int groupSum = 0; //定义变量记录小组销售总额
            for (int j = 0; j < arr[i].length; j++){ //遍历小组内每个人的销售额
                groupSum = groupSum + arr[i][j];
            }
            sum = sum + groupSum; //累加销售额
            System.out.println("第" + (i + 1) + "小组销售额：" +groupSum + "万元。");
        }
        System.out.println("总销售额为：" + sum + "万元。");
    }
}