Java学习笔记（二）--函数、函数重载、数组

Java学习笔记（二）–函数、函数重载、数组

1. 函数简述

将需要频繁调用的代码封装成一段独立的程序，可供其他函数调用执行，这种封装形式即可称作函数

public class FunctionDemo1{
    public static void main(String[] args){
        /**
        int a = 4+5;
        System.out.println("a="+a);
        int b = 3+9;
        System.out.println("b="+b);
      */
        add(4,5);//我不想每次都写那么多代码，我就将运算过程封装成一个add()函数来用
    }
    public static int add(int a, int b){
        return a+b; 
    }
}

2. 函数格式

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…)
    {
            执行语句;
            return 返回值;
    }

返回值类型： 运行这段程序得出的一个运算结果，结果类型，如果函数没有返回值则用void来表示该函数没有返回值。
函数名：仅仅是一个标识符，可以随意起名字。
形式参数：是一个变量，用于存储调用函数传递进来的实际参数。
实际参数：传递给形式参数的具体数值，调用函数时提供。
返回值：返回给调用者。

3. 函数的特点
- 定义函数可以将功能代码进行封装
- 便于对该功能进行复用
- 函数只有被调用才会被执行
- 函数的出现提高了代码的复用性
- 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
注意：
- 函数中只能调用函数，不可以在函数内部定义函数，为平级关系。
- 定义函数时，函数的结果应该返回给调用者，交由调用者处理。

4. 函数的重载

定义：在同一个类中，有一个以上的同名函数，只要函数的参数列表或参数类型不一样即可，与返回值无关， 这些统称为方法的重载。
增强方法的阅读性，优化了程序设计。

形式

public class HelloJJAVA {
    //main方法//简单理解，就不多做其他举例了
    public static void main(String[] str) {

    }
    //参数为int型
    private static int getNum(int a) {
        return a;
    }
    //参数为两个int型//当然可以是其他数据类型
    private static int getNum(int a, int b) {
        return a + b;
    }
    //参数为三个int型//当然可以是其他数据类型
    private static int getNum(int a, int b, int c) {
        return a + b + c;
    }
}

5. 数组

概念：同一种类型数据的集合。其实数组就是一个容器。

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[4];
格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

int[] arr = new int[]{1,2,3,4};

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

5.1 数组遍历

//数组的第一个常见操作.遍历 | 数组长度arr.length
public static void main(String[] args) {
        int[] arr = { 0, 1, 2 };
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            // System.out.println("arr["+i+"]="+arr[i]); 打印效果 arr[0]=1;
        } 
    }

5.2 数组常见异常

1）数组越界异常

//一数组角标越界异常:，注意：数组的角标从0开始。
public static void main(String[] args) {
        int[] arr = { 1, 2, 3 };//0 1 2
        System.out.println(arr[3]);//3越界
        //java.lang.ArrayIndexOutOfBoundsException
}

2）空指针异常

//二 空指针异常:
public static void main(String[] args) {
        int[] arr = { 1, 2, 3 };
        arr = null;
        System.out.println(arr[1]);
        // java.lang.NullPointerException
    }

5.3 数组常见操作

1）获取最大值

public static int getMax(int[] arr){
        //定义变量记录较大的值，初始化为数组中的任意一个元素。
        int max = arr[0];
        for(int x=1; x<arr.length; x++){
            if(arr[x]>max)
                max = arr[x];
        }
        return max;
    }

2）直接排序

/**
    选择排序。
    以一个角标的元素和其他元素进行比较。
    在内循环第一次结束，最值出现的头角标位置上。
    */

public static void selectSort(int[] arr){
        for(int x=0; x<arr.length-1; x++){
            for(int y=x+1; y<arr.length; y++){
                if(arr[x]>arr[y]){
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }

3）冒泡排序

/**
    冒泡排序。
    比较方式：相邻两个元素进行比较。如果满足条件就进行位置置换。
    原理：内循环结束一次，最值出现在尾角标位置。
    */
    public static void bubbleSort(int[] arr){
        for(int x=0; x<arr.length-1; x++){
            //-x:让每次参与比较的元减-1:避免角标越界。
            for(int y=0; y<arr.length-x-1; y++){
                if(arr[y]>arr[y+1]){
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
    }

4）二分法

/**
    为了提高查找效率，可使用折半查找的方式，注意：这种查找只对有序的数组有效。
    这种方式也成为二分查找法。
    */
    public static int halfSeach(int[] arr,int key){
        int min,mid,max;
        min = 0;
        max = arr.length-1;
        mid = (max+min)/2;
        while(arr[mid]!=key){
            if(key>arr[mid])
                min = mid + 1;
            else if(key<arr[mid])
                max = mid - 1;

            if(min>max)
                return -1;

            mid = (max+min)/2;
        }
        return mid;
    }

5）数组翻转

/**
    反转其实就是头角标和尾角标的元素进行位置的置换，
    然后在让头角标自增。尾角标自减。
    当头角标<尾角标时，可以进行置换的动作。
    */
    public static void reverseArray(int[] arr)
    {
        for(int start=0,end=arr.length-1; start<end; start++,end--)
        {
            swap(arr,start,end);
        }
    }
    //对数组的元素进行位置的置换。
    public static void swap(int[] arr,int a,int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

5.4 二维数组
遍历： toString() 将数组的元素以字符串的形式返回
排序： sort() 将数组按照升序排列
查找： binarySearch()在指定数组中查找指定元素，返回元素的索引，如果没有找到返回（-插入点-1） 注意：使用查找的功能的时候，数组一定要先排序。

二维数组：实质就是存储是一维数组。

数组定义：
数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];

数组的初始化：
静态初始化:
int [][] a = new int[][]{ {1,3,5,9},{4,6,8,10},{1,3,6,4} };
动态初始化：

int[][] a = new int[3][4];
    for(int i = 0; i < a.length; i ++){
        for(int j = 0; j < a[i].length; j ++){
            a[i][j] = ++ value;
        }
    }