java泛型总结

泛型笔记

Jdk5引入了泛型概念，可以使类型参数化。

定义一个泛型类：

定义一个泛型类，使用这个类的时候，就像使用List接口一样去实例化相应参数的对象就可以。

例如：

public class Fanxing<T> {       //定义一个泛型类

    //定义泛型类时，也可以定义多个类型，例如 Fanxing<T1，T2>

    private T name;     //定义泛型成员变量
    //也可以定义泛型数组     ,但是不能用泛型来建立数组的实例
    private T[] array;


    public T getName() {
        System.out.println(name);
        return name;
    }

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

 

public static void main(String[] args){
    Fanxing<String> f1=new Fanxing<>();
    //将泛型类Fanxing实例化一个String类型的对象
    //此时对象f1的成员变量就成为了String类型，并对String类型的数据进行get/set操作
    f1.setName("sss");
    f1.getName();

    //同样也可以将泛型类Fanxing实例化其他类型的对象，包括基本数据类型和引用数据类型
}

}

 

定义一个泛型方法：

public class FanMethod {
    //此类中定义一个泛型方法
    public static <T>T MethodMiddle(T...ts){            //ts是一个T类型的数组
        return ts[ts.length/2];         //返回数组中间那个元素
    }

    public static void main(String[] args){
       // 调用泛型方法
        String s=MethodMiddle("sss", "xxx", "bbb");
        System.out.println(s);   //输出结果为xxx

        int a=MethodMiddle(1,2,3);
        System.out.println(a);  //输出结果为2
        //证明了泛型方法可以自动识别参数类型
    }
}

 

泛型的其他用法：

1. 定义泛型类时声明多个类型

Class Method1<T1,T2>

Class Method<T1,T2,T3...>

1. 定义泛型数组

public class Fanxing<T> {           //也可以定义泛型数组     ,但是不能用泛型来建立数组的实例
    private T[] array;

}

 

1. 集合类声明容器的元素

public class MapEG<K,V> {
    public Map<K,V> m=new HashMap<>();
    //获得容器中的元素
    public Map<K, V> getM() {
        return m;
    }

    //容器中添加元素
    public void setM(Map<K, V> m) {
        this.m = m;
    }
}

泛型高级用法：

1. 参数类型的限定

如果限制只有特定某些类可以传入T参数，那么可以对T进行限定，

如：只有实现了特定接口的类：<T extends Comparable>，表示的是Comparable及其子类型。

//限定了传入参数的类型，同时也可以访问类型的方法
//也可以指定多个限制类型：:<T,S extends Comparable & Serializable>。
public class LImitClass <T extends List>{

    private T name;

    public T getName() {
        return name;
    }

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

    }

   public static void main(String[] args){
        //实例化一个ArrayList类型的对象对象
       LImitClass<ArrayList> li=new LImitClass<>();             //li是一个泛型类对象
       //此时表明泛型对象li里面只能存Arraylist对象，
       ArrayList<String> list=new ArrayList<>();
       li.setName(list);                //向li中存入一个arraylist对象
       //此时name(泛型类的成员变量)就是一个ArrayList对象
       System.out.println(li.getName());        //输出结果为一个空的Arraylist集合
       li.getName().add("sxx");  //调用ArrayList的add()方法
       li.getName().get(0);
       System.out.println(li.getName().get(0));        //输出结果为sxx
   }
}

泛型的约束和限制

不能使用8个基本类型实例化类型参数

原因在于类型擦除，Object不能存储基本类型：

byte,char,short,int,long,float,double，boolean

从包装类角度来看，或者说三个：
Number(byte,short,int,long,float,double),char,boolean

 

1. 此处主要是包含 ？extends T 和 ？super T两个关键点，我们来通过一段代码说明

public class PersonTest {
    public static void main(String[] args) {
        List<Person> personList=new ArrayList<>();
        List<Student> studentList=new ArrayList<>();
        List<Gril> grilList=new ArrayList<>();
        personList.add(new Person("人类1"));
        studentList.add(new Student("学生1"));
        grilList.add(new Gril("女孩1"));

        //测试赋值
        List<? extends Person> extendsperson1=personList;
        List<? extends Person> extendsperson2=studentList;
        List<? extends Student> extendstudent1=studentList;
        //List<? extends Student> students=personList;  
        //这行代码会编译报错 因为 ？ exdents Student 规定了只能赋值Student或者其的子类

        List<? super Gril> supergril1=grilList;
        List<? super Gril> supergril2=studentList;
        List<? super Gril> supergril3=personList;
        List<? super Student> superstudent1=personList;
        //下面两行会编译报错 因为只能赋值给对应的类或者其父类
        //List<? super Student> superStudent1=grilList;
        //List<? super Person> superPerson1=grilList;

        //测试add方法

        //以下三行都会编译报错，因为为了类型安全，？extends T不允许添加除了null以外的元素
        /*extendstu dent1.add(new Person("111")); 
        extendstudent1.add(new Student("222"));
        extendstudent1.add(new Gril("111"));*/

        //下面第一行会编译时报错 因为此时只能添加student类或者其子类，不允许添加其他类型
        // superstudent1.add(new Person("111"));
        superstudent1.add(new Student("111"));
        superstudent1.add(new Gril("111"));

        Object o =extendstudent1.get(0);
        Person person =extendstudent1.get(0); //只能返回student类或者其父类的对象，子类类型都会被擦除
        //下面这一行会编译报错
        //Gril gril =extendstudent1.get(0);

        Object o1=superstudent1.get(0);
        //只能返回object类型，所以下面两行代码都会编译报错
        /*Person person1=superstudent1.get(0);
        Gril gril1=superstudent1.get(0);*/
    }
}