泛型机制＜＞

1.jdk5.0之后退出的新特性：泛型
2.泛型这种机制，只在程序编译阶段起作用，只是给编译器参考的（运行阶段泛型没用）
3.使用泛型的好处：
第一：集合中存储的元素统一了。
第二：从集合中取出的元素类型是泛型指定的类型，不需要进行大量的向下转型了
4.泛型的缺点：
导致集合中的元素缺乏多样性！

package Collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest {
    public static void main(String[] args) {
       //不使用泛型机制
        //创建集合对象
        List mylist=new ArrayList();
        //准备对象
        Cat c=new Cat();
        Bird b=new Bird();
        //将集合添加到集合里边
        mylist.add(c);
        mylist.add(b);
        //遍历集合，取出每个Animal,让他run
        Iterator it=mylist.iterator();
        while(it.hasNext()){
            //Animal a=it.next(); 没有这个语法，通过迭代器取出的就是Object
            Object ob=it.next();
            //Object中没有run方法，无法调用，需要向下转型！！
            if(ob instanceof Animal){
                Animal a=(Animal)ob;
                a.run();

            }
        }

        /*使用泛型
        使用泛型List<Animal>之后，表示List集合只允许存储Animal类型的数据
        用泛型来指定集合中存储的数据类型
         */
      /*  List<Animal> mylist=new ArrayList();
        //准备对象
        Cat c=new Cat();
        Bird b=new Bird();
        //指定list集合中只能存储Animal，如果存储String就会报错
        //这样使用泛型之后，集合中元素的数据类型就更加统一了
       // mylist.add("asd");
        mylist.add(c);
        mylist.add(b);
        //获取迭代器，这个迭代器迭代的就是Animal类型
        Iterator<Animal> it=mylist.iterator();
      while(it.hasNext()){
            //使用了泛型之后，每一次迭代返回的数据就是Animal类型
            Animal a=it.next();
            //这里也不需要进行强制类型转换了，直接调用
            a.run();
            }


          //调用子类型特有的方法还是需要向下转型的
        while(it.hasNext()){
            Animal a=it.next();
            if(a instanceof Cat){
                Cat ca=(Cat)a;
                ca.eat();
        }
            if(a instanceof Bird){
                 Bird bi=(Bird)a;
                bi.fly();
            }

        }*/


    }
}

class Animal{
    public void run(){
        System.out.println("小动物喜欢奔跑");
    }

}
class Cat extends Animal{
    public void eat(){
        System.out.println("猫喜欢吃鱼");
    }

}
class Bird extends Animal{
    public void fly(){
        System.out.println("小鸟喜欢飞");
    }

}

使用泛型之后，不需要大量的强制转换啦！！

package Collection;

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

public class GenericTest {
    public static void main(String[] args) {
       //不使用泛型机制
        //创建集合对象
       /* List mylist=new ArrayList();
        //准备对象
        Cat c=new Cat();
        Bird b=new Bird();
        //将集合添加到集合里边
        mylist.add(c);
        mylist.add(b);
        //遍历集合，取出每个Animal,让他run
        Iterator it=mylist.iterator();
        while(it.hasNext()){
            //Animal a=it.next(); 没有这个语法，通过迭代器取出的就是Object
            Object ob=it.next();
            //Object中没有run方法，无法调用，需要向下转型！！
            if(ob instanceof Animal){
                Animal a=(Animal)ob;
                a.run();

            }
        }*/

        /*使用泛型
        使用泛型List<Animal>之后，表示List集合只允许存储Animal类型的数据
        用泛型来指定集合中存储的数据类型
         */
       List<Animal> mylist=new ArrayList();
        //准备对象
        Cat c=new Cat();
        Bird b=new Bird();
        //指定list集合中只能存储Animal，如果存储String就会报错
        //这样使用泛型之后，集合中元素的数据类型就更加统一了
       // mylist.add("asd");
        mylist.add(c);
        mylist.add(b);
        //获取迭代器，这个迭代器迭代的就是Animal类型
        Iterator<Animal> it=mylist.iterator();
      while(it.hasNext()){
            //使用了泛型之后，每一次迭代返回的数据就是Animal类型
            Animal a=it.next();
            //这里也不需要进行强制类型转换了，直接调用
            a.run();
            }


          //调用子类型特有的方法还是需要向下转型的
      /*  while(it.hasNext()){
            Animal a=it.next();
            if(a instanceof Cat){
                Cat ca=(Cat)a;
                ca.eat();
        }
            if(a instanceof Bird){
                 Bird bi=(Bird)a;
                bi.fly();
            }*/

        }


    }


class Animal{
    public void run(){
        System.out.println("小动物喜欢奔跑");
    }

}
class Cat extends Animal{
    public void eat(){
        System.out.println("猫喜欢吃鱼");
    }

}
class Bird extends Animal{
    public void fly(){
        System.out.println("小鸟喜欢飞");
    }

}

但是调用子类型的方法，还是需要强制转换！！

package Collection;

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

public class GenericTest {
    public static void main(String[] args) {

        List<Animal> mylist=new ArrayList();
        //准备对象
        Cat c=new Cat();
        Bird b=new Bird();
        //指定list集合中只能存储Animal，如果存储String就会报错
        //这样使用泛型之后，集合中元素的数据类型就更加统一了
        // mylist.add("asd");
        mylist.add(c);
        mylist.add(b);
        //获取迭代器，这个迭代器迭代的就是Animal类型
        Iterator<Animal> it=mylist.iterator();
      /*  while(it.hasNext()){
            //使用了泛型之后，每一次迭代返回的数据就是Animal类型
            Animal a=it.next();
            //这里也不需要进行强制类型转换了，直接调用
            a.run();
        }*/
      //调用子类型特有的方法，还是需要进行向下转型的

        while(it.hasNext()){
            Animal a=it.next();
            if(a instanceof Cat) {
                Cat x = (Cat) a;
                x.eat();
            }
            if(a instanceof Bird){
                    Bird y=(Bird)a;
                    y.fly();
                }
            }
    }




    }



class Animal{
    public void run(){
        System.out.println("小动物喜欢奔跑");
    }

}
class Cat extends Animal{
    public void eat(){
        System.out.println("猫喜欢吃鱼");
    }

}
class Bird extends Animal{
    public void fly(){
        System.out.println("小鸟喜欢飞");
    }

}

自定义泛型

package Collection;
//自定义泛型 <>钻石表达式
/*java源代码中经常出现的是：
     <E>和<T>
     E是Element单词首字母
     T是Type单词首字母
     Duan随便写一般写E或T
 */

public class GenericTest01<Duan随便写> {
    public void dosome(Duan随便写 d){
        System.out.println(d);
    }
    public static void main(String[] args) {
        //new对象的时候指定了泛型是：String类型
        GenericTest01<String>  ge=new GenericTest01<>();
        ge.dosome("吃脆脆鲨");
        //类型不匹配
       // ge.dosome(123);

    }
}