1.二維數組
定義：元素為一維數組的數組。
動態初始化方式一（指定有多少個長度相同的一維數組）：
數據類型[][] 變量名 = new 數據類型[m][n];
m表示有多少個一維數組
n表示一維數組中有多少個元素
動態初始化方式二（指定二維數組中有多少個一維數組，每一個一維數組的長度不固定）：
數據類型[][] 變量名 = new 數據類型[m][];
註：m這個數據必須給出，後面的數據可以不給
二維數組的靜態初始化
數據類型[][] 變量名 = new 數據類型[][]{{元素…},{元素…},{元素…}};

public class arrayarraydemo {
//  二維數組的遍歷
    public static void main(String[] args) {
//      定義一個靜態數組
        int [][]arr1={{1,2},{1,2,3},{21,4,5},{23,45,5}};
//      定義一個含有三個一維數組的二維數組，一維數組有4個元素
        int [][]arr=new int[3][4];
//      定義一個含有三個一維數組的數組
        int [][]arr2=new int[3][];
        showarray(arr1);
    }    public static void showarray(int arr1[][]){        
    for (int i = 0; i < arr1.length; i++) {            
               for (int j = 0; j < arr1[i].length; j++) {
            System.out.print(arr1[i][j]+" ");
            }
        }
    }

}

2.形式參數問題
如果形式參數是基本類型：
形式參數的改變，不影響實際參數。
如果形式參數是引用類型：
形式參數的改變，直接影響實際參序。

3 .冒泡排序
基本規則：相鄰兩個比較，大的放後面第一次排序完畢最大的元素在索引最大處，依此類推。
代碼實現

public class bubblesort {    public static void main(String[] args) {    
        int []a={1,223,34,532,64,8,56};
        bubbleSort(a);
        printArray(a);
    }    public static void bubbleSort(int[] a){    
    //冒泡排序方法，外層循環控制大的輪回，內層循環進行相鄰兩個元素比較把大的在
    //後面第一次輪回結束最大的元素在最後一位。
        for (int i = 0; i < a.length-1; i++) {           
         for (int j = 0; j < a.length-1-i; j++) {                
         if(a[j]>a[j+1]){                    
                  int temp=a[j];
                 a[j]=a[j+1];
                 [j+1]=temp;
                }               
            }
        }
    }    //構造一個遍歷數組的方法
    public static void printArray(int[] a){
        System.out.print("[");        
        for (int i = 0; i < a.length; i++) {            
           if(i==a.length-1){
           System.out.print(a[i]);
            }  else{
              System.out.print(a[i]+",");
                 }
        }
        System.out.println("]");
    }
}

3.選擇排序
基本規則：從0索引處開始依次與後面的比較，第一次結束後最小的位於0索引處，依次進行
代碼實現

public class selectSort {    
       public static void main(String[] args) {        
             int []arr={1,24,5,34,6,367,434,378};
        printArray(arr);
    }    
    //選擇排序
    public static void selectSort(int []arr){        
    //使用兩個for循環嵌套，假設i為最小數，用它跟數組中其他元素比較，
    //如果有比他小的就交換位置
        for (int i = 0; i < arr.length-1; i++) {           
         for (int j = 0; j < arr.length; j++) {                if(arr[i]>arr[j]){                    int temp=arr[i];
             arr[i]=arr[j];
             arr[j]=arr[i];      
                }
            }
        }
    }    
    //寫一個遍歷數組的方法
    public static void printArray(int[] arr){
        System.out.print("[");        
        for (int i = 0; i < arr.length; i++) {            
             if(i==arr.length-1){
            System.out.print(arr[i]);
            }else{
            System.out.print(arr[i]+",");
            
        }
        System.out.print("]");
    }
}

4.Arrays數組工具類
針對數組進行操作的工具類。提供了排序，轉換等功能。

成員方法：
public static String toString(int[] a):把數組轉成字符串
public static void sort(int[] a):對數組進行排序（有重載）
5.繼承
extends關鍵字可以進行類與類之間的繼承
格式：
class 子類名 extends 父類名 {

        } 

    父類：基類，超類
    子類：派生類

學生類：
        成員變量：name,age
        構造方法：無參,帶參
        成員方法：getXxx()/setXxx(),eat(),sleep()


    老師類：
        成員變量：name,age
        構造方法：無參,帶參
        成員方法：getXxx()/setXxx(),eat(),sleep()    

按照我們剛才對繼承的概述，我們可以找一個父類。

    人類：
        成員變量：name,age
        構造方法：無參,帶參
        成員方法：getXxx()/setXxx(),eat(),sleep()    

    學生類：繼承人類就可以了。
    老師類：繼承人類就可以了。

繼承的好處：
    A:提高了代碼的復用性
        多個類相同的成員可以放到同一個類中
    B:提高了代碼的維護性
        如果功能的代碼需要修改，修改一處即可
    C:讓類與類之間產生了關系，是多態的前提
方法重寫(子類的方法名，參數和父類完全一樣，將父類方法覆蓋)：
1.必須存在繼承關系
2.父類的方法滿足不了你的需求，此時你就需要重寫父類的方法，實現自己想要實現的功能
繼承的特點：（代碼演示）
    A:Java只支持單繼承，不支持多繼承。
    B:Java支持多層(重)繼承(繼承體系)。

什麽時候使用繼承呢?
    繼承中類之間體現的是：”is a”的關系。就是子類必須是父類的對象。
    舉例：水果，香蕉
    舉例：水杯，水果 (不能采用繼承。)
    舉例：動物，狗

6.類的組成：
成員變量
構造方法
成員方法

繼承間的成員變量關系：
    A:名字不同，非常簡單。
    B:名字相同
        首先在子類局部範圍找
        然後在子類成員範圍找
        最後在父類成員範圍找(肯定不能訪問到父類局部範圍)
        如果還是沒有就報錯。(僅能在父類找）
        就近原則。

super
關鍵字

可以調用父類的方法
super:
super代表父類存儲空間的標識(可以理解為父類對象)

this和super的使用區別：
    A:成員變量
        this.成員變量   本類的成員變量
        super.成員變量  父類的成員變量
    B:成員方法
        this.成員方法() 本類的成員方法
        super.成員方法()父類的成員方法 
繼承間構造方法的關系：
    子類中所有的構造方法默認都會訪問父類中空參數的構造方法(super())


    因為子類會繼承父類中的數據，可能還會使用父類的數據。
    所以，子類初始化之前，一定要先完成父類數據的初始化。
    每個子類的構造方法的第一行，有一條默認的語句:
        super();

    註意：僅僅是完成數據的初始化，創建對象目前必須用new申請空間。

假如父類沒有無參構造方法,該怎麽辦呢?
    A:調用父類的其他構造方法。帶參構造。
        怎麽訪問呢?
            super(...)

註意：
    super(…)或者this(….)必須出現在第一條語句上。
    因為如果可以放後面的話，就會對父類的數據進程多次初始化。所以，只能放在第一條語句上。

建議：
    永遠給出無參構造方法。

7.final關鍵字
在實際開發的時候，有些方法的內容一旦寫定後，就不允許被改動。
即使是子類，也不允許。
Java為了解決這樣的問題就提供了一個關鍵字：final
最終的意思。它可以修飾類,方法,變量。
特點：
修飾方法，方法不能被重寫。
修飾類，類不能被繼承。
修飾變量，變量的值不能再改動。其實這個時候變量已經變成了常量。

常量：
    A:字面值常量
        ‘a‘,12,"hello"
    B:自定義常量
        就是把變量用final修飾。
        定義一個常量。
        final 數據類型 變量名;

8.多態
定義：同一個對象,在不同時刻表現出來的不同狀態。
多態的前提：
A:有繼承關系
B:有方法重寫（不是必要條件，但是只有有了方法重寫多態才有意義）
C:有父類引用指向子類對象
成員訪問特點
A:成員變量
編譯看左邊,運行看左邊
B:構造方法
子類構造默認訪問父類的無參構造
C:成員方法（重點理解）
編譯看左邊,運行看右邊

        為什麽變量和方法不一樣呢?
            方法重寫。
    D:靜態成員方法
        編譯看左邊,運行看左邊
        因為靜態的內容是和類相關的，與對象無關。

9.抽象類
抽象類特點:
A:抽象類和抽象方法必須用abstract關鍵字修飾
B:抽象類不一定有抽象方法，有抽象方法的類一定是抽象類
C:抽象類不能實例化
實例化並使用
按照多態的方式，由具體的子類實例化。其實這也是多態的一種，抽象類多態。
D:抽象類的子類
要麽是抽象類
，要麽重寫抽象類中的所有抽象方法

抽象類的作用：
    強制要求子類必須要重寫某些方法。    
類的組成：
    成員變量：
    構造方法：
    成員方法：
抽象類的成員：
    成員變量：可以是變量，也可以是常量。
    構造方法：有構造方法
      構造方法作用：用於子類訪問父類數據的初始化。
    成員方法：既可以是抽象的，也可以是非抽象的。

抽象類練習
以後我們在寫代碼的時候，有這樣的分析過程。
分析：
從具體到抽象。
實現：
從抽象到具體。
使用：

使用具體的類。

java基礎3