农学转IT-Java学习第八天、第九天：方法重载、数组

一、方法重载

1、方法重载的基本使用

package cn.itcast.day4.demo04;

/*
对于功能类似的方法来说，因为参数列表不一样，却需要记住那多不同的方法名称，太麻烦。

方法的重载（Overload）:多个方法的名称一样，但是参数列表不一样。
好处，只要记住唯一一个方法名称，就可以实现类似的多个功能。
*/
public class Demo01Overload {
    public static void main(String[] args) {
        System.out.println(sum(10, 20));//两个参数的方法
        System.out.println(sum(10, 20 ,30 ));//三个参数的方法
        System.out.println(sum(10, 20, 30, 40));//四个参数的方法
//        System.out.println(sum(10,20,30,40,50));//住不到任何方法来匹配，所以报错
//
    }

    public static int sum(int a, int b) {
        System.out.println("有2个参数的方法执行");
        return a +b;
    }

    public static int sum(int a, int b, int c) {
        System.out.println("有3个参数的方法执行");
        return a +b + c;
    }

    public static int sum(int a, int b, int c, int d) {
        System.out.println("有4个参数的方法执行");
        return a +b +c +d;
    }
}

2、方法重载的注意事项

3、重载练习1-四种不同参数类型比较

package cn.itcast.day4.demo04;

public class Demo02MethodOverloadSome {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        System.out.println(isSame(a, b));

        System.out.println(isSame((short)20, (short) 20));

        System.out.println(isSame(11, 12));

        System.out.println(isSame(10L, 10L));
    }

    public static boolean isSame(byte a, byte b) {
        System.out.println("两个byte参数的方法执行！");
        boolean same;
        if (a == b) {
            same = true;
        } else {
            same = false;
        }
        return same;
    }

    public static boolean isSame(short a, short b) {
        System.out.println("两个short参数的方法执行！");
        boolean same = a == b ? true : false;
        return same;
    }

    public static boolean isSame(int a, int b) {
        System.out.println("两个int参数的方法执行！");
        return a ==b;
    }

    public static boolean isSame(long a, long b) {
        System.out.println("两个long参数的方法执行！");
        if(a == b) {
            return true;
        } else {
            return false;
        }
    }
}

4、重载练习2-判断哪些方法是重载关系

5、重载练习3-实现重载的println

二、数组

1、数组的概念

概念：是一种容器，可以同时存放多个数据。

数组的特点：
1、数组是一种引用类型数据
2、数组当中的多个数据，类型必须统一
3、数组的长度在程序运行期间不可改变

2、数组的定义格式（动态初始化、静态初始化）

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
两种常见的初始化方式：
1、动态初始化：（指定长度）
2、静态初始化：（指定内容）

动态初始化数组的格式：
数据类型 [ ] 数组名称 = new 数据类型 [数组长度];

解析含义：
左侧数据类型：也就是数组当中保存的数据；全都是统一的什么类型
左侧的中括号：代表我是一个组
左侧的数组名称：给数据取一个名字
右侧的new：代表创建数组的动作
右侧的数据类型：必须和左边的数据类型保持一致
右侧的中括号的长度：也就是数组当中到底可以保存多少个数据，是一个int数字

3、省略的静态初始化数组格式

使用建议：
如果不确定数组当中的具体内容，用动态初始化，否则，已经确定了具体内容，用静态初始化。

4、访问数组元素进行获取

package huaiwen.com.day8.demo01;

/*
直接打印数组名称，得到的是数组对应：内存地址哈希值。
二进制：01
十进制：0123456789
十六进制：0123456789abcdef

访问数组内容的格式：数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素编号
【注意】索引值从0开始，一直到“数组的长度-1”为止。
*/
public class Demo02ArrayUse {
    public static void main(String[] args) {
        //静态初始化的省略格式
        int[] array = {10, 20, 30};

        System.out.println(array);//[I@50cbc42f

        //直接打印数组当中的元素
        System.out.println(array[0]);//10
        System.out.println(array[1]);//20
        System.out.println(array[2]);//30
        System.out.println("===========");

        //也可以将数组当中的某一个单个元素，赋值交给变量
        int num = array[1];
        System.out.println(num);//20
    }
}

5、访问数组元素进行赋值

package huaiwen.com.day8.demo01;

public class Demo03ArrayUse {
    public static void main(String[] args) {
        //动态初始化一个数组
        int[] array = new int[3];

        System.out.println(array);//内存地址值
        System.out.println(array[0]);//0
        System.out.println(array[1]);//0
        System.out.println(array[2]);//0
        System.out.println("=========");

        //将数据123赋值交给数组array当中的1号元素
        array[1] = 123;
        System.out.println(array[0]);//0
        System.out.println(array[1]);//123
        System.out.println(array[2]);//0
    }
}

6、Java中的内存划分

7、一个数组的内存图

8、两个数组的内存图

9、两个引用指向同一数组的内存图

10、常见问题

10.1、数组索引越界异常

package huaiwen.com.day8.demo03;

public class Demo01ArrayNull {
    public static void main(String[] args) {
        int[] array = {15, 25, 35};

        System.out.println(array[0]);//15
        System.out.println(array[1]);//25
        System.out.println(array[2]);//35

        //错误写法
        //并不存在3号元素，所以发生异常
        System.out.println(array[3]);

    }

}

10.2、空指针异常

11、获取数组的长度

12、数组的遍历输出

package huaiwen.com.day8.demo03;

/*
遍历数组，说的就是对数组当中的每一个元素进行逐一、挨个处理。默认的处理方式即使打印输出。
*/
public class Demo04array {
    public static void main(String[] args) {
        int[] array = {15, 25, 35, 45, 55, 65};

        //首先使用原始方式
        System.out.println(array[0]);//15
        System.out.println(array[1]);//25
        System.out.println(array[2]);//35
        System.out.println(array[3]);//45
        System.out.println(array[4]);//55
        System.out.println("==========");

        //使用循环，次数就是数组的长度
        for (int i = 0; i < 5; i++) {
            System.out.println(array[i]);
        }
        System.out.println("========");

//        int len = array.length;//长度
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

13、求出数组中的最大值

package huaiwen.com.day8.demo03;

public class Demo05Max {
    public static void main(String[] args) {
        int[] array = {5, 15, 30, 20, 10000};

        int max = array[0];//比武擂台
        for (int i = 1; i < array.length; i++) {
            //如果当前元素比max大，则换人
            if(array[i] > max) {
                max = array[i];
            }
        }
        //谁最后最厉害，就在max当中留下谁的战斗力
        System.out.println("最大值：" + max);
        System.out.println("==========");

        int min = array[0];//比武擂台
        for (int i = 1; i < array.length; i++) {
            //如果当前元素比min小，则换人
            if(array[i] < min) {
                min = array[i];
            }
        }
        //谁最后最弱，就在min当中留下谁的战斗力
        System.out.println("最小值：" + min);
    }
}

14、数组元素反转

package huaiwen.com.day8.demo03;

public class Demo03Revers {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};

        //遍历打印数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("==========");

        /*初始化语句：int min =0, max = array.length - 1
        * 条件判断： min < max
        * 步进表达式：min++， max--
        * 循环体：用第三个变量倒手*/

        for(int min = 0,max = array.length-1; min < max; min++, max--) {
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        //再次打印遍历输出数组后的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

15、数组作为方法参数

16、数组作为方法的返回值