區別

一、多載與重寫

多載（overload）：在一個類里面我們需要用一個函式同時兼容多種引數的情況, 我們就可以使用到方法多載 ，在同一個方法內，方法名稱相同，但是傳入引數不同，這個就可以根據傳入的引數來判斷呼叫的到底是哪一個方法，多載大大增強了方法的功能性，[繼承的時候，不一定就在同一個類里面了]

1.1方法的多載

class OverwriteDemo {
    void print(int i) {
        System.out.println("列印整型值："+i);
    }
    void print(String i) {
        System.out.println("列印字串型別值：" +i);
    }
    void  print(String s1,String s2) {
        System.out.println("列印字串型別值："+s1+";字串型別值2："+s2);
    }
}

public class Test {
    public static void main(String[] args) {
        OverwriteDemo overwriteDemo=new OverwriteDemo();
        overwriteDemo.print(12);
        overwriteDemo.print("123");
        overwriteDemo.print("字串1","字串2");
    }
}

1.2多載的規則

針對同一個類：

1、方法名相同

2、方法引數不同（引數個數或者引數型別）

3、方法的回傳值型別不影響多載

1.3方法的重寫 （覆寫，覆寫）

同多載不同，重寫（Override）是發生在兩個類中的，且兩個類是繼承關系或者實作關系，同時方法簽名完全相同！也就是說，方法名稱和傳入蠶食要完全一致，重寫是java實作運行時多型的方式，這種通過物件型別而非定義型別去匹配實作方法的方式極大地提升了程式的開發效率和擴展性，同事也讓程式更加易于維護，

重寫使用==@Override== 注解注釋，使用該注釋編輯器會在編譯時就檢查該方法是否符合重寫的條件，避免以為是重寫卻因出現導致該方法只是多載的尷尬情況發生，

想了解更詳細重寫 請轉到 這個鏈接！！！！！

1.4 重寫的規則：

重寫：

1、方法名相同

2、方法的回傳值相同

3、方法的引數串列相同

1.5 小結

二、順序表和鏈表

順序表：底層是陣列，陣列的優點就是順序表的優點，所以順序表比較適合查找和修改，只要給定下標就可以找到這個資料并且可以修改；

鏈表：每個資料是由節點組織，鏈表適合插入和洗掉，他只需要通過節點修改執行就好， 關于鏈表的習題講解可以點 這個鏈接 ！！！

三、Comparable和Comparator

3.1 comparable

原始碼：

public interface Comparable<T> {
     public int compareTo(T o);
}

ComparaTo比較當前物件與指定物件的順序

 @Override
    public int compareTo(Students o) {
        return this.age-o.age;
    }

this是當前物件；

o：是指定的物件比較

ComparaTo的原始碼：

 if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
                         ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

也可以理解為當前物件大于，等于，小于回傳1，0，-1：

 @Override
public int compareTo(Student o) {
    
    if(this.age > o.age) {
            return 1;
        }else if(this.age == o.age) {
            return 0;
        }else {
            return -1;
    }
}

3.2Comparator

原始碼：

public interface Comparator<T> {
     int compare(T o1, T o2);
}

compare用法：

class Studens {.........}
class AgeComparator implements Comparator<Students> {
    @Override
    public int compare(Students o1, Students o2) {
        return o1.getAge()-o2.getAge();
    }
}

public class Test {
    public static void main(String[] args) {
        Students[] students=new Students[3];
        students[0]=new Students("yuenye",12,20);
        students[1]=new Students("xiaoming",22,18);
        students[2]=new Students("weichi",50,32);
        AgeComparator ageComparator=new AgeComparator();
        Arrays.sort(students,ageComparator);
        System.out.println(Arrays.toString(students));
    }

Comparator也稱之為比較器，可以通過compare指定里面的比較規則；

所以就引出了他兩的區別：

3.3小結

1、Comparable也稱內比較器，對類的侵入性強，Comparable里面的類都是自己跟自己比較，在自定義中的陣列排序，如要排序就可以用到Comparable，但是要在這個陣列進行另一種設定排序的時候就會改變原有類里面的代碼，不夠靈活.

@Override
    public int compareTo(Student o) {
        return (int)(this.score-o.score);
        //return this.name.compareTo(o.name);
        //return o.age-this.age;
        /*if(this.age > o.age) {
            return 1;
        }else if(this.age == o.age) {
            return 0;
        }else {
            return -1;
        }*/
    }

Comparator稱外在比較器，對類的侵入性弱，不需要修改類本身，只需要修改比較器的比較規則，如要進行其他比較規則直接重寫比較器即可；這也算是對Comparable不足的增強，揚長補短；

2.Comparable重寫的是compareTo；

? Comparator重寫的是compare；

四、抽象類和介面

4.1 抽象類

1、用abstract修飾

2、抽象類可以包含欄位，成員方法，和普通方法規則一樣

3、不能被final和private修飾；

4、不能被實體化；

5、extends維護

6、普通類繼承抽象類，那么普通類里面所有的抽象方法都要被重寫；

4.2 介面

1、用interface修飾；

2、介面里面不能有普通方法，只能有抽象方法；

3、介面當中的成員變數，可以用publlic static final修飾；

4、不能被實體化；

5、一個類用implements實作n個介面；

6、介面和介面之間的關系時extends來維護；

詳細的語法規則可以看 這個鏈接 ！！！！

五、super和this

super關鍵字一般用于繼承中，在建構式和需要用到父類屬性和方注的時候使用

大多數書上this寫的是代表當前物件，其實是錯誤的，應該是代表當前物件的參考，想看原因可以 點擊這個鏈接 ！！！

六、ArrayList和LinkedList

ArrayList 和 LinkedList 是 List 介面的兩種不同實作，

ArrayList底層是陣列，LinkedList底層是一個雙向鏈表，區別主要是他們不同方法使用和不同的時間復雜度，

6.1ArrayList：

1、get (int index) 方法時間復雜度是O(1)，找到下標即可

2、boolean add(E e)方法，默認是放到這個陣列最后的位置，還要考慮擴不擴容，不擴容時間復雜度就是O(1)，默認陣列大小變為10，需要擴容的話，需要擴容的話，擴容方式就是1.5倍擴容，add的原始碼最后還有個Arrays.copyOf()，最后還要把原陣列復制到新陣列中，就會耗時了；

//ArrayList 的add方法的原始碼
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

 List<Integer> list = new ArrayList<>();
 ArrayList<Integer> list2 = new ArrayList<>(14);
 ArrayList<Integer> list3 = new ArrayList<>(list);//new ArrayList<>()

6.2LinkedList：

1、get (int index) 方法時間復雜度是O(n)，因為要遍歷整個鏈表，

2、boolean add(E e)方法時間復雜度是O(1)，因為是鏈表直接放最后就好了

LinkedList<Integer> list = new LinkedList<>();
LinkedList<Integer> list2 = new LinkedList<>(new ArrayList<>());

6.3 小結

需要注意的是ArrayList和LinkedList在記憶體的使用上是不同的，LinkedList是雙向鏈表，所以會存盤前序和后續元素地址，所以LinkedList開銷會比較大，但是ArrayList就沒有這樣的開銷，另外ArrayList占用的記憶體用add方法的時候就已經默認是10了，而LinkedList不需要指定大小，