Java定义和使用含有泛型的类

定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，API中的ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型： 即什么时候确定泛型。

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

举例：

//普通类
public class Student1 {
    private String name;

    public String getName() {
        return name;
    }

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

自定义泛型类

public class Student2<E> {
    private E name;

    public E getName() {
        return name;
    }

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

使用:

public class Demo06Main {
    public static void main(String[] args) {
        Student1 stu = new Student1();//不带泛型
        stu.setName("only String allowed");
        String name = stu.getName();//当没有定义泛型时，这个变量只能由String接收，String是原来定义好的
        System.out.println(name);

        //定义使用泛型的类
        Student2<String> stu2 = new Student2<>();//带有泛型 泛型取String类型
        stu2.setName("String Type");
        String name1 = stu2.getName();// 此时泛型为String类型
        System.out.println(name1);

        Student2<Integer> stu3 = new Student2<>();//带有泛型 泛型取Integer类型
        stu3.setName(266666);
        Integer name2 = stu3.getName();//此时泛型为Integer类型
        System.out.println(name2);

        Student2 stu4 = new Student2();//不写泛型的情况
        stu4.setName("String Type");
        Object name3 = stu4.getName();//不写泛型默认的E就是Object类
       // int length = name3.length(); //不能写，Object类不能调用String类的特有方法

        String s = (String) name3;
        int length = s.length();
        System.out.println(length);
    }
}