Java中数组与方法的基本概念

1. 数组

1.1 数组定义与初始化

数组概述：数组(array)是一种用于存储多个相同类型数据的存储类型。一次性声明大量的用于存储数据的变量。要存储的数据通常是同类型的数据，例如：考试成绩。

定义格式

格式一：数据类型[] 变量名范例：int[] arr
定义了一个int类型的数组，数组名是arr
格式二：数据类型变量名[] 范例：int arr[]
定义了一个int类型的变量，变量名是arr数组

数组初始化概述：Java中的数组必须先初始化，然后才能使用。初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

数组初始化方式：有动态初始化和静态初始化。

动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 变量名 = new 数据类型[数组长度];
范例：int[] arr = new int[3];

静态初始化

静态初始化：初始化时由程序员自己为数组对象的每个元素赋值，由系统自动计算出数组的长度。

格式：数据类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3...};
范例：String[] s = new String[]{"Hello","World","Java"};
简化格式：数据类型[] 变量名 = {数据1，数据2，数据3...};
范例：String[] s = {"Hello","World","Java"};

1.2 数组元素访问

数组变量访问方式(格式)：数组名

数组内部保存的数据的访问方式(格式)：数组名[索引]

索引：索引是数组中数据的编号方式。索引用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名。

索引从0开始
索引是连续的
索引逐一增加，每次加1

1.3 内存分配

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

Java中内存分配

栈内存：存储局部变量，即定义在方法中的变量，例如：arr。使用完毕，立即消失。
堆内存：存储new出来的内容(实体，对象)。每一个new出来的东西都有一个地址值，使用完毕，会在垃圾回收器空闲时被回收。

数组在初始化时，会为存储空间添加默认值

整数：默认值0
浮点数：默认值0.0
布尔值：默认值false
字符：默认值是空字符
引用数据类型：默认值是null

1.4 数组操作的两个常见小问题

索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题。

空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常。

null：空值，引用数据类型的默认值，表示不指向任何有效对象。

1.5 数组常见操作

遍历

获取数组元素数量(格式)：数组名.length。

范例：arr.length

数组遍历的通用格式

int[] arr = {...};

for(int i=0;i<arr.length;i++){
    System.out.println(arr[i]);
}

获取最值

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = {12,45,98,73,60};

        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        System.out.println("max:" + max);
    }
}

2. 方法

2.1 方法的基本概念

方法：方法(method)是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。

方法必须先创建才可以使用，该过程称为方法定义
方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用。

方法的定义

//方法定义格式
public static void 方法名(){
    //方法体
}

方法调用

//调用格式
方法名();

注意：方法必须先定义后调用，否则程序将报错。

练习：设计一个方法用于打印两个数中的较大数。

public class MethodDemo {
    public static void main(String[] args) {
        getMax(10,20);
    }

    public static void getMax(int a,int b){
        int max = a > b ? a : b;
        System.out.println("max:" + max);
    }
}

带参数方法的定义

//基本格式
public static void 方法名(参数){......}

//单个参数
public static void 方法名(数据类型 变量名){......}

//多个参数
public static void 方法名(数据类型 变量名1, 数据类型 变量名2, ...){......}

注意：

方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
方法定义时，多个参数之间使用逗号(,)分隔

带参数方法的调用

//基本格式
方法名(参数);

//单个参数
方法名(变量名/常量值);

//多个参数
方法名(变量名1/常量值1, 变量名2/常量值2, ...);

注意：方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错。

形参和实参

形参：方法定义中的参数，等同于变量定义。

实参：方法调用中的参数，等同于使用变量或常量。

带返回值方法定义

//格式
public static 数据类型 方法名(参数){
    return 数据;
}

//范例
public static boolean isEvenNumber(int number){
    return true;
}

带返回值方法调用

//格式1
方法名(参数);

//格式2
数据类型 变量名 = 方法名(参数);

注意：方法的返回值通常会使用变量接收，否则该返回值将无意义。

练习：设计一个方法可以获取两个数的较大值，数据来源于参数。

public class MethodDemo {
    public static void main(String[] args) {
        int max = getMax(10,20);
        System.out.println("max:" + max);
        System.out.println(getMax(10,20));
    }

    public static int getMax(int a,int b){
        int max = a > b ? a : b;
        return max;
    }
}

方法注意事项

方法不能嵌套定义
void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

方法的通用格式

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

public static：修饰符，目前记住这个格式
返回值类型：方法操作完毕之后返回的数据的数据类型

如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
方法名：调用方法时使用的标识
参数：由数据类型和变量名组成，多个参数之间用逗号隔开
方法体：完成功能的代码块
return：如果方法操作完毕，有数据返回，用于把数据返回给调用者

定义方法时，要做到两个明确

明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
明确参数：主要是明确参数的类型和数量

调用方法时

void类型的方法，直接调用即可
非void类型的方法，推荐用变量接收调用

2.2 方法的重载

方法重载概述

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载。

多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同

方法重载特点

重载仅对应方法的定义，与方法的定义无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说，不能通过返回值来判定两个方法是否构成重载

练习：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型(byte,short,int,long)。

public class MethodDemo {
    public static void main(String[] args) {
        System.out.println(compare(10,20));
        System.out.println(compare((byte)10,(byte)20));
        System.out.println(compare((short)10,(short)20));
        System.out.println(compare(10L,20L));
    }

    public static boolean compare(int a, int b){
        System.out.println("int");
        return a == b;
    }

    public static boolean compare(long a, long b){
        System.out.println("long");
        return a == b;
    }

    public static boolean compare(byte a, byte b){
        System.out.println("byte");
        return a == b;
    }

    public static boolean compare(short a, short b){
        System.out.println("short");
        return a == b;
    }
}

2.3 方法的参数传递

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值。

public class MethodDemo {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);
        change(number);
        System.out.println("调用change方法后：" + number);
    }

    public static void change(int number){
        number = 200;
    }
}
-------------------------------------------------------------------------------------
//输出
调用change方法前：100
调用change方法后：100

方法参数传递(引用类型)

对于引用类型的参数，形式参数的改变，影响实际参数的值。

public class MethodDemo {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        System.out.println("调用change方法前：" + arr[1]);
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);
    }

    public static void change(int[] arr){
        arr[1] = 200;
    }
}
-------------------------------------------------------------------------------------
//输出
调用change方法前：20
调用change方法后：200

练习1：设计一个方法用于数组遍历，要求便利的结果是在一行上的。例如：[11,22,33,44,55]。

public class MethodDemo {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        printArray(arr);
    }

    public static void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1){
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        System.out.println("]");
    }
}

练习2：设计一个方法用于获取数组中元素的最大值，调用方法并输出结果。

public class MethodDemo {
    public static void main(String[] args) {
        int[] arr = {12,45,98,73,60};
        int number = getMax(arr);
        System.out.println("number:" + number);
    }

    public static int getMax(int[] arr){
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }
}

3. Debug

Debug：是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。

Debug操作流程

Debug调试，又被称为断点调试，断点其实就是一个标记，告诉我们从哪里开始查看。

如何加断点：选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。
如何运行加了断点的程序：在代码区域右键Debug执行。
看哪里：看Debug窗口，看Console窗口。
点哪里：点Step Into(F7)这个箭头，也可以直接按F7，执行完后点Stop结束。
如何删除断点：选择要删除的断点，单击鼠标左键即可。

注意事项：如果数据来自于键盘输入，一定要记住输入数据，不然就不能继续往下查看了。

练习：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。选手的最后得分为：去掉一个最高分和一个最低分后的4个评委的平均值(不考虑小数部分)。

import java.util.Scanner;

public class MethodDemo {
    public static void main(String[] args) {
        int[] arr = new int[6];
        Scanner sc = new Scanner(System.in);

        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个评委的打分：");
            arr[i] = sc.nextInt();
        }

        int max = getMax(arr);
        int min = getMin(arr);
        int sum = getSum(arr);
        int avg = (sum - max - min) / (arr.length - 2);
        System.out.println("选手的最终得分是：" + avg);
    }

    public static int getSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    public static void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ",");
            }
        }
        System.out.println("]");
    }
}

posted @ 2020-11-22 09:30 HeartQuake 阅读(225) 评论(0) 收藏举报

刷新页面返回顶部

HeartQuake