泛型

对于泛型的基本概念就不多讲，需要了解泛型的知识点可以看下图：

泛型解决了java中对Object的任意化操作所产生的问题，这种任意化操作就是Object引用进行“向上转型”或者“向下转型”操作，但是某些操作强制类型转换的错误也许不会被编译器捕捉，而在运行的时候出现异常，可见类型转换存在安全隐患，所以在此提供安全省心的泛型类型。

泛型的初步了解

1、泛型类：

class 类名<字母，字母......>{
        private 字母 属性名;
        …setter与getter.
}

需要注意的是：
          a) 泛型不能使用在基本类型上
          b) 泛型不能使用在静态属性上

public class Student<T,T1> {
   private T javase;

   public Student() {
   }
   public Student(T javase) {
      this.javase =javase;
   }
   public T getJavase() {
      return javase;
    }
   public void setJavase(T javase) {
       this.javase = javase;
   }
}

2、泛型接口
接口中泛型字母只能使用在方法中，不能使用在全局常量中

public interface Comparator<T> {
    void compare(T t);  
    //T Max_Value = 100;  //会报错 
}

3、泛型方法
泛型方法一般都是在返回值之前加<字母>，泛型方法可以在非泛型类中

public class TestMethod {
    public static void main(String[] args) {
        test("a"); //T -->String
    }
    //定义泛型方法
    public static <T> void test(T a){       
        System.out.println(a);
    }
    // extends表示上限<=   ...表示可变参数，例如将其换成[]就成了数组
    public static <T extends Closeable> void test(T... a){
        for(T temp:a){
            try {
               if(null!=temp){  temp.close();}
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

泛型的深入

泛型的继承
当父类为泛型的话，子类也必须要保留父类的泛型或者实现父类的泛型，而且子类泛型必须>=父类泛型，也就是会所子类的泛型可以比父类多。当子类没写父类的具体实现的话，就会默认为Object，而泛型的接口和类的继承是一样的

  /**
     * 泛型父类，子类为富二代 
     * 1、保留父类泛型 -->子类为泛型
     * 2、不保留父类泛型 -->子类按需实现
     * 
     * 属性 及方法 类型 -->随位置而定
     * 1)、子类重写方法的类型 -->随父类而定
     * 子类新增方法的类型 -->随子类而定
     * 2)、子类中使用父类的属性 -->随父类而定
     * 子类中使用自己的属性 -->随子类而定
     * @author bj
     *
     */
public class Class_Extends{
    public abstract class Father<T1,T2> {
        T1 age;
        public abstract void test(T2 name);

    }

    //保留  -->泛型子类
    //1)、全部保留
    class Child1<T1,T2,A,B> extends Father<T1,T2>{
        T1 age;//this.age -->T1
        A Sex;

        @Override
        public void test(T2 name) {
        }

        public void test2(B b){
        }   
    }

    //2)、部分保留
    class Child2<T2,A,B> extends Father<Integer,T2>{
        Integer age;//this.age -->Integer
        A Sex;

        @Override
        public void test(T2 name) {
        }

        public void test2(B b){
        }   
    }

    //不保留  -->按需实现
    //1)、具体类型
    class Child3 extends Father<Integer,String>{
        Integer age;//this.age -->Integer

        @Override
        public void test(String name) { 
        }
    }

    //2)、没有类型 擦除 Object
    @SuppressWarnings("rawtypes")
    class Child4 extends Father/*<Object,Object>*/{
        Object age;//this.age -->Object

        @Override
        public void test(Object name) { 
        }
    }
}

泛型的擦除

public class MyStudent<T> {
    private T javase;
    //private static T test; //泛型不能使用在静态属性上
    public MyStudent() {
    }

    public MyStudent(T javase) {
        this.javase = javase;
    }

    public T getJavase() {
        return javase;
    }

    public void setJavase(T javase) {
        this.javase = javase;
    }
}

public class MyStudentImpl {
    /**
     * 泛型的擦除: 使用时 |实现|继承 没有指定类型 ，
     * 类似于 Object ,不等同于 Object
     */
    public static void main(String[] args) {
        //擦除 -->没有指定 泛型的具体类型
        MyStudent student =new MyStudent();
        student.setJavase(100); //100 -->int -->Integer -->Object
        Object obj=student.getJavase();
        System.out.println(obj);
        test(student);//编译不会类型检查，此处不会报错，因为Object类型相当于被擦除了

        MyStudent<Object> student2 =new MyStudent<Object>();
        //不等于 Object
        //test(student2); -->会报错，因为这个地方已经申明了Object类型，就只能是Object类型
    }

    public static void test(MyStudent<Integer> stu){
    }
}

import java.util.ArrayList;
 public class ErasedTypeEquivalence { 
      public static void main(String[] args) { 
          //我们分别定义了一个接受String类型的List和一个接受Integer类型的List，
          //按照我们正常的理解，泛型ArrayList<T>虽然是相同的，但是我们给它传了不同的类型参数，
          //那么c1和2的类型应该是不同的。但是结果恰恰相反，运行程序发现二者的类型时相同的。这是为什么呢？
          //这里就要说到Java语言实现泛型所独有的——擦除
            Class c1 = new ArrayList<String>().getClass(); 
            Class c2 = new ArrayList<Integer>().getClass(); 
       System.out.println(c1 == c2); 
      } 
 }