Generic 泛型 <> 钻石表达式

什么是泛型：

    1 JDK5.0之后推出的新特性：泛型

    2 泛型这种语法机制，只在程序编译阶段起作用，只是给编译器作参考的。（运行阶段泛型没用！）

    3 使用了泛型的好处是什么？

        第一：集合中存储的元素类型统一了。

        第二：从集合中取出的元素类型是泛型指定的类型，不需要进行大量的“向下转型”！

 

 

    4 泛型的缺点是什么？

        导致集合中存储的元素缺乏多样性！

        大多数业务中，集合中的元素类型还是统一的，所以这种泛型特性被大家所认可。

 

 

案例1：

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;
    }
}