package com.javaSe;


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


/*
1 JDK5.0之後推出的新特性：泛型
2 泛型這種語法機制，只在程式編譯階段起作用，只是給編譯器作參考的。（執行階段泛型沒用！）
3 使用了泛型的好處是什麼？
    第一：集合中儲存的元素型別統一了。
    第二：從集合中取出的元素型別是泛型指定的型別，不需要進行大量的“向下轉型”！


4 泛型的缺點是什麼？
    導致集合中儲存的元素缺乏多樣性！
    大多數業務中，集合中的元素型別還是統一的，所以這種泛型特性被大家所認可。
 
*/
public class GenericTest01 {
    public static void main(String[] args) {
        /*// 不使用泛型機制，分析程式存在的缺點
        List myList = new ArrayList();
        
        // 準備物件
        Cat c = new Cat();
        Bird b = new Bird();
        
        // 將物件新增到集合當中
        myList.add(c);
        myList.add(b);
        
        // 遍歷集合，取出Cat讓他抓老鼠，取出Bird讓它飛。
        Iterator it = myList.iterator();
        while(it.hasNext()){
            
            
 
*//*if (obj instanceof Cat){
                ((Cat) obj).catchMouse();
            }else if(obj instanceof Bird){
                ((Bird) obj).fiy();
            }*//*
            
            // 沒有這個語法，通過迭代器取出就是Object
            // Animal a = it.next();
            
            // obj中沒有move方法，無法呼叫，需要向下轉型！
            Object obj = it.next();
            
            if(obj instanceof Animal){
                Animal a = (Animal)obj;
                a.move();
            }
        }
 
*/
        
        // 使用JDK5之後的泛型機制
        // 使用泛型List<Animal>之後，表示List集合中只允許儲存Animal型別的資料。
        // 用泛型來指定集合中儲存的資料型別
        List<Animal> list = new ArrayList<Animal>();
        
        // 指定List集合中只能儲存Animal型別的物件，那麼儲存String型別就報錯了。
        // 這樣用了泛型之後，集合中的元素資料型別更加統一了。
        // list.add("abc");
    
        // 準備物件
        Cat c = new Cat();
        Bird b = new Bird();
    
        // 將物件新增到集合當中
        list.add(c);
        list.add(b);
        
        // 獲取迭代器
        Iterator<Animal> it = list.iterator();
        while(it.hasNext()){
            
            // 使用泛型之後，每一次迭代返回的資料都是Animal型別。
            /*Animal a = it.next();
            a.move();*/
    
            Animal a = it.next();
            if(a instanceof Cat){
                ((Cat) a).catchMouse();
            }
            
            if(a instanceof Bird){
                ((Bird) a).fiy();
            }
        }
        
    }
}


class Animal{
    public void move(){
        System.out.println("動物在移動!");
    }
}


class Cat extends Animal{
    public void catchMouse(){
        System.out.println("貓抓老鼠！");
    }
}


class Bird extends Animal{
    public void fiy(){
        System.out.println("鳥兒在飛翔！");
    }
}

案例2：

package com.javaSe;


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


/*
JDK之後引入了:自動型別推斷機制。（又稱為鑽石表示式）
*/
public class GenericTest02 {
    public static void main(String[] args) {
        // ArrayList<這裡的型別會自動推斷>(),前提是JDK8之後才允許。
        // 自動型別推斷,鑽石表示式！
        List<Animal> myList = new ArrayList<>();
        myList.add(new Animal());
        myList.add(new Cat());
        myList.add(new Bird());
        
        // 遍歷
        Iterator<Animal> it = myList.iterator();
        while(it.hasNext()){
            Animal animal = it.next();
            animal.move();
        }
        
        List<String> strList = new ArrayList<>();
        // 型別不匹配
        // strList.add(new Cat());
        strList.add("http://www.baidu.com");
        strList.add("http://www.126.com");
        strList.add("http://localhost:8090/reinsure");
        
        // 型別不匹配
        // strList.add(123);
    
        System.out.println(strList.size());
        
        // Iterator的泛型就是String
        Iterator<String> iterator = strList.iterator();
        /*Object obj = iterator.next();
            if(obj instanceof String){
                String s = ((String) obj).substring(7);
                System.out.println(s);
            }*/
        while (iterator.hasNext()){
            
            // 如果沒有使用泛型
            
            
            // 通過迭代器獲取了String型別的資料
            String s = iterator.next();
            // 直接呼叫String類的subString()方法擷取字串。
            s = s.substring(7);
            System.out.println(s);
        }
    }
}

案例3：

package com.javaSe;
/*
自定義泛型可以嗎？可以
    自定義泛型的時候，<>尖括號中的是一個識別符號，隨便寫。
    java原始碼中經常出現的是：
        <E>和<T>
    E是element單詞首字母。
    T是type單子首字母。
    
*/
public class GenericTest03<aaaaaa> {
    public void doSome(aaaaaa o) {
        System.out.println(o);
    }
    
    public static void main(String[] args) {
        // new物件的時候指定了泛型是：String型別
        GenericTest03<String> gt = new GenericTest03<>();
        
        // 型別不匹配
        // gt.doSome(123)
        
        gt.doSome("abcdef");
        
        // ------------------------------------------------------
        
        GenericTest03<Integer> gt2 = new GenericTest03<>();
        gt2.doSome(123);
        
        // 型別不匹配
        // gt2.doSome("123");
        
        MyIterator<String> mit = new MyIterator();
        String s1 = mit.get();
        System.out.println(s1);
    
        MyIterator<Animal> mit2 = new MyIterator();
        Animal a = mit2.get();
        System.out.println(a);
        
        // 不用泛型就是Object型別
        // GenericTest03 gt3 = new GenericTest03();
        // gt3.doSome(new Object());
    }
}


class MyIterator<T>{
    public T get(){
        return null;
    }
}