1.氣泡排序程式碼

簡單的排序演算法

依次比較兩個相鄰的元素，

原理如下：

• 比較相鄰的元素
• 從開始第一對到結尾的最後一對。
• 針對所有的元素重複以上的步驟，除了最後一個。

以下就是一個氣泡排序

public class Test {
   public int[] sort(int[] a){
       int t=0;
       for (int i = 0; i < a.length-1; i++) {
           int f=0;
           for (int j = 0; j < a.length-i-1; j++) {
               
 
if (a[j+1]>a[j]){
                   t=a[j];
                   a[j]=a[j+1];
                   a[j+1]=t;
                   f=1;
               }
           }
           if (f==0){
               break;
           }
       }
       return a;
   }
    public static void main(String[] args) {
        Test test 
 
= new Test();
        int[] a={2,5,1,6,4,9,8,5,3,1,2,0};
        int[] b=test.sort(a);
        for (int n:b) {
            System.out.print(n+" ");
        }
    }
}
//結果：9 8 6 5 5 4 3 2 2 1 1 0 

2.選擇排序的程式碼

簡單直觀的排序演算法

每一次從待排序的資料元素中選出最小 （或最大）的一個元素，存放在序列的起始位置

public class Test007 {
   public int[] sort(int
 
[] a){
        //1.假設第一個下標值為最小值
       int t=0;
       for (int i = 0; i < a.length-1; i++) {
           int minindex=i;
           //2.第一個和第二個值比較，如果第二個值小於第一個值，則下標換成第二個值的下標
           for (int j = i+1; j < a.length; j++) {
                if (a[minindex]>a[j]){
                    minindex=j;
                }
           }
           //3.發現最小值不是最初的了
           if (i!=minindex){
               t=a[i];
               a[i]=a[minindex];
               a[minindex]=t;
           }
       }
       return a;
   }
    public static void main(String[] args) {
        Test007 test = new Test007();
        int[] a={2,5,1,6,4,9,8,5,3,1,2,0};
        int[] b=test.sort(a);
        for (int n:b) {
            System.out.print(n+" ");
        }
    }
}
//結果：0 1 1 2 2 3 4 5 5 6 8 9 

3.插入排序的程式碼

在一個已經排序好的陣列中插入一個數，插入之後仍然保持有序

新的排序方法——插入排序法

public class Test007 {
    public int[] sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        for (int i = 1; i < arr.length; i++) {
//內層迴圈依次減少並提出結果
            for (int j = i; j > 0; j--) {
//如果當前數字小於前一個,則交換,否則不變
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                } else {
                    break;
                }
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        Test007 test = new Test007();
        int[] a = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
        int[] b = test.sort(a);
        for (int n : b) {
            System.out.print(n + " ");
        }
    }
}
//0 1 1 2 2 3 4 5 5 6 8 9 

4. 可變引數的作用和特點

可變引數

• 形式 ...
• 只能是方法的形參
• 對應的實參可以0,1,2.....n個，也可以是一個數組
• 如果定義了可變引數的方法，不允許同時定義相同型別陣列引數的方法

陣列做形參和可變引數做形參聯絡和區別

聯絡：

• 實參都可以是陣列
• 方法體中，可變引數本質就是當做陣列來處理

區別：

• 個數不同 可變引數只能有一個數組引數可以多個
• 位置不同 可變引數只能是最後一個 陣列引數位置任意
• 實參不同 可變引數實參可以0,1,2.....個，也可以是一個數組，陣列的實參只能是陣列

private static int sum(int... values) {
int sum = 0;
for (int i = 0; i < values.length; i++) {
sum += values[i];
}
return sum;
}

5.類和物件的關係

類是物件的抽象，而物件是類的具體例項

人類就是一個概念

小明就是一個具體的人，也就是例項

還可以有小紅,小藍等具體的人即物件,但他們都是人類的例項,即類.

7.面向過程和麵向物件的區別

比喻：

 面向過程是蛋炒飯，面向物件是蓋澆飯

蓋澆飯的好處就是“菜”“飯”分離，從而提高了製作蓋澆飯的靈活性。飯不滿 意就換飯，菜不滿意換菜

蛋炒飯就不 行了, 如果不滿意就要丟掉重做

區別：

• 程式設計思路不同
• 封裝性：都具有封裝性，但是面向過程是封裝的是功能，而面向物件封裝的是資料和功能

面向物件具有繼承性和多型性

8.方法過載和方法重寫（覆蓋）的區別

方法過載（overload）：一句話”方法名字相同，而引數列表不同“

方法重寫（override）：子類繼承父類的方法進行編寫，但是不允許更改此方法的引數列表。子類根據需求定義。

重寫與過載直接的區別

過載

•  發生在一個類中
• 對返回許可權沒有要求（但在開發中會保持一致）
• 對返回值沒有要求（但在開發中會保持一致）
• 表示過載的單詞是 overloading

重寫：

• 發生在繼承中（子類和父類）
• 子類不能擁有比父類更小的訪問許可權
• 如果子類和父類訪問許可權一樣則返回值必須相同
• 表示重寫的單詞是 override

9.this和super關鍵字的作用  

this：

this是物件內部指代自身的引用,同時也是解決成員變數和區域性變數同名問題；this可以呼叫成員變數，不能呼叫區域性變數；this也可以呼叫成員方法，但是在普通方法中可以省略this，在構造方法中不允許省略，必須是構造方法的第 一條語句。而且在靜態方法當中不允許出現this關鍵字。

super：

super可以呼叫直接父類的成員方法（注意許可權修飾符的影響，比如不能訪問private成員）；super可以呼叫直接父 類的構造方法，只限構造方法中使用，且必須是第一條語句。