第14、15课Java数组与方法零基础编程实战课堂笔记

概要：
数组零基础实战
方法零基础实战
一. Java中一维数组
1. 数组：是一组相关数据的集合，数组中的数据类型一定是完全相同；
2. 数组的三种类型：一维数组,二维数组,多维数组；
3. 要使用数组，首先要声明数组，然后要分配具体的内存给数组；
代码实现：

int scores[] = null;  //声明scores为整型数组
scores = new int[10]; //为整型数据分配空间，其元素个数是

for(int x = 10;x < 10;x++){//打印出数组中每一个元素的值
    System.out.println(scores[x]);
}

打印结果如下：
0
0
0
0
0
0
0
0
0
0

1. 在内存的栈保存数据的名字，而在内存的堆中则保存数组的具体内容，数组的名字具体指向数组的内容，从而可以通过数组的名字加上数组内容索引的方式来访问数组中具体的内容; 在栈中保存的永远是数组的名称，必须通过new关键字在堆中为当前的数组开辟堆内存空间并赋(初始)值,此时栈中的数组的名称会指向堆中分配的数组空间的首地址；
2. 数组中有一些类同类型的元素，每个元素的访问可以通过数组的名称加上元素的索引位置来共同完成，数组的索引位置是从0开始的。例如访问数组中的第三个元素scores[2];
3. 数组长度的访问是通过数组的length方法，例如scores.length
4. int [] scores = {1,2,3,4,5};//使用静态初始化声明数组

二： java中的二维数组
1. 二维数组相当于一个表格，数组中的每一个元素又是一个数组。

int scores[][];
        scores = new int[5][2];
        for(int i = 0;i < scores.length;i++){
            for(int j = 0; j < scores[i].length; j++){
                System.out.println(scores[i][j] + "\t");
            }
            System.out.println();
        }

输出结果如下：
    0   0
    0   0
    0   0
    0   0
    0   0

2.   使用静态初始化的方式实例化二维数组可以让元素类型为数组的具体的每一个元素的内容的长度不同。

  int scores[][] = {{10,2},{31,1,4,56,3},{2,321}};
        for(int i = 0;i < scores.length;i++){
            for(int j = 0; j < scores[i].length; j++){
                System.out.print(scores[i][j] + "\t");
            }
            System.out.println();
        }

输出结果如下：
10  2   
31  1   4   56  3   
2   321 

三： java中的多维数组

int scores[][][] = {{{10,2}},{{31,1,4}},{{2,321}}};

 for(int i = 0;i < scores.length;i++){
 for(int j = 0; j < scores[i].length; j++){
 for(int k = 0; k < scores[i][j].length; k++){
System.out.print("scores["+ i + "][" + j + "][" + k + "] = " + scores[i][j][k] + "\t");
 }
 }
 System.out.println();
 }

输出结果如下：
scores[0][0][0] = 10 scores[0][0][1] = 2
scores[1][0][0] = 31 scores[1][0][1] = 1 scores[1][0][2] = 4
scores[2][0][0] = 2 scores[2][0][1] = 321

四：关于数组的范围
数组索引的范围是从0 ~数组的长度-1,在访问数组的时候必须在访问内，否则的话会出现如下错误：

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2
    at com.dt.java.ArrayOps.arrayMoreAdvanced(ArrayOps.java:19)
    at com.dt.java.ArrayOps.main(ArrayOps.java:8)

补充说明：其实excel就是一个二维数组的实现！

五， java中方法的定义和使用
1. 方法代表一段可以复用代码集合，接受输入参数，通过代码的计算，返回执行结果；

    public static int sum(int x, int y){
        int result = x + y;
        return result;
    }

输出结果如下：
    x + y = 8

1. 方法的重载：函数名称相同，但传递的函数的参数类型或者参数个数不同。

    public static int sum(int x, int y){
        int result = x + y;
        return result;
    }
    public static int sum(int x, int y,int z){
        int result = x + y + z;
        return result;
    }

输出结果如下：
x + y + z = 18

1. 方法重载只考虑在函数名称相同的情况下不同的输入参数类型和参数的个数不考虑函数返回值的类型(也就是如果函数名称及其参数类型和个数完全相同的话，则不能算作方法重载)例如下面就是错误的方法重载的方式：

        int result = x + y;
        return (float)result;
    }
    public static int sum(int x, int y){
        int result = x + y;
        return result;
    }

1. 可以使用“return”关键字来返回方法中执行的结果内容；
2. 方法的递归调用，即方法自己调用自己！

    public static int sum(int number){
        if(number == 1){
            return 1;
        }else{
            return number + sum(number -1);
        }
    }

1. 可变参数：方法接受个数不固定的参数，即按照需要传递参数个数：

    public static void sum(int... args){
        for(int x = 0; x < args.length; x++){
            System.out.println(args[x] + "\t");
        }
    }

补充：可以使用JDK1.5推出foreach增强循环语法来更加方便的访问数组的内容。

    public static void sum(int... args){
        for(int arg : args){
            System.out.println(args[arg] + "\t");
        }
    }

六： 把数组作为方法的参数传递给方法进行处理：

    int[] scores = {89,97,100,88,85};
        sort(scores);
        for(int score : scores){
            System.out.println(score + "\t");
        }
    }
    private static void sort(int[] scores) {
        for(int i = 0; i < scores.length; i++){
            for(int j = 0; j < scores.length; j++){
                if(scores[i] < scores[j]){
                    int x = scores[i];
                    scores[i] = scores[j];
                    scores[j] = x;
                }
            }
        }
    }

此时传递给方法的只是数组的引用，在方法内部改变数组引用所指向的具体的数组的内容实际上就改变了数组本身。

课程笔记来源：