java基礎------函數與數組

函數（方法）

　　　　　　定義：如果一個功能的代碼要被復用起來，那么這時候可以把這里的功能代碼封裝起來，在java中把功能代碼封裝起來的是以函數的形式體現的。

　　　　　　函數的格式：

　　　　　　　　　　修飾符　返回值類型　函數名（形式參數.....）{

　　　　　　　　　　　　　　需要被封裝的功能代碼；

　　　　　　　　　　　　　　return 結果；

　　　　　　　　　　　　　　　　}

　　　　　　例如：

　　　　　　　　　　public static int add（）{

　　　　　　　　　　　　　　int a=2；

　　　　　　　　　　　　　　int b=3；

　　　　　　　　　　　　　　return a+b；

　　　　　　　　　　　　　　}

　　　　　　分析函數：

　　　　　　　　　　修飾符：public static

　　　　　　　　　　返回值類型：int  返回值類型就是指函數運行完畢后，返回結果的數據類型。

　　　　　　　　　　　　　　　　注意： 某些函數是沒有結果返回給調用者的,那么這時候返回值類型是void。

　　　　　　　　　　函數名：add

　　　　　　　　　　　　　　函數名的作用：如果需要調用該函數就需要使用的函數名。 函數名只要符合標識符的命名規則即可。 

　　　　　　　　　　　　　　函數名的命名規范： 首單詞全部小寫，其他單詞的首字母大寫，其他小寫。

　　　　　　　　　　形式參數： 如果一個函數在運行的時候，存在的數據是要調用者確定的，那么這時候就應該定義形式參數。

　　　　　　　　　　return：把一個結果返回給調用者。

　　　　　　函數的作用：提高功能代碼的復用性

　　　　　　函數的特點：

　　　　　　　　　　1. 函數的作用就是把一個功能代碼給封裝起來，已達到提高功能代碼的復用性。

　　　　　　　　　　2.函數定義好之后是需要被調用才會執行的。其中main函數是由jvm調用的，不需要我們手動調用。

　　　　　　　　　　3.如果一個函數沒有返回值返回給調用者，那么返回值類型必須是使用void表示。　

　　　　　　如何定義一個函數：
　　　　　　　　　　1. 返回值類型。
　　　　　　　　　　2. 是否存在未知的參數(是否存在要由調用者確定的參數)。---->形式參數

class Demo1
{
    public static void main(String[] args) 
    {
        //int max = getMax(14,5); //調用了需求1的函數，括號內填寫的是實際參數，實際參數由調用者確定
        //System.out.println("最大值："+ max);//輸出需求1的結果 結果為14

        getMax(3,7);//調用了需求2的函數
    }    

/*
    //需求1： 定義一個函數比較兩個int類型的數據大小，把最大值返回給調用者。
    public static int  getMax(int a, int b){  // 形式參數
        int max = 0; //定義一個變量用於保存最大值的
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        return max;//把結果返回給調用者
    }
*/

    //需求2：定義一個函數比較兩個int類型的數據大小，不需要把最大值返回給調用者,直接打印即可。
    public static void getMax(int a, int b){
        int max = 0; //定義一個變量用於保存最大值的
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        System.out.println("最大值："+ max);
    }

}

class Demo2 
{
    public static void main(String[] args) {
        //String result = getGrade(91);//調用了需求1的函數，並把結果賦值給result
        //System.out.println(result);//輸出的結果為：A等級

        print(7);//調用了需求2的函數
    }

//需求1： 定義一個函數判斷一個分數的等級，把分數的等級返回給調用者。
    public static String getGrade(int score){
        String grade = "";    //定義一個變量存儲等級
        if(score>=90&&score<=100){
            grade = "A等級";
        }else if(score>=80&&score<=89){
            grade = "B等級";
        }else if(score>=70&&score<=79){
            grade = "C等級";
        }else if(score>=60&&score<=69){
            grade = "D等級";
        }else if(score>=0&&score<=59){
            grade = "E等級";
        }else{
            grade = "補考等級";
        }
        return grade;//把等級返回給調用者
    }

    //需求2： 定義一個函數打印一個乘法表，不需要返回任何數據。 
    public static void  print(int row){
        for(int i = 1 ; i<= row ; i++){
            for (int j = 1 ;j<=i  ;j++ ){
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            //換行
            System.out.println();
        }
    }

}

　　　　　　注意： 如果一個函數的返回值類型是具體的數據類型，那么該函數必須要保證在任意情況下都保證有返回值。（除了返回值類型是void以外）

class Demo3{
    public static void main(String[] args) 
    {
        String result = getGrade(10);//調用函數
        System.out.println("對應的等級是："+ result );
    }
    public static String getGrade(int score){//未知的參數定義在形參中，由函數的調用者確定。
        if(score>=90&&score<=100){
            return "A等級";
        }else if(score>=80&&score<=89){
            return "B等級";
        }else if(score>=70&&score<=79){
            return "C等級";
        }else if(score>=60&&score<=69){
            return "D等級";
        }else if(score>=0&&score<=59){
            return "E等級";
        }else{
            //如果一個函數的返回值類型是具體的數據類型，那么該函數就必須要保證在任意情況下都保證有返回值。（除了返回值類型是void以外）
            return "補考等級";
        }
    }
}

　　　　　　return 關鍵字的作用：

　　　　　　　　　　1. 返回數據給函數的調用者。

　　　　　　　　　　2. 函數一旦執行到了return關鍵字，那么該函數馬上結束。 (能結束一個函數)

　　　　　　注意：如果一個函數的返回值類型是void，那么也可以出現return關鍵字，但是return關鍵字的后面不能有數據。

　　　　　　break關鍵字與return關鍵字的區別：

　　　　　　　　　　1.break關鍵字是結束一個循環。

　　　　　　　　　　2. return關鍵字是結束一個函數。

　　　　　　函數的重載：在一個類中出現兩個或者兩個以上的同名函數，這個稱作為函數的重載。

　　　　　　函數重載的要求：

　　　　　　　　　　1. 函數名一致。

　　　　　　　　　　2. 形參列表不一致。（形式參數的個數或者是對應的數據類型不一致）

　　　　　　　　　　3. 與函數的返回值類型是無關的。

　　　　　　函數重載的作用： 同一個函數名可以出現不同的函數，以應對不同個數或者不同數據類型的參數。

class Demo4 {
    public static void main(String[] args) {
        add1(1,2);//調用了含有兩個參數的函數
        add(1,2.0);//調用了含有三個參數的函數
    }

        // 一下兩個函數都是以函數重載在做加法運算。
    public static double add(int a, int b){
        System.out.println("兩個參數的總和: "+ (a+b));
        return 3.14;
    }

    public static void add(int a , int b , int c){
        System.out.println("三個參數的總和: "+ (a+b+c));
    }

}

數組

　　　　　　定義：數組是存儲同一種數據類型數據的集合容器。

　　　　　　數組的定義格式：

　　　　　　　　　　數據類型[]  變量名 = new 數據類型[長度];

　　　　　　分析數組:

　　　　　　　　　　左邊： int[] arr    聲明了一個int類型的的數組變量，變量名為arr。

　　　　　　　　　　　　　　int : 表示該數組容器只能存儲int類型的數據。

　　　　　　　　　　　　　　[] ： 這是一個數組類型。

　　　　　　　　　　　　　　arr ： 變量名。

　　　　　　　　　　右邊：new int[50]　創建了一個長度為50的int類型數組對象。

　　　　　　　　　　　　　　new ： 創建數組對象的關鍵字。

　　　　　　　　　　　　　　int：表示該數組對象只能存儲int類型數據。

　　　　　　　　　　　　　　[]： 表示是數組類型。

　　　　　　　　　　　　　　50 : 該數組最多能存儲50個數據。數組的容量。

　　　　　　數組的好處： 對分配到數組對象中的每一個數據都能夠分配到一個索引值（編號、角標、下標）,索引值的范圍是從0開始，最大是： 長度-1。

　　　　　　局部變量： 如果一個變量是在一個函數（方法）的內部聲明的，那么該變量就是一個局部變量。

　　　　　　成員變量： 成員變量就是定義在方法之外，類之內的.

class Demo5 {
    public static void main(String[] args) 
    {
        //定義一個數組
        int[] arr = new int[4];
        arr[0] = 10;
        arr[1] = 30;
        arr[2] = 50;
        arr[3] = 90; 
        
        //System.out.println("數組的容量："+ arr.length);    //數組里有一個length 的屬性，可以查看數組的容量。
        //System.out.println("arr[2] = "+ arr[2]);//查看索引值為2的數組的值    結果為：50
        
        //查看數組中的所有數據。
        for(int index = 0 ; index<arr.length ; index++){
            System.out.println(arr[index]);
        }
    }
}

　　　　　　數組的內存分析圖：

　　　　　　數組中常見的問題：

　　　　　　　　　　1. NullPointerException 空指針異常

　　　　　　　　　　原因： 引用類型變量沒有指向任何對象，而訪問了對象的屬性或者是調用了對象的方法。

　　　　　　　　　　2. ArrayIndexOutOfBoundsException 索引值越界。

　　　　　　　　　　原因：訪問了不存在的索引值。

　　　　　　數組的初始方式：

　　　　　　　　　　動態初始化：數據類型[] 變量名 = new 數據類型[長度]；

　　　　　　　　　　靜態初始化：數據類型[] 變量名 = {元素1，元素2.....}；

　　　　　　如果程序一開始你就已經確定了數據，那么這時候建議使用靜態初始化。如果一開始數據還不太明確，這時候就建議使用動態初始化。

class Demo6{
    public static void main(String[] args) 
    {    
            /*
        //動態初始化
        int[] arr = new int[10];
        Scanner scanner = new Scanner(System.in);//創建掃描器對象
        for(int i  = 0 ; i< arr.length ; i++){
            arr[i] = scanner.nextInt();//調用掃描器的nextInt()掃描數據，並把數據賦值於數組中
        }
        */

        //靜態初始化
        int[] arr = {10,20,30,40,50};
                //查看數組的所有數據
        for(int index = 0 ; index<arr.length ; index++){
             System.out.print(arr[index]+",");
        }


    
    }
}

/*
    需求： 定義一個函數接收一個int類型的數組對象，找出數組對象中的最大元素並返回給調用者。
*/
class Demo7 {
    public static void main(String[] args) 
    {
        int[] arr = {-12,-14,-5,-26,-4};//靜態初始化
        int max = getMax(arr);
        System.out.println("最大值："+ max); //結果為：-4
    }

    public static int  getMax(int[] arr){
        int max = arr[0]; //用於記錄最大值
        for(int i = 1 ; i < arr.length ; i++){
            if(arr[i]>max){  //如果發現有元素比max大，那么max變量就記錄該元素。
                max = arr[i];
            }
        }
        return max;//把max的值返回給調用者
    }
}

　　　　　　數組常見的操作：

　　　　　　　　　　選擇排序(直接排序)：使用一個元素與其他的元素挨個比較一次，符合條件交換位置。

　　　　　　　　　　需求： 定義一個函數接收一個int類型的數組對象, 把數組中的最大值放在數組中的第一位。

class Demo8{
    public static void main(String[] args) 
    {
        int[] arr = {12,5,17,8,9};  //對於有5個元素的數組，只需要找出4個最大值就可以排序了。
        selectSort(arr);
    }

    public static void selectSort(int[] arr){
        
        //對以下注釋的代碼進行優化
        for(int j = 0; j<arr.length-1; j++){  //  控制的是輪數。
            for(int i = j+1 ; i<arr.length ; i++){ //控制的是每次找出的最大值
                if(arr[i]>arr[j]){
                    //交換位置
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        

/*
                //把老大放在第一個位置
                for(int i=1;i<arr.length;i++）{
                       if(arr[i]>arr[0]){
                int temp = arr[i];
                arr[i] = arr[0];
                arr[0] = temp;
            }
                 }
                
        //把老二放在第二個位置
        for(int i = 2  ; i< arr.length ; i++){
            if(arr[i]>arr[1]){
                int temp = arr[i];
                arr[i] = arr[1];
                arr[1] = temp;
            }
        }
        

        //把老三放在第三個位置
        for(int i = 3  ; i< arr.length ; i++){
            if(arr[i]>arr[2]){
                int temp = arr[i];
                arr[i] = arr[2];
                arr[2] = temp;
            }
        }

        //把老四放在第四個位置
        for(int i = 4  ; i< arr.length ; i++){
            if(arr[i]>arr[3]){
                int temp = arr[i];
                arr[i] = arr[3];
                arr[3] = temp;
            }
        }

*/

        //遍歷數組，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }
    }
}
        

　　　　　　　　　　冒泡排序：冒泡排序的思想就是使用相鄰的兩個元素挨個比較一次，符合條件交換位置。

　　　　　　　　　　需求： 定義一個函數接收一個int類型的數組對象, 把數組中的最大值放在數組中的最后一位。

class Demo9 {
    public static void main(String[] args) 
    {
        int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量：5 
         bubbleSort(arr);
    }


    public static void bubbleSort(int[] arr){
        //對以下注釋的代碼進行優化
        for(int j = 0 ; j<arr.length-1 ; j++){ //控制輪數
            for(int i = 0 ; i<arr.length-1-j  ; i++){  //控制找出一個最大值  
                //相鄰的元素比較
                if(arr[i]>arr[i+1]){
                    int temp  = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }

/*
                // 把最大值放在最后一個位置
            for(int i = 0 ;  i <arr.length-1-0 ; i++){
                if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

        //把老二放在倒數第二個位置上。
        for(int i = 0 ;  i <arr.length-1-1 ; i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

        //把老三放在倒數第三個位置上。
        for(int i = 0 ;  i <arr.length-1-2 ; i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

        //把老四放在倒數第四個位置上。
        for(int i = 0 ;  i <arr.length-1-3 ; i++){
            if(arr[i]>arr[i+1]){
                int temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }    
        }

*/

        //遍歷數組，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length; i++){
            System.out.print(arr[i]+",");
        }
    }
}

　　　　　　　　　　二分查找法：定義三個變量分別記錄要查找元素的范圍最大索引值、中間索引值、最小索引值，每次都是使用中間索引值的元素與目標元素比較一次，如果不是我們所需要的元素，那么縮小查找的范圍。

　　　　　　　　　　注意：使用二分查找法的前提必須是有序的數組。

　　　　　　　　　　需求：定義一個函數接收一個數組對象和一個要查找的目標元素，函數要返回該目標元素在數組中的索引值，如果目標元素不存在數組中，那么返回-1表示。

class Demo10 {
    public static void main(String[] args) 
    {
        int[] arr = {12,16,19,23,54};
        //int index = searchEle(arr,23);//調用searchEle（），但是效率低
        int index = halfSearch(arr,116);
        System.out.println("元素所在的索引值是："+ index);
    }
    
        
    public static int halfSearch(int[] arr, int target){
        //定義三個變量分別記錄最大、最小、中間的查找范圍索引值
        int max = arr.length-1;
        int min = 0;
        int mid = (max+min)/2;
        while(true){
            if(target>arr[mid]){
                min = mid+1;
            }else if(target<arr[mid]){
                max = mid -1;
            }else{
                //找到了元素
                return mid;
            }

            //沒有找到的情況
            if (max<min){
                return -1;
            }

            //重新計算中間索引值
            mid = (min+max)/2;
        }
    
    }
/*
    public static int searchEle(int[] arr, int target){
        for(int i = 0 ; i<arr.length ; i++){
            if(arr[i]==target){
                return i;
            }
        }
        return -1;
    }
*/
}

/*
需求： 定義 一個函數接收一個char類型的數組對象,然后翻轉數組中的元素。    
例如：char[] arr = {'a','b','c','d','e'};翻轉元素后的結果為e、d、c、b、a
*/
class Demo11{
    public static void main(String[] args){
        char[] arr = {'a','b','c','d','e'};
        reverse(arr);
    }

    public static void reverse(char[] arr){
        for(int startIndex = 0 ,endIndex = arr.length-1 ;   startIndex<endIndex ; startIndex++,endIndex--){
            char temp = arr[startIndex];
            arr[startIndex] = arr[endIndex];
            arr[endIndex] = temp;
        }

        //遍歷數組，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }

    }
}

 　　　　　　二維數組：二維數組就是數組中的數組。

　　　　　　二維數組的定義格式：數據類型[][] 變量名 = new 數據類型[長度1][長度2]；

　　　　　　二維數組的初始化方式：

　　　　　　　　　　動態初始化：數據類型[][] 變量名 = new 數據類型[長度1][長度2]；

　　　　　　　　　　靜態初始化：數據類型[][]  變量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}；

　　　　　　二維數組的內存分析圖：

　　　　　　數組的特點：

　　　　　　　　　　1. 數組只能存儲同一種數據類型的數據。

　　　　　　　　　　2. 數組是會給存儲到數組中的元素分配一個索引值的，索引值從0開始，最大的索引值是length-1；

　　　　　　　　　　3. 數組一旦初始化，長度固定。

　　　　　　　　　　4. 數組中的元素與元素之間的內存地址是連續的。

class Demo12{
    public static void main(String[] args) 
    {    
        //定義了一個二維數組
        int[][] arr = new int[3][4];
        arr[1][1] = 100;
        /*
        System.out.println("二維數組的長度："+ arr.length);  //長度為3
        System.out.println("二維數組的長度："+ arr[1].length); //長度為4
        */
        System.out.println("數組的元素："+ arr[1][1]);結果為100
        
    }
}