泛型的概念
泛型就是参数化类型。定义一个带参数的方法时有形参，调用这个方法的时候要传入实参。而所谓参数化类型就是这个形参的类型，将原来定义好的参数类型参数化，然后在使用的时候传入具体的类型。
泛型的作用
主要是限定参数类型，以防止后续调用出现错误，例如：
List不指定泛型时默认是object类，下面这个例子转化为Integer计算时就会报错。
public static void main(String [] args) throws Exception{
List list = new ArrayList();
list.add("lll");
list.add(123);
int a = (Integer) list.get(0) + (Integer) list.get(1);
System.out.print(a);
}
自定义泛型
有时我们需要对一些对象类型进行额外的逻辑操作，但是这些对象类型未定，这个时候使用自定义泛型是个不错的办法。
下面这个例子就是对Tag类中的data进行了额外的操作，data既可以是Integer,也可以是Boolean。
public static void main(String [] args) throws Exception{
Tag<Integer> integerTag = new Tag<Integer>(4,"数量是4");
System.out.println(integerTag.getDescription());
Tag<Boolean> booleanTag = new Tag<>(false,"这个标签目前是");
System.out.println(booleanTag.getDescription());
}
static class Tag<T>{
private T data;
private String description;
public Tag(){}
public Tag(T data,String description) {
this.description = description;
this.data = data;
}
public Tag(T data) {
this.data = data;
}
public T getData(){
return data;
}
public String getDescription(){
return description+data.toString();
}
}
这里要注意一点，就是Tag指定泛型后，仅仅只是限定了Tag内的数据类型，而对于Tag而言它的类型并没有什么变化，可以看下面的例子
public static void main(String[] args) {
Tag<String> name = new Tag<String>("corn");
Tag<Integer> age = new Tag<Integer>(712);
System.out.println("name class:" + name.getClass()); // com.xiaow.Tag
System.out.println("age class:" + age.getClass()); // com.xiaow.Tag
System.out.println(name.getClass() == age.getClass()); // true
}
现在我们已经知道了Tag<String>和Tag<Integer>是同一种类型，现在需要继续探讨一个问题，那么在逻辑上，类似于Tag<Number>和Tag<Integer>是否可以看成具有父子关系的泛型类型呢？看下面例子
public static void main(String [] args) throws Exception{
Tag<Integer> integerTag = new Tag<Integer>(4,"数量是4");
System.out.println(integerTag.getDescription());
Tag<Boolean> booleanTag = new Tag<>(false,"这个标签目前是");
System.out.println(booleanTag.getDescription());
Tag<Number> numberTag = new Tag<>(11);
printData(numberTag);//1
printData(integerTag);//2
}
public static void printData(Tag<Number> data) {
System.out.println(data.getData());
}
这里ide会告诉我们2处出现编译错误printData，错误提示为
(com.xiaow.learn.Annotion.Test.Tag<java.lang.Number>)
in Test cannot be applied
to
(com.xiaow.learn.Annotion.Test.Tag<java.lang.Integer>)
这表明了Tag<Number>和Tag<Integer>不能看做为具有父子关系的泛型类型。但是如果我们有需求是需要能使用父子关系的泛型呢？这里就需要使用类型通配符了，看下面例子：
首先我们可以使用类型通配符在printData方法里
public static void main(String [] args) throws Exception{
Tag<Integer> integerTag = new Tag<Integer>(4,"数量是4");
Tag<Number> numberTag = new Tag<>(11);
printData(numberTag);//1
printData(integerTag);//2
}
public static void printData(Tag<? extends Number> data) {
System.out.println(data.getData());
}
这样就不会出现编译错误了，如果我们要限定Tag内的data只能是某一类的对象呢，我们可以这样做，首先让这一类的对象都实现某个接口，然后定义Tag的泛型都要extends这个接口，如下例子
public static void main(String [] args) throws Exception{
Tag<Note> numberTag = new Tag<>(new Note("hh"));
Tag<Article> articleTag = new Tag<>(new Article(22));
}
static class Tag<T extends AppDo>{
private T data;
private String description;
public Tag(){}
public Tag(T data,String description) {
this.description = description;
this.data = data;
}
public Tag(T data) {
this.data = data;
}
public T getData(){
return data;
}
public String getDescription(){
return description+data.toString();
}
}
//接口
public interface AppDo extends Serializable {
}
//两个实现类
public class Article implements AppDo {
private Integer count;
public Integer getCount() {
return count;
}
public void setCount(Integer count) {
this.count = count;
}
public Article(Integer count) {
this.count = count;
}
public Article() {
}
}
public class Note implements AppDo {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Note(String name) {
this.name = name;
}
public Note() {
}
}
