泛型

1. 泛型的意義：
   a:可以對型別進行自動檢查。 並不是替換，只是編譯期間進行檢查。
   b:自動對型別進行轉換。

2. 泛型到底是怎麼編譯的？
   型別的擦除機制：》向上擦除》Object(最高到)
   在編譯器編譯期間，把泛型全部擦除為object型別。

3. 用jmap命令檢視記憶體洩漏：javac 》Javap -c jmap jps====>檢視java程序號
   jmap -histo：live 程序號> e:\log.txt
   start e；

4. 泛型的上界：
   < T extends Comparable< T > >

5. 泛型的坑：
   1:不能new 泛型型別的陣列 new T[]
   2：不能new泛型型別的物件 T obj=new T()
   3；不能new泛型型別的物件陣列
   Object[] obj=new GenericStack< Integer>[10];
   obj[0]=“sadh”
   obj[1]=Integer(10);
   4: 不能用簡單型別作為泛型型別的引數 //但是簡單型別對應包裝類可以自動裝包的可以直接寫簡單型別；例如：需要一個Integer型別的，可以直接傳int 型別的 因為int型別直接裝包為Integer
   5：GenericStack< 記得加引用型別的引數> genericStack3=new GenericStack< 記得加引用型別的引數>(); //後面的佔位符可以不用寫但是一般都要求寫。
   一定記得加< 泛型型別的引數>，否則就預設為Object。
   6：在static方法中，不能使用泛型型別的引數，因為：static方法不依賴物件，如果不依賴物件，靜態方法就不知道這個T是什麼型別，那麼編譯的時候，拿什麼去進行型別檢查
   static方法使用泛型，如果沒有返回值，那佔位符就放在void之前，如果有返回值，那就放在返回值T 之前

public static <T extends Comparable<T>> T  findMaxVal(ArrayList<T> list){
    //<T（T的上界為Comparaable） extends Comparable<T>> T
    T max=list.get(0);
    for(int i=0;i<list.size();i++){
        if(max.compareTo(list.get(i))<0){
            max=list.get(i);
        }
    }
    return max;
}
 

萬用字元

8. 也是運用擦除機制 ==》到object
9. 萬用字元的上界：主要用於寫入，一般用於庫的開發 <? extends E> 可以接受E型別或者他的子類。
10. 萬用字元的下界：主要用來讀取
    < ? super E> 可以接受E型別或者他的父型別。

import java.util.ArrayList;
/**
 * @Created with IntelliJ IDEA
 * @Description:
 * @Package: PACKAGE_NAME
 * @User: FLy
 * @Date: 2018/11/19
 * @Time: 16:37
 */
class GenericAlg{

    public static <T extends Comparable<T>> T  findMaxVal(ArrayList<T> list){
        //<T（T的上界為Comparaable） extends Comparable<T>> T
        T max=list.get(0);
        for(int i=0;i<list.size();i++){
            if(max.compareTo(list.get(i))<0){
                max=list.get(i);
            }
        }
        return max;
    }
    public static <T extends Comparable<? super T> > T findMaxVal2(ArrayList<T> list){
        //<T(T的上界是Comparable，可以是它和他的子類) extends Comparable<? super T  (萬用字元(?)的下界是T，可以是T 和他的父類)> >  T（返回值型別為T）
        T max=list.get(0);
        for(int i=0;i<list.size();i++){
            if(max.compareTo(list.get(i))<0){
                max=list.get(i);
            }
        }
        return max;
    }
}
class Person implements Comparable<Person>{
    private String name;
    public Person(String name){
        this.name=name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    public int compareTo(Person o) {
        return this.name.compareTo(o.name);
    }
}
class Student extends Person {
    private int age;
    public Student(String name,int age){
        super(name);
        this.age=age;
    }

}
public class Generic {
    public static void main(String args []){
        ArrayList<Person>arrayList=new ArrayList<Person>();
        arrayList.add(new Person("hehouzi"));
        arrayList.add(new Person("zhouzelin"));
        System.out.println(GenericAlg.findMaxVal(arrayList));//(GenericAlg.<Person>findMaxVal(arrayList))
         //T會通過實參的型別推演出泛型的型別。
         
        ArrayList<Student> arrayList1=new ArrayList<Student>();//後面的這個佔位符可以寫
        arrayList1.add(new Student("haha",52));    // 也可以不寫，但一般建議寫
        arrayList1.add(new Student("heihei",88));
        System.out.println(GenericAlg.findMaxVal2(arrayList1));
    }
}

注意:

//這些不可以構成繼承關係
Integer     ArratList<Integer>
Number   ArrayList<Number>
Object      ArrayList<Object>