java高级特性之泛型

看了一些关于泛型的文章，写一下自己对于泛型的理解。。
当我们知道了泛型可以用来干什么之后就自然而然会明白泛型是什么了，即使它是一个非常抽象的东西。
泛型，泛，大致的，就是你知道它是一个黑盒子里面装的东西，但是你不知道它具体是什么，它可能是炸弹，可能是糖果，或者是iphone X。
那泛型可以用来干什么呢，打个比方，老板让你送一个快递盒子，你的快递盒子里面装的东西你并不知道，老板也不会告诉你它是什么（如果每次都告诉你是什么东西岂不是非常麻烦？），但是老板告诉你，你要非常小心，不能剧烈抖动（实际上老板已经告诉你它有一个特点，就是易碎或者是在剧烈抖动下易损坏），你要做的事情就是将你的快递盒子交给老板要求送到的一个人。
那整理一下思路，我们需要的东西是：盒子（未知对象）、送给谁、剧烈抖动下易损坏。
用程序表示：

Test.java
public class Test {

    public static <T> T hezitoWho(man me,T t,man who) {
        System.out.println("运送目标："+who.getName());
        if(t.getClass()==hezi.class) {
        hezi hezi = (hezi)t;
        if(hezi.isFragile()) {
            me.beCareful();
        }
        else {
            me.dontWorry();
        }
        }
        return t;
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        man me = new man("我");
        man who = new man("周星星");
        hezi hezi = new hezi();
        String stringhezi = new String("stringhezi");
        Integer integerhezi = new Integer(0);
        who.get(hezitoWho(me,hezi,who));
        who.get(hezitoWho(me,stringhezi,who));
        who.get(hezitoWho(me,integerhezi,who));
    }

}

man.java
public class man {
    private String name;

    public man(String name) {
        this.name = name;
    }
    public void beCareful(){
        System.out.println(name+"小心运送中..");
    }

    public void dontWorry(){
        System.out.println(name+"不用小心，大胆动起来，运送中..");
    }

    public <T> void get(T t) {
        if (t!=null)
        System.out.println(name+"收到"+t.toString());
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

hezi.java
public class hezi{
    private boolean fragile=true;//盒子是易碎的

    public boolean isFragile() {
        return fragile;
    }

    public void setFragile(boolean fragile) {
        this.fragile = fragile;
    }

    public String toString() {
        return hezi.class.toString();
    }
}

这个例子比较繁琐。。帮助我个人理解。。。
这个时候我们会发现，可以直接使用Object作为类似泛型来操作这样的例子，比如例子中的hezi，直接在函数中把它当作对象进行处理，最后根据情况进行不同对象的强转即可。
但是强转很容易出现ClassCastException，因为我们在处理不同对象时要进行分辨然后分别进行转化，如：
If（class==“String”）{//转化成String}
If (class==”Integer”){//转化成Integer}
…
当数据类型较多时，就会出现非常多复杂冗余的代码，所以，为了提高我们程序的灵活性和拓展性,我们还是应该学会灵活应用泛型。

泛型的使用：
1. 具有一个或多个类型的变量的类，叫做泛型类
class A {
}

1. 在创建泛型类实例时，需要为其类型变量赋值
   A a = new A();

   • 如果创建实例时，不给类型变量赋值，那么会有一个警告！（目的是向下兼容）

2. 具有一个或多个类型的方法，叫做泛型方法
   class A {
   public T fun(T t) {}//不是泛型方法
   public void fun(){}
   public void fun(T t){}
   public T fun(T t){}
   }

3. 泛型在类中或方法中的使用
   class A {
   private T bean;//成员变量
   public T fun(T t) {}//类中的方法上（返回值和参数类型）

   public void fun2() {
   T b = … //泛型还可以在局部变量的引用类型上使用
   new T();//不行
   }
   }

4. 泛型的继承 class AA extends A{}//不行（子类不是泛型，不能继承父类的泛型）

5. 通配符
   内容比较复杂，总结少部分。

List<Animal>
List<Cat>
List<? extends Animal>
类似
List<? super Cat> 
(List容器中装的类型应当一致,如全部为Animal对象，所以一般含?的List不能add不同类型的对象)