黑马程序员--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.length;a++) {                //arrs[a],就是每个数组                //对这个数组进行遍历                for (int b = 0;b<arrs[a].length;b++) {                    sum = 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.0char型默认值：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培训、期待与您交流！ ———-