Java 泛型

不能对加入到集合的数据类型进行约束(不安全)，对集合进行遍历时，需要进行类型转换，数据量过大时影响效率，因此引出泛型

优点：

1.数据装入和取出集合的数据类型很具体，不需要在取出时进行类型转换，提高效率，对数据类型进行约束，解决数据类型安全性问题

2.保证了如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常，同时代码更简洁更健壮

3.可以在类声明时通过一个标识来表示类中某个属性的类型，或者是某个方法返回值的类型，或者是参数类型

E s ;//E 表示 s 的数据类型, 该数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型
E 具体的数据类型在定义 Person 对象的时候指定,即在编译期间，就确定 E 是什么类型

public class fanxing {
    public static void main(String[] args) {
        //具体数据类型要写包装类型
        Person<String, Integer, Character> sic = new Person<String, Integer, Character>("aa",1,'c');
    }
}

class Person<E, V, T>{
    E e;//属性类型
    V v;
    T t;
    //参数类型
    public Person(E e, V v, T t) {
        this.e = e;
        this.v = v;
        this.t = t;
    }
    //函数返回类型
    public V f(){
        return v;
    }
}

 

语法：（任意字母均可，常用T，是Type的缩写）

interface 接口名<T>{}
class 类名<K, V>{}

实例化：

//要在类名后指定类型
List<String > strlist = new ArrayList<String >();

注意事项：

1.指定完类型后，可以传入指定类型的子类型

2.如果不显式的指定类型，则默认给他Object类型

3.可以简写：例如：List<String > Strlist = new ArrayList<>();

自定义泛型：

class Person<E, V, T>{}//这样自定义泛型的类，就是自定义泛型
interface inf<T>{}//或者是自定义的接口

注意细节：

1.普通成员可以使用泛型（属性，方法）

2.使用泛型的数组，不能初始化

T[] ts = new T[18];//是错误的，因为泛型类型没有确定，无法知道要开多少空间
T[] ts;//只能先声明，在后面创建对象在进行初始化

3.静态方法中不能使用类的泛型：同样的静态方法是和类相关的，类加载是仍不能明确泛型的类型，所以jvm无法初始化

4.泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）

5.创建对象时，没有指定类型则默认为Object

6.在接口中，静态成员也不能使用泛型，道理同上，没有指定类型默认Object

7.泛型接口的类型，在继承该接口或者实现该接口时确定

8.泛型方法可以定义在普通类中，也可以定义在泛型类中

public class fanxing {
    public static void main(String[] args) {
        //具体数据类型要写包装类型
        Person person = new Person();
// 普通类的泛型方法
//当调用方法时，传入参数，编译器，就会确定类型
//传入参数的类型不同，确定的泛型类型就不同
        System.out.println(person.kk("AA", 12));
    }
}
class Person{
    //泛型方法可以使用类声明的泛型，也可以使用自己声明泛型
    public<E,T> E kk(E e, T t){
        return e;
    }
}

class Person1<K>{
    //可以使用类声明的泛型
    public<E,T> T kk(K e, T t){
        return t;
    }
}
//泛型方法的基本语法：---一定要有修饰符后面的泛型<T,R,...>才算是泛型方法，否则只能算是使用了泛型的方法
//修饰符<T,R,...> 返回类型 方法名（参数列表）
//注意，使用到泛型的方法并不一定是泛型方法：
class Person1<E>{
    //仅仅是使用了类声明的泛型
    public void kk (E e){
        ;    
    }
}

泛型的继承和通配符：

1.泛型不具备继承性：

List<Object> list = new ArrayList<String>();//是错误的

2.<?>：支持任意泛型类型

//说明: List<?> 表示 任意的泛型类型都可以接受
public static void printCollection1(List<?> c) { 
    for (Object object : c) { 
    // 通配符，取出时，就是 Object 
        System.out.println(object); 
    } 
}

3.<? extends A>:支持A类以及A类的子类，规定了泛型的上限

//? extends 子类类名 AA:支持 AA 类以及 AA 类的子类
public static void printCollection1(List<? extends AA> c) { 
    for (Object object : c) { 
    // 通配符，取出时，就是 Object 
        System.out.println(object); 
    } 
}

4.<? super A>:支持A类以及A类的父类，不限于直接父类，规定了泛型的下限

//? super 子类类名 AA:支持 AA 类以及 AA 类的父类，不限于直接父类，
public static void printCollection1(List<? super AA> c) { 
    for (Object object : c) { 
    // 通配符，取出时，就是 Object 
        System.out.println(object); 
    } 
}