Java泛型

什么是泛型

泛型，即“参数化类型” 。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。

参数化类型，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式，然后在使用/调用时传入具体的类型。

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，泛型的好处就是在编译的时候能够检查类型安全。

import java.util.ArrayList;
import java.util.Date;
public class Demo1 {
	 public static void main(String[] args) {
		/*
		   ArrayList<E>  E-->参数-->类型
		                泛型--->参数化类型,类型参数化
		                
		   java中所有的集合类,都支持泛型,支持向类中,传入一个类型,
		         建议集合中只存储一种类型 , 就不需要进行向下转型          
		 */
	/* 
	    不使用泛型的反例
            ArrayList list = new ArrayList<>();
            list.add("aaa");
            list.add("aaa");
            list.add(new Date());
            list.add(10);
            for(Object obj : list){
                if(obj instanceof String){
                    String s = (String)obj;
                    s.length();
                }
                if(obj instanceof Date){
                    String s = (String)obj;
                    s.length();
                }
            }  */
		 //使用泛型的案例
	 ArrayList<String> list = new ArrayList<>();
         list.add("aaa");
         list.add("aaa");
         for(String obj : list){
              String s = (String)obj;
              s.length();
        }  
	}
}

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。

一个最普通的泛型类：

public class Car<T> {//T可以为任意标识符，常见的如T(type)、E(element)、K(key)、V(value)等形式的参数常用于表示泛型,类型是和创建对象时的类型所对应的
    private T name;//成员变量的类型为T,T的类型由外部指定
    //private int price;
    
    public Car() {
    }

    public Car(T name) {//泛型构造方法形参name的类型也为T，T的类型由外部指定
        this.name = name;
    }

    public T getName() {//泛型方法getName的返回值类型为T，T的类型由外部指定
        return name;
    }

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

    public static void main(String[] args) {
        //类型参数化, 把类型当做参数一样,动态的传递
        Car<String> car1=new Car<>("aaa");//传入的实参类型需与泛型的类型参数类型相同，即为String
    }
}

1.泛型的类型参数只能是类类型 ,不能是int类型。。。。

2.泛型的类型参数可以有多个。

3.如果没有定义具体类型,默认为Object

从泛型类派生子类

1.子类也是泛型类，子类和父类的泛型类型要一致

class A<T> extends Demo<T>

2.子类不是泛型类，父类要明确泛型的数据类型

class A extends Demo<String>

泛型接口

泛型接口与泛型类的定义及使用基本相同

public interface Demo<T> { //定义一个泛型接口 }

1.子类也是泛型类，子类和父类的泛型类型要一致

class A<T> implements Demo<T> { }

//如果一个子类继承/实现父级类/接口是有泛型的,那么子类也可以定义为一个泛型类
public class Person<T> implements Comparable<T>{
	private String name;
	@Override
	public int compareTo(Person o) {
		return 0;
	}
	public static void main(String[] args) {
		Person<String> p =   new Person<>();
		p.compareTo("aaa");
	}
}

2.子类不是泛型类，父类要明确泛型的数据类型

public class A implements Demo<String> { }

//如果一个子类继承/实现父级类/接口是有泛型的,那么子类也可以不定义为泛型类,那么父类/接口类型必须要明确才行
public class Person implements Comparable<Person>{
	 private String name;
	@Override
	public int compareTo(Person o) {
		return 0;
	}
	public static void main(String[] args) {
		Person p = new Person();
	}
}

泛型通配符

类型通配符 一般是使用"?"，代替具体的类型实参，表示实际传入的参数类型可以是任意的

public class Demo<T>{ 
	//test(Demo<?> d)  ? 类型通配符,指的是实际传入参数的类型, 可以是任何类型
	 public void test(Demo<?> d){
         
	 }
	 public static void main(String[] args) {
		  Demo d0 = new Demo<>();
		  Demo<Integer> d1 = new Demo<>();
		  Demo<String> d2 = new Demo<>();
		  d0.test(d1);
		  d0.test(d2);
	}
}

<? extends T> 泛型上限，实际传入参数的泛型,上限是T 以及T的子类

<? super T> 泛型下限，实际传入参数的泛型,下限是T 以及T的父类

public class Demo<T>{
	 public void test(Demo<?> d){
		 
	 }
      public void test1(Demo<? extends T> d){//传进来的类型比T小，或者等于T
		 
	 }
      public void test2(Demo<? super T> d){//传进来的类型比T大，或者等于T
 		 
 	 }
	 
	 public static void main(String[] args) {
		 
		  /*Demo<Number> d0 = new Demo<>();
		  Demo<Integer> d1 = new Demo<>();//Integer继承了Number
		  Demo<Number> d2 = new Demo<>();
		  Demo<String> d3 = new Demo<>();
		    d0.test1(d1);
		    d0.test1(d2);
		    d0.test1(d3);//错误❌
		    */
		 
		  Demo<Number> d0 = new Demo<>();
		  Demo<Object> d1 = new Demo<>();
		  Demo<Number> d2 = new Demo<>();
		  d0.test2(d1);
		  d0.test2(d2);
	}
}

类型擦除

泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好地和之前版本的代码兼容。那是因为，泛到信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为一类型擦除。泛型类被类型擦除后，相应的类型就被替换成 Object 类型或者上限类型。

泛型只是在编译期间来对类型进行限制,底层还是Object类型，这就是泛型类型擦除。

import java.lang.reflect.Field;
import java.util.ArrayList;
public class Demo2<T> {
    public T name;
    public static void main(String[] args) throws NoSuchFieldException, SecurityException {
        // transient Object[] elementData; 
        ArrayList<String> list  =  new ArrayList();
        list.add("");

        Demo2<String> d2 = new Demo2<>();
        d2.name = "aaa";
         //同过反射机制,获取运行时的属性,结果发现,运行时,底层是Object类型             
         Class c =   d2.getClass();//把Demo2对象在内存中的类地址，类信息拿到了   
         Field f =  c.getField("name");
         System.out.println(f.getName()+":::"+f.getType());//name:::class java.lang.Object

    }
}