一起来学习Java的泛型

泛型：

什么是泛型？

泛型是在java 1.5引入的的新特性，本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

简而言之：<>泛型就是用来约束类、方法、属性上的数据类型，比如

list<integer> list = new arraylist<integer>();list<integer> list = new arraylist<integer>();

new arraylist这个集合的元素只能添加integer类型。

为什么需要泛型？

java推出泛型之前，程序员可以构建一个object类型的集合，该集合能够存储任何的数据类型，而在使用该 集合的时候，需要程序员明确知道每个元素的具体的类型并向下转型，否则容易引发classcastexception类转换异常。现在我们通过泛型就能解决这个问题，通过泛型<>我们就能够约束这个集合插入的类型，就不需要再从object类型转换成子类类型。

泛型有什么好处？

类型安全，不会插入指定类型以外的数据消除了强制类型转换

泛型的类型：

泛型可以定义在类上、父类上、接口上、子类上、方法上、参数上、属性上， 泛型类型是可以用任意字母来代替你需要传递的数据，一般为了可读性，我们约定一般会写：

e -element 代码集合中存放的元素t -type表示类型java类k -key 表示键v -v 表示valuen -number 表示数值类型？ 表示不确定的类型

那么这么多字母有什么用呢？我们来看一段代码：这是一个普通的student类：

package test;public class student {    private string name; 伤感qq昵称   private int age;    public string getname() {        return name;    }    public void tname(string name) {        this.name = name;    }    public int getage() {        return age;    }    public void tage(int age) {        this.age = age;    }}

我们升级一下，把这个类定为string的泛型，意思是这个类只能接收string的类型：

public class student<stirng> {   //重复的代码就不重写了，和上面的是一样}

ok，这样没问题，但是我们想一想，如果直接就把这个类的泛型定义死了，如果后面需要在student传入integer类型，我们就得重写一个student类，这样代码的复用性不高，不符合编程思维，所以我们可以这样：

public class student<t> {        private t t;        public t gett() {return t;}        public void tt(t t) {this.t = t;}    }

然后当需要用什么泛型的时候直接传入即可：

student<string> stu1 = new student<>();student<integer> stu2 = new student<>();student<double> stu3 = new student<>();

测试：（接上面的代码）

public class test {    public static void main(string[] args) {        //先使用integer泛型，传入100        student<integer> stu1 = new student<>(100);        integer in = stu1.gett();        system.out.println(in);    }}

输出：100 （没问题）

但是如果在定义为integer下输入string类型，会怎么样？

很明显，直接就报错了

这样就更好的利用了代码的复用性。上面部分的知识点也就是泛型类。

泛型父类和子类：

我们先定义一个泛型父类：（）

public class student<t> {        private t t;        public t gett() {return t;}        public void tt(t t) {this.t = t;}    }

然后定义一个子类，继承该student父类：

public class child<t> extends student<t>{    @override    public t gett(){        return super.gett();    }    @override    public void tt(t t){        super.tt(t);    }}

特别需要注意：

1.泛型子类的参数一定要和父类的参数类型一致

2.如果子类没有添加泛型，那么父类的参数类型必须明确

也就是这样：

public class child extends student<integer>{}

测试：下面代码的解释：在父类student内定义泛型为string，然后创建子类child的对象child，因为是继承关系，所有child的泛型也是string，

public class test {    public static void main(string[] args) {        student<string> child = new child<评课评语大全>();  //多态        child.tt("abc");        string value = child.gett();        system.out.println(value);    }}

当子类传入非string类型值时：

泛型接口：

泛型接口其实也很简单，定义如下：

public interface usb<t> {   }

泛型子类实现泛型接口，除了处理标识父类的泛型标识外，还可以继续扩展泛型：

public class phone<t,v> implements usb<t>{  //这里的意思是子类除了有usb接口的泛型t类，也可以再扩展一个泛型    private t color; //手机颜色    private v phonename;  //手机名称    public phone(t color,v phonename) {        this.color = color;        this.phonename = phonename;    }    public t getcolor() {        return color;    }    public void tcolor(t color) {        this.color = color;    }    public v getphonename() {        return phonename;    }    public void tphonename(v phonename) {        this.phonename = phonename;    }}

注意：泛型接口也和泛型父子类一样，如果子类没有添加泛型参数，那么父类一定要明确的指定类型！

public class phone implements usb<string>{}

测试：

分别把t和v的泛型都定义为string：

public class test {    public static void main(string[] args) {        phone<string,string> ph = new phone<>("黑色","华为");        string str1 = ph.getcolor();        string str2 = ph.getphonename();        system.out.println(str1+str2);    }}

泛型方法：

定义泛型方法：在public和返回值之间定义<>的才是泛型方法：

    public<e> void printtype(){    }

然而这个方法的返回值类型就是取决于e的类型，如果e是integer，那么这个方法的返回值类型就是整数。用法基本和上述的一致，需要什么类型的返回值，在调用的时候去传递泛型类型即可。

通配符：

通配符一般是使用?代替具体的类型实参（此处是类型实参，而不是类型形参）。当操作类型时不需要使用类型的具体功能时，只使用object类中的功能，那么可以用?通配符来表未知类型。例如 list<?> 在逻辑上是list、list 、list等所有list<具体类型实参>的父类。

有界的类型参数:

有的时候需要限制那些被允许传递到一个类型参数的类型种类范围，例如一个操作数字的方法可能只希望接受number或者number子类的实例。这时就需要为泛型添加上边界，即传入的类型实参必须是指定类型的子类型。要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends或super关键字，最后紧跟它的上界或下界。由此可以知道泛型的上下边界的添加必须与泛型的声明在一起 。

上限：<? extends t>：

表示该通配符所代表的类型是t类型的子类。 例如往集合中添加元素时，既可以添加t类型对象，又可以添加t的子类型对象。

下限：<? super t>：

表示该通配符所代表的类型是t类型的父类，就是只能获取到t类及以上的泛型，任何继承t类的泛型将得不到。

举例说明：

建一个动物的父类：

public class animal {}

建一个猫类，继承父类：

public class cat extends animal{}

建一个小猫类，继承猫类：

public class minicat extends cat{}

现在的关系是animal>cat>minicat

通配符上限的测试类：

public class test {    public static void main(string[] args) {        arraylist<animal> animals = new arraylist<>();        arraylist<cat> cats = new张碧晨张艺兴 arraylist<>();        arraylist<minicat> minicats = new arraylist<>();        showanimals(cats);        showanimals(minicats);        //这样会报错，因为在showanimals方法内的通配符最高继承自cat        showanimals(animals);    }    //使用通配符，把上线限制到cat，意思是animal这个类不能被获取    private static void showanimals(arraylist<? extends cat> cats) {      电容能量  for (cat cat:cats             ) {            system.out.println(cat);        }    }}

可以看到使用通配符限制到cat类后，animals这个类就已经获取不到了。这就是上限。

如果把上限设置成animal的时候：

通配符下限的测试类：（其他代码与上面的一致）

public class test {    public static void main(string[] args) {        arraylist<animal> animals = new arraylist<>();        arraylist<cat> cats = new arraylist<>();        arraylist<minicat> minicats = new arraylist<>();        showanimals(cats);        showanimals(minicats);        //这样会报错，因为在showanimals方法内的通配符最高继承自cat        showanimals(animals);    }    //使用通配符，把上线限制到cat，意思是animal这个类不能被获取    private static void showanimals(arraylist<? extends cat> cats) {        for (cat cat:cats             ) {            system.out.println(cat);        }    }}

因为通配符设置了下限到cat类，所以minicat是获取不到的：

总结

以上就是关于泛型和通配符的介绍，泛型可以在类、接口、方法中使用，分别简称之泛型类、泛型接口、泛型方法，并且通过泛型实现数据类型的任意化，即灵活、又有安全性，易于维护。在编译过中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到小时代观后感运行时阶段。

总而言之，泛型是在编译的时候检查类型安全，所有的强制转换都是自动和隐式的，提高代码的重用率。并且消除强制类型转换，在传入参数的时候就已经限制的类型。

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注www.887551.com的更多内容!