java 數組的反轉、二維數組、方法

數組的反轉：
        數組的反轉：數組中的元素顛倒順序，例如：原始數組：1，2，3，4，5數組反轉之后為5，4，3，2，1
        /*
            思路：本質是考察交換兩個變量的值，兩種方式
            實現反轉,就需要將數組最遠端元素和最近端元素互換
            定義兩個變量，保存數組的最小索引和數組的最大索引
            
            讓兩個索引上的元素值交換位置
            最小的索引++，最大的索引-- ，再次交換位置
            
            最小索引超過了最大索引數組反轉結束
                
        */
        第一種：
            定義一個需要反轉的數組 int[] arr = {1,2,3,4,5,6}
            定義兩個索引變量,一個索引變量只想最小索引，一個索引變量指向最大索引
            int min = 0
            int max = arr.length-1
            int temp = 0
            
            遍歷數組，讓兩個索引變量產生變化
            min++;
            max--;
            條件min < max
            交換最小索引元素和最大索引元素，需要定義第三方變量
            
            temp = arr[min]//把最小的索引元素賦值給第三方變量temp
            arr[min] = arr[max];//把最大的索引元素賦值給最小的索引元素
            arr[max] = temp//把第三方變量的值賦值給最大索引的元素
            
            
            public static void main(String[] args){
                int[] arr = {1,2,3,4,5}
                
                
                //遍歷數組 for
                for (int min = 0,int  max = arr.length-1;min < max;min++,max--){
                    int temp = 0;
                    temp = arr[min];
                    arr[min] = arr[max];
                    arr[max] = temp;                
                }
                //遍歷反轉之后的數組內容
                for (int i = 0; i<=arr.length-1;i++){
                    System.out.println(arr[i]);
                }
            }
            
            
        第二種：
            public static void main(String[] args){
                int[] arr = {1,2,3,4,5}
                
                
                //遍歷數組 for
                for (int i = 0;i<arr.length/2;i++){
                    //交換變量
                    int temp = 0;
                    temp = arr[i];
                    arr[i] = arr[arr.length-1-i];
                    arr[arr.length-1-i] = temp;                
                }
                //遍歷反轉之后的數組內容
                for (int i = 0; i<=arr.length-1;i++){
                    System.out.println(arr[i]);
                }
            }
    二維數組：
        定義方式：和一維數組是一樣的，也有三種方式
            方式一：
                數組數據類型[][] 數組名稱 = new 數組的數據類型[長度1][長度2];
                長度1不可省略，代表 該數組里面存儲的元素個數
                長度2可以省略，代表 該二維數組里面的元素（數組里面的元素個數） 而且它里面的數組元素個數一樣
                如-------》int [][] arr = new int [3][2];
                長度3----》該arr數組里面有三個元素（數組）
                長度2----》該arr數組的每個數組元素都有兩個元素
                相當於---》int[][] arr = {{0,0},{0,0},{0,0}}
            方式二：
                數組的數據類型[][] 數組名稱 = new 數組的數據類型[][]{{元素1,元素2},...{元素1,元素2,元素3,...},...};
            方式三：
                數組數據類型[][] 數組名稱 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2,元素3,...},...}
                
        二維數組元素訪問方式
            借助於【索引】
            格式：
                數組名稱[索引]---》訪問的是二位數組元素
                
                訪問二維數組當中的異為數組里面的元素
                數組名稱[一維數組的索引值][一維數組里面的元素索引值]
                如：int[][] arr = {{10,20,50},{30,40,80},{15,100}};
                //訪問arr數組當中的10元素
                arr[0][0] = 10;
                //訪問arr數組的80元素
                arr[1][2] = 80;        
                
                
                
                
                
方法：
    概念：在程序中要去實現的某一個功能，需要包含多條語句，這些語句包括循環，選擇語句結構共同處理一件事情.
    
    定義方法的格式詳解：
        public stctic void main(String[] args){
            //方法體內容
        
        }
        方法比喻成工廠
            蒙牛工廠
            返回值：產出物：奶制品
            void 空的，無效的
            
            
    方法定義的完整格式：
        修飾符 返回值類型 方法名稱(參數類型1 參數名稱1,參數類型2 參數名稱2,......){}
        
        修飾符：public static
        返回值類型：方法最終產生的數據結果是什么樣的
        方法名稱：方法的名字，名字自定義--標識符  小駝峰命名法、見名知意
        參數：String[]（參數類型） 進入方法中的數據是一個什么類型
                args---》變量（參數名稱）進入方法當中的數據對應的變量名稱
        方法體：方法需要執行的功能，由若干行代碼組成的
        return：一般認為有兩個作用。1.可以將后面的返回值返回給程序；2.可以停止當前正在執行的方法
        返回值：就是方法執行最終產生的數據結果
        
        備注：1.return后面的返回值必須和方法聲明上的返回值類型保持一致
              2.方法不允許嵌套,方法不能定義在類外面
              3.方法只能並列，並且必須定義在類的里面.
              
    方法的調用：【重點】
        三種調用格式：
            單獨調用：方法名稱(參數具體值);
            打印調用：System.out.println(方法名稱(參數具體值));
            賦值調用：數據類型 變量名稱 = 方法名稱(參數具體值);
            備注：當返回值類型為void的時候，這種方法只能單獨調用，不能進行打印調用或者賦值調用.
            返回值類型一般可以理解為數據類型(基本數據類型和引用數據類型)，除了這些還包含一種類型void
            當方法執行完畢不需要給程序的調用者返回任何的數據結果時，可以指定該方法的返回值類型為void
            此時只能【單獨調用】.
            
            
        注意事項：
            1.方法定義的先后順序無所謂
            2.方法定義不能嵌套，不能再一個方法內部定義另外一個方法
            3.方法定義之后，自己不會執行；如果希望執行，一定要進行方法的調用
            
            
            
    方法重載：
        對於功能類似的方法來說，因為參數列表不一致，卻需要定義不同的方法名稱，
        對於開發者來說，記憶呢么多的功能類似的不同的方法名。非常麻煩
    
        public class MethodDemo02{
            public static void main(String[] args){
                
            }
            //計算兩個數的和
            //計算兩個整數的和
            public static int sum(int a,int b){
                //兩個整數的和
                return(a+b);
            }
            //計算兩個小數的和
            public static doublic sum(double    a,double b){
                
                return(a+b);
            }
            //計算整數和小數的和
            public static doublic sum(int    a,double b){
                
                return(a+b);
            }
            //計算整數和小數的和
            public static doublic sum(double    a,int b){
                
                return(a+b);
            }
        }
        【如果在類中定義方法時方法的參數列表不一致，雖然方法名稱一樣，但是程序會認為這是一個新方法】
        方法重載[Overload]:在一個類中，多個方法名稱一致，但是參數列表不一樣
        
        好處：只需要記住唯一一個方法名稱即可，就可以實現類似的多個功能.
        
        方法重載與哪些因素有關：
            1.參數個數不同
            2.參數類型不同
            3.參數的多類型順序不同
            
        方法重載與哪些因素無關：
            1.與參數名稱無關
            2.與方法的返回值類型無關
            3.與方法的修飾符無關
            
    數組作為方法參數和返回值
        數組作為方法的參數
            數組作為引用類型能否當成方法的參數進行傳遞呢？當然可以
                數組作為方法參數傳遞時，傳遞的參數是數組內存的地址.
                public static void main(String[] args){
                    int[] arr = {1,2,3,4,5};
                    //調用方法，傳遞數組
                    println(arr);
                }
                /*
                    創建方法，方法接收數組類型的參數
                    進行數組遍歷
                */
                public static void println(int[] arr){
                    for(int i = 0; i<=arr.lenght-1;i++){
                        System.out.println([arr[i]]);
                    }
                }
                
                
        數組作為方法的返回值
            數組作為方法的返回值，返回的是數組的內存地址
            public static void main(String[] args){
                //調用方法，接收數組的返回值
                //接收到的是數組中的內存地址
                int[] arr = getArray();
                System.out.println(arr);//此時是一個內存地址哈希值
            }
            /*
                創建方法，返回值是數組類型
                return 返回數組內存地址
            */
            public static int[] getArray(){
                int[] arr = {1,3,5,9,11};
                //此時返回數組的內存地址，返回給調用者
                return arr;
            }
            一個方法可以有0，1多個參數；但是只能有0個或者1個返回值，不能有多個返回值.
            如果我們希望一個方法當中它產生了多個結果數據，這些多個結果數據同時需要返回
            解決方案：使用一個容器（數組）作為方法的返回值類型即可.
            public static void main(String[] args){
                int a = 10;
                int b = 20;
                change(a,b);
                System.out.println(a);//a = 10
                System.out.println(b);//b = 20
            }
            public static void change(int a,int b){
                a = a+b;// 30
                b = b+a;// 50
            }
            
            public static void main(String[] args) {
                int[] arr = {10,20};
                changeArray(arr);
                System.out.println(arr[0]);// arr[0] = 10?---->30
                System.out.println(arr[1]);// arr[1] = 20?---->50
            }   
            public static void changeArray(int[] arr) {
                arr[0] = 30;
                arr[1] = 50;
         }