黑马程序员--java基础-方法重载与数组

——- android培训、java培训、期待与您交流！ ———-

为了解决，一次性能存入大量相同类型这种情况，Java给我们提供了一项新的技术叫做“数组”
数组：数的组合。可以看作存储大量数据的容器。
数组的定义：
    数据类型[] 数组名;  //这就定义了一个数组
        //数据类型 数组名[];  //不要用这种方法时去写。
    数组名 = new 数据类型[数组的大小];  //数组的初始化。

class ArrayDemo {
    public static void main(String[] args) {
        /*
            int a1 = 100;
            int a2 = 100;
            int a3 = 100;
            int a4 = 100;
            ……

            int a85 = 100;
        */

        //定义以一个int类型的数组
        //int scores[];  //不允许这么写
        int[] scores;   //这个东西只是告诉计算机，我需要一个int类型的数组叫做scores
        scores = new int[5];  //告诉计算机，这个scores数组的大小为5

        //拿到数组的大小。数组名.length  他是int类型的数据
        int a = scores.length;
        System.out.println(a);


    }
}

数组的使用：其实就是对数组中的变量的使用。
    存入：
    取出：
    修改：

class ArrayDemo1 {
    public static void main(String[] args) {
        //定义一个数组
        int[] scores;  //定义一个int类型的数组，名字叫scores
        scores = new int[5];  //这个数组的大小为5

        //数组的使用
        /*
            变量的使用：int a;
                存入（赋值）：a = 12；
                取出（直接拿着变量当作值来使用）
                    int b = a;
                    System.out.println(a);
                修改（就是直接赋值，这样就把值覆盖了）：a = 15;


            难点：
                要把“scores[0]”整体看作是一个变量的名字，就相当于a
        */

        //存入（赋值）
            scores[0] = 12;
        //取出（直接拿着变量当作值来使用）
            int b = scores[0];
            System.out.println(scores[0]);
            System.out.println("b="+b);
        //修改（就是直接赋值，这样就把值覆盖了）：
            scores[0] = 15;
            System.out.println(scores[0]);
    }
}

class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arrs;  //定义一个int类型的数组，名字叫做arrs
        arrs = new int[5]; //告诉计算机，我们数组的大小为5
        arrs[0] = 15;
        System.out.println(arrs);
        /*
            [I@4e4d1abd
                [: 代表数组
                I: 代表int类型
                @：在……地方
                4e4d1abd：内存地址。
            出现这句话，意味着 数组是“引用数据类型”


        */
    }
}

数组定义的格式：
    1.数组的动态初始化
      数据类型[] 数组名;    //数组的声明
      数组名 = new 数据类型[大小];  //数组的初始化
        简化版本：
            数据类型[] 数组名 =  new 数据类型[大小];  

    2.数组的静态初始化
        数据类型[] 数组名;
        数组名 = new 数据类型[]{1,5,3,8};
            简化版本：
                数据类型[] 数组名 = new 数据类型[]{1,5,3,8};
            终极简化版本：
                数据类型[] 数组名 = {1,5,3,8};


    数组定义常见问题：
        1.不能同时使用静态初始化和动态初始化。
        2.数组中存储的数据必须和数组的类型保持一致。

class ArrayDemo6 {
    public static void main(String[] args) {
        int[] arr = new int[5];
        /*
        int a = 5;

        */


        /*
            数据类型[] 数组名;
            数组名 = new 数据类型[]{1,5,3,8};
                简化版本：
                    数据类型[] 数组名 = new 数据类型[]{1,5,3,8};
                终极简化版本：
                    数据类型[] 数组名 = {1,5,3,8};

            int[] brr;
            brr = new int[]{7,8,9};

            int[] brr = new int[]{7,8,9};
        */
            int[] brr = {7,8,9};
            System.out.println(brr.length);


            int[] arr2 = new int[]{1,5,8};


    }
}

数组的常见问题：
    1.ArrayIndexOutOfBoundsException:数组索引越界异常
        指的是，我们使用的数组的索引，超出了数组索引的范围。
    2.可能尚未初始化变量
        数组在使用之前必须初始化。
    3.NullPointerException:空指针异常。
        数组已经变成空的了，但是我们还要想人家要东西，所以就产生了空指针异常。

class ArrayDemo8 {
    public static void main(String[] args) {
        //int[] arr = new int[3];
        //int[] arr;
        int[] arr = new int[3];
        arr = null;
        System.out.println(arr[0]);
    }
}

遍历：就是循环一遍，一个一个的拿出来。
数组的遍历：把数组中的元素一个一个的拿出来。

class ArrayDemo9 {
    public static void main(String[] args) {
        int[] arr = {11,15,19,21,85,33};
        /*
        arr[0]
        arr[1]
        arr[2]
        ……
        arr[arr.length-1]

        System.out.println(arr[0]);
        */

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


        //求数组中的最大值
        int max = arr[0];
        /*
            max = max > arr[0] ? max : arr[0];
            max = max > arr[1] ? max : arr[1];
            ……
            max = max > arr[arr.length-1] ? max : arr[arr.length-1];
        */

        for (int a = 0; a < arr.length ; a++) {
            max = max > arr[a] ? max : arr[a];
        }
        System.out.println("数组的最大值为："+max);
    }
}

基本数据类型：在值的传递时，传递的“值”
引用数据类型：在值的传递时，传递的是“内存地址”

class ArrayTest1 {
    public static void main(String[] args) {
        /*
        int a=5;
        int b=a;
        b=10;
        System.out.println(a);
        */

        int[] arr = {1,2,3};
        int[] brr = arr;
        brr[2] = 5;
        System.out.println(arr[2]);

    }
}

二维数组：存储数组的数组。
    一维数组的格式；
        数据类型[] 数组名 = new 数据类型[大小];
        int[] arr = new int[5];

定义方法：
        数据类型[][] 数组名 = new 数据类型[m][n];
        m指的是这里边存储了m个数组。
        n指的是二维数组中存储的数组的大小。

        int[][] arrs = new int[2][3];
        2指的是arrs里边存储了2个数组。
        3指的是arrs中存储的这两个数组，每个数组的大小都为3

    二维数组定义方式2：
        数据类型[][] 数组名 = new 数据类型[m][];
        m指的是这里边存储了m个数组。

    二维数组定义方式3：
        数据类型[] 数组名 = {1,5,3,8,9};
            int[] arr = {1,5,3,8,9};

        int[][] arrs = {{1,2,3},{4,5},{3}};

class ArrayArrayDemo {
    public static void main(String[] args) {
        /*
        int[][] arrs = new int[2][3];
        System.out.println(arrs[0]);
        System.out.println(arrs[1]);
        System.out.println(arrs[0][0]);


        //二维数组定义方式2
        int[][] arrs = new int[2][];
        //System.out.println(arrs[0]);
        //System.out.println(arrs[1]);
        //System.out.println(arrs[0][0]);

        arrs[0] = new int[3];
        System.out.println(arrs[0]);
        System.out.println(arrs[0][0]);
        System.out.println(arrs[1]);
        //给arrs[1]赋值
        arrs[1] = new int[1];
        System.out.println(arrs[1][1]);
        */

        //

        int[][] arrs = {{1,2,3},{4,5},{3}};
        System.out.println(arrs[1][2]);
    }
}

二维数组遍历

class ArrayArrayTest {
    public static void main(String[] args) {
        int[][] arrs = {{1,2,3},{4,5},{3}};
        //二维数组遍历
        //外层循环，遍历二维数组中的数组
        for (int a = 0; a < arrs.length ;a++) {
            System.out.println(arrs[a]);
            //现在发现arrs[a]全都是数组
            //内层循环遍历，二维数组中数组的元素
            for (int b = 0; b< arrs[a].length ; b++) {
                System.out.println(arrs[a][b]);
            }
        }
    }
}

某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

class ArrayArrayTest1 {
    public static void main(String[] args) {
            //第一季度：22,66,44
            int[] arr1 = {22,66,44};
            //第二季度：77,33,88
            int[] arr2 = {77,33,88};
            //第三季度：25,45,65
            int[] arr3 = {25,45,65};
            //第四季度：11,66,99
            int[] arr4 = {11,66,99};

            //定义二维数组
            int[][] arrs = {arr1,arr2,arr3,arr4};
            //int[][] arrs = new int[4][];
            //arrs[0] = arr1;


            //求整个公司的盈利，就是求这个二维数组的和。
            int sum = 0;
            //先拿出二维数组中的数组
            for (int a = 0;a//arrs[a],就是每个数组
                //对这个数组进行遍历
                for (int b = 0;bsum = sum + arrs[a][b];
                }
            }
            System.out.println(sum);

    }
}

方法重载(overload)：
要求：
    1.方法名完全相同
    2.参数列表不同
    3.和返回值、访问修饰符、方法体都没有关系。
参数列表不同的表现：
    1.参数个数不同
    2.相应位置上参数类型不同。
    3.和参数名称没有任何关系。

数组定义与初始化:
数组的声明：
    数据类型[] 数组名; 
数组的初始化：
    数组名 = new 数据类型[大小];

数组定义方式：
    数组的动态初始化。
        数据类型[] 数组名 = new 数据类型[大小];
    数组的静态初始化：
        数据类型[] 数组名 = new 数据类型[]{值1，值2……};
        数据类型[] 数组名 = {值1，值2……};

数组赋值与使用：
索引：数组中每一个小块的编号。索引有时候也叫做角标、下标。Index
    数组最大的索引：数组的长度-1;  //数组的长度：数组名.length
    数组最小的索引：0

找到数组中的元素：数组名[索引]; 
    如果找到元素，则就可以把这个元素当作一个变量来处理。


Java的默认值：
整数类型默认值：0
浮点型默认值：0.0
char型默认值：ASCII编码为0的字符。‘\u0000’
boolean型默认值：false
引用数据类型：null
    String和数组都是引用数据类型。

参数传递(不同类型的赋值)
基本数据类型：传递和赋值都传递的是值。
引用数据类型：传递和赋值的都是内存地址。String除外。
二维数组(了解)：
定义格式1：
    数据类型[][] 数组名 = new 数据类型[m][n];
    m表示这个二维数组中存储了m个一维数组。
    n表示这二维数组中存储的一维数组的大小都为n
定义格式2：
    数据类型[][] 数组名 = new 数据类型[m][];
    m表示这个二维数组中存储了m个一维数组。
定义格式3：
    数据类型[][] 数组名 = {数组1,数组2……}


二维数组的遍历：
    使用循环嵌套遍历。
    外层循环遍历二维数组中的每个数组。
    内层循环遍历数组中的每个元素。

——- android培训、java培训、期待与您交流！ ———-