题外话：前几天我的笔记本电脑硬盘坏了，本子送到售后进行维修，需要2到3个工作日才能搞定。。现在木有本本用了，无奈就借了女朋友的本子先用着了。。现装的JDK，UltraEdit。。所以下面的图片中编译器的报错信息就变成了中文。。哎，脆弱的硬盘啊。。。
Java在J2SE 5.0后开始增加了泛型(Generics)功能，并且许多API都根据这个新的功能被重新改写了，例如List、Map、Set等与数据结构相关的类。如果我们不想使用泛型功能，也可以用J2SE 1.4或以前的版本的语法来使用这些类，但编译的时候就会出现一些警告。如果对泛型了解不足，那么就会完全不知编译器所云。因此，了解或学会使用泛型是十分必要的。
1、在没有泛型之前
先来看2个类:
IntegetTest :&
class IntegerTest
public void setObj(Integer integer)
this.integer =
public Integer getObj()
BooleanTest :
class BooleanTest
public void setObj(Boolean bool)
this.bool =
public Boolean getObj()
通过观察我们发现，这两个类除了Boolean和Integer这两个关键字不同外，其它的代码都相同。如此相似的类如果我们必须要写两份代码就难免有些冗杂。我们都知道，Object类是所有类的父类，因此用Object类来实现泛型或许是个不错的解决方案。如：
class ObjectTest
public void setObj(Object obj)
this.obj =
public Object getObj()
}于是我们在使用ObjectTest这个类时就需要编写如下代码：
ObjectTest obj = new ObjectTest();
obj.setObj(new Integer(100)); //传递一个Integer对象的引用
//由于getObj()方法返回的是一个Object类型对象的引用，因此需要强制转换为Integer
Integer I = (Integer)obj.getObj();可以看出，如果要使用getObj()方法得到我们想要的对象，那么就必须进行一次强制类型转换才能满足我们的需求。但问题就出在这里。很多时候，我们往往会忘记进行强制转换，这时候编译器就会报错：
因此这就需要开发人员在写代码的时候要额外注意。在没有泛型之前，所有存入List, Map, Set窗口中的实例都会失去其类型信息，当我们要取出数据进行使用时，就必须再手动强制转换回它们原来的类型。如果我们忘记了它们是什么类型的对象，那就费时了。。慢慢拉上去翻前面的代码吧。。。
2、定义泛型类
为了解决传统的泛型设计用Object定义类所带来的种种问题（如类型丢失、程序员忘记了转换类型、必须将其转换为原来的类型才能调用相应的方法），Java在J2SE 5.0之后提出了针对泛型设计的解决方案。
如：下面的代码用泛型类取代了Object :
// 在类名后面，使用&T&来声明一个类型持有者(Holder)
public class Demo&T&
public void setObj(T obj)
this.obj =
public T getObj()
使用泛型定义类时，可以用&T&来声明一个类型持有者(Holder)。然后就可以用 T 这个名称作为类型来声明成员、参数或返回值类型。在声明对象时，用尖括号一并指定泛型类类型持有者T的真正类型。如：
Demo&Integer& obj = new Demo&Integer&();
这样，在调用getObj()方法时，返回的就会是一个我们在尖括号内所指定的Integet对象，而不是Object了，因此也就不必再进行类型转换了：
obj.setObj(new Integer(100));
Integer I = obj.getObj(); //无需强制转换
如果我们使用泛型类声明对象的时候没有为它指定类型，那么编译器默认会使用Object类型。这样的话我们就得又要像之前那样进行类型转换了。
3、几个泛型的小例子
我们可以在定义泛型类时，同时声明多个类型持有者，如：
class Test&T1,T2& //声明了两个Holder
private T1 obj1;
private T2 obj2;
public Test(T1 obj1,T2 obj2)
this.obj1 = obj1;
this.obj2 = obj2;
也可以声明数组，如：
class TestArray&T&
// 声明T类型的数组
private T[]
public TestArray(T[] objs)
this.objs =
}但要注意的是，不允许使用泛型来建立数组的实例，如下面的操作是错误的：
class TestArray&T&
// 声明T类型的数组
private T[] objs = new T[10]; //Error
public TestArray(T[] objs)
this.objs =
了解了以上知识，我们就可以在实际中应用泛型类了。在下一节中我们会介绍Java中泛型的高级语法。
阅读(...) 评论()关于java泛型Public实例用法汇总-java教程-PHP中文网QQ群微信公众号关于java泛型Public实例用法汇总　引言
　　泛型是Java中一个非常重要的知识点，在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计，将会涉及到通配符处理，以及让人苦恼的类型擦除。
　泛型基础
　　泛型类
　　我们首先定义一个简单的Box类：public class Box {
public void set(String object) { this.object = }
public String get()1. 简介：　引言 　　泛型是Java中一个非常重要的知识点，在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计，将会涉及到通配符处理，以及让人苦恼的类型擦除。
　泛型基础 　　泛型类 　　我们首先定义一个简单的Box类：public&class&Box&{&&&&private&n...2. 简介：PHP函数 array_udiff 函数使用中遇到的问题解决&?php//&array_udiff()class&Obj{ private&$code&=&0; public&function&construct($code) {
$this-&code&=&in...3. 简介：泛型是Java中一个非常重要的知识点，在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java泛型的设计，将会涉及到通配符处理，以及让人苦恼的类型擦除。
　泛型基础 　　泛型类 　　我们首先定义一个简单的Box类：public&class&Box&{&&&&private&n...4. 简介：Java调用DOS实现定时关机的实例，需要的朋友可以参考一下代码如下:public&static&void&shutdown(){&&&&&&&&&System.out.print(&请输入多少分钟后关机:&);&&nbs5. 简介：对象的遍历和数组的遍历一样，对象的遍历指的是实例属性的遍历。 　　 下面遍历出来的属性，是在该范围中的“可访问属性”（要考虑访问权限）。&?phpclass&A{&&&&public&$p1&=&1;&&&&&&&&6. 简介：这篇文章主要介绍了C#使用正则表达式抓取网站信息,结合实例形式分析了C#针对网页信息的正则抓取操作相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下本文实例讲述了C#使用正则表达式抓取网站信息的方法。分享给大家供大家参考，具体如下：这里以抓取京东商城商品详情为例。1、创建JdRobber.cs程序类public&class&JdRobber{&&/...7. 简介：Java初始化方法：类、容器初始化类（非final）：Struts2的DefaultActionMapper类中： &&public&DefaultActionMapper()&{&&&&prefixTrie&=&new&PrefixTrie()&{&{&n8. 简介：1.线程池的概念与 Executors 类的应用在jdk1.5之后,我们可以使用 Executors 这个类的静态方法来创建线程池对象//该方法用于创建一个线程池对象,通过指定的参数确定该线程池中有多少个线程对象,该对象实现了ExecutorService接口1.public&static&ExecutorService&newFixedThreadPool(int&...9. 简介：这篇文章主要为大家详细介绍了html中p设计总结,具有一定的参考价值，感兴趣的小伙伴们可以参考一下&!DOCTYPE&html&PUBLIC&&-//W3C//DTD&HTML&4.01&Transitional//EN&&&http://www.w3.org/TR/html4/loose...10. 简介：本篇文章主要介绍了浅谈Java设计模式之开放封闭原则，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧写在前面最近, 接手了一个新业务,系统的架构可圈可点。但有些地方让人望而生畏，有些代码臃肿难以维护，让人不敢恭维。于是，结合了Java的开放封闭原则，对其中一部分代码进行了重构优化。先来看下以前系统的老代码ShareChannelManager.javapublic&nb...【相关问答推荐】：以上就是关于java泛型Public实例用法汇总的详细内容，更多请关注php中文网其它相关文章！共3篇741点赞收藏分享：.&猜你喜欢12345678910
PHP中文网：独家原创，永久免费的在线，php技术学习阵地！
All Rights Reserved | 皖B2-QQ群:关注微信公众号Java中泛型的介绍与简单使用
掌握泛型的产生意义。
掌握泛型的基本使用。
了解泛型的警告信息及泛型的擦除。
泛型是在JDK1.5之后增加的内容，泛型（Generic）
使用泛型的原因
题目分析：
首先要考虑到，必须建立一好一个表示坐标点的类&&Point，此类中有两个属性分别用来表示x坐标和y坐标，但是x和y中所保存的整数类型会有三种（int、float、String），而要想使用一个类型可以同时接收这样的三种类型数据，现在只能使用Object，因为Object类可以接收任何类型的数据，都会自动发生向上转型操作，这样三种数据类型安装以下的方式进行转换：
数字(int) && 自动装箱成Interger && 向上转型使用Object接收
小数(float)&& 自动装箱成Float && 向上转型使用Object接收
字符串(String)&&向上转型使用Object接收
设计Point类
class Point{
// 表示X坐标
// 表示Y坐标
public void setX(Object x){
public void setY(Object y){
public Object getX(){
return this.
public Object getY(){
return this.
public class GenericsDemo01{
public static void main(String args[]){
Point p = new Point() ; // 声明一个Point的对象
p.setX(10) ;
// 利用自动装箱操作：int --& Integer --& Object
p.setY(20) ;
// 利用自动装箱操作：int --& Integer --& Object
int x = (Integer)p.getX() ; // 取出数据先变为Integer，之后自动拆箱
int y = (Integer)p.getY() ; // 取出数据先变为Integer，之后自动拆箱
System.out.println(&整数表示，X坐标为：& + x) ;
System.out.println(&整数表示，Y坐标为：& + y) ;
class Point{
// 表示X坐标
// 表示Y坐标
public void setX(Object x){
public void setY(Object y){
public Object getX(){
return this.
public Object getY(){
return this.
public class GenericsDemo02{
public static void main(String args[]){
Point p = new Point() ; // 声明一个Point的对象
p.setX(10.5f) ;
// 利用自动装箱操作：float --& Float --& Object
p.setY(20.6f) ;
// 利用自动装箱操作：float --& Float --& Object
float x = (Float)p.getX() ; // 取出数据先变为Float，之后自动拆箱
float y = (Float)p.getY() ; // 取出数据先变为Float，之后自动拆箱
System.out.println(&小数表示，X坐标为：& + x) ;
System.out.println(&小数表示，Y坐标为：& + y) ;
字符串表示：
class Point{
// 表示X坐标
// 表示Y坐标
public void setX(Object x){
public void setY(Object y){
public Object getX(){
return this.
public Object getY(){
return this.
public class GenericsDemo03{
public static void main(String args[]){
Point p = new Point() ; // 声明一个Point的对象
p.setX(&东经180度&) ;
// String --& Object
p.setY(&北纬210度&) ;
// String --& Object
String x = (String)p.getX() ; // 取出数据先变为String，之后自动拆箱
String y = (String)p.getY() ; // 取出数据先变为String，之后自动拆箱
System.out.println(&字符串表示，X坐标为：& + x) ;
System.out.println(&字符串表示，Y坐标为：& + y) ;
以上代码存在很大问题，如果现在假设有以下的程序代码。
class Point{
// 表示X坐标
// 表示Y坐标
public void setX(Object x){
public void setY(Object y){
public Object getX(){
return this.
public Object getY(){
return this.
public class GenericsDemo04{
public static void main(String args[]){
Point p = new Point() ; // 声明一个Point的对象
p.setX(10) ;
// 利用自动装箱操作：int --& Integer --& Object
p.setY(&北纬210度&) ;
// String --& Object
int x = (Integer)p.getX() ; // 取出数据先变为Integer，之后自动拆箱
int y = (Integer)p.getY() ; // 取出数据先变为Integer，之后自动拆箱
System.out.println(&整数表示，X坐标为：& + x) ;
System.out.println(&整数表示，Y坐标为：& + y) ;
传统的实现方法就有可能出现操作不当的情况，本程序就是数据类型不统一造成的。
泛型的使用
泛型可以解决数据类型的安全性问题，它主要的原理，是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值以及参数类型。这样在类声明或实例化的时候只要指定好需要的类型即可。
泛型的定义格式如下：
[访问权限] class 类名称&泛型类型1,泛型类型2,......泛型类型3&{
[访问权限] 泛型类型标识 变量名称;
[访问权限] 泛型类型标识 方法名称(){ };
[访问权限] 返回值类型声明 方法名称(泛型类型标识 变量名称){};
泛型对象的定义
类名称&具体类型& 对象名称 = new 类名称&具体类型&();
按照此格式定义一个Point类。
class Point{
// 此处可以随便写标识符号，T是type的简称
private T // var的类型由T指定，即：由外部指定
public T getVar(){ // 返回值的类型由外部决定
public void setVar(T var){ // 设置的类型也由外部决定
this.var =
写完之后，就可以在对象声明的时候使用了。
class Point{
// 此处可以随便写标识符号，T是type的简称
private T // var的类型由T指定，即：由外部指定
public T getVar(){ // 返回值的类型由外部决定
public void setVar(T var){ // 设置的类型也由外部决定
this.var =
public class GenericsDemo06{
public static void main(String args[]){
Point p = new Point() ; // 里面的var类型为String类型
p.setVar(&MLDN&) ;
// 设置字符串
System.out.println(p.getVar().length()) ; // 取得字符串的长度
以上是将var变量设置成了String类型，当然也可以设置成Integer，如果设置的内容与指定的泛型类型不一致，则会在编译时就出现错误。
class Point{
// 此处可以随便写标识符号，T是type的简称
private T // var的类型由T指定，即：由外部指定
public T getVar(){ // 返回值的类型由外部决定
public void setVar(T var){ // 设置的类型也由外部决定
this.var =
public class GenericsDemo07{
public static void main(String args[]){
Point p = new Point() ; // 里面的var类型为String类型
p.setVar(&MLDN&) ;
// 设置字符串
这样可以更好的去保护数据类型。
通过泛型就可以直接去修改之前的程序。
class Point{
// 表示X坐标
// 表示Y坐标
public void setX(T x){
public void setY(T y){
public T getX(){
return this.
public T getY(){
return this.
public class GenericsPoint{
public static void main(String args[]){
Point p = new Point() ;
p.setX(10) ;
// 利用自动装箱操作：int --& Integer
p.setY(20) ;
// 利用自动装箱操作：int --& Integer
int x = p.getX() ; // 自动拆箱
int y = p.getY() ; // 自动拆箱
System.out.println(&整数表示，X坐标为：& + x) ;
System.out.println(&整数表示，Y坐标为：& + y) ;
在这样程序里，减少类类型转换的操作代码，而且更加安全，如果设置的内容不是数字，则在编译的时候就会出现错误，如下所示：
class Point{
// 表示X坐标
// 表示Y坐标
public void setX(T x){
public void setY(T y){
public T getX(){
return this.
public T getY(){
return this.
public class GenericsPoint{
public static void main(String args[]){
Point p = new Point() ;
p.setX(10) ;
// 利用自动装箱操作：int --& Integer
p.setY(&北纬210度&) ;
// 利用自动装箱操作：int --& Integer
int x = p.getX() ; // 自动拆箱
int y = p.getY() ; // 自动拆箱
System.out.println(&整数表示，X坐标为：& + x) ;
System.out.println(&整数表示，Y坐标为：& + y) ;
泛型也可以在构造方法中使用，一般有可能使用构造方法为类中的属性赋值。
构造方法中使用泛型
构造方法可以为类中的属性初始化，那么如果类中的属性通过泛型指定 而又需要通过构造设置属性内容的时候，那么构造方法的定义与之前并无不同，不需要像声明类那样指定泛型。
使用格式：
[访问权限] 构造方法 ([&泛型类型& 参数名称]){ }
class Point{
// 此处可以随便写标识符号，T是type的简称
private T // var的类型由T指定，即：由外部指定
public Point(T var){
// 通过构造方法设置内容
this.var =
public T getVar(){ // 返回值的类型由外部决定
public void setVar(T var){ // 设置的类型也由外部决定
this.var =
public class GenericsDemo08{
public static void main(String args[]){
Point p = new Point(&liuxun&) ; // 里面的var类型为String类型
System.out.println(&内容：& + p.getVar()) ;
在泛型中也可以指定多个泛型。
设置多个泛型，实例如下：
class Notepad{
// 此处指定了两个泛型类型
// 此变量的类型由外部决定
private V // 此变量的类型由外部决定
public K getKey(){
return this.
public V getValue(){
return this.
public void setKey(K key){
this.key =
public void setValue(V value){
this.value =
public class GenericsDemo09{
public static void main(String args[]){
Notepad t =
// 定义两个泛型类型的对象
t = new Notepad() ;
// 里面的key为String，value为Integer
t.setKey(&刘勋&) ;
// 设置第一个内容
t.setValue(22) ;
// 设置第二个内容
System.out.print(&姓名；& + t.getKey()) ;
// 取得信息
System.out.print(&，年龄；& + t.getValue()) ;
// 取得信息
泛型的安全警告
在泛型应用中最好在声明类对象的时候指定好其内部的数据类型，例如&Info& ,但也可以不指定类型。
class Info{
public T getVar(){
return this.
public void setVar(T var){
this.var =
public String toString(){
// 覆写Object类中的toString()方法
return this.var.toString() ;
public class GenericsDemo10{
public static void main(String args[]){
Info i = new Info() ;
// 警告，没有指定泛型类型
i.setVar(&MLDN&) ;
// 设置字符串
System.out.println(&内容：& + i.getVar()) ;
在Info类中并没有指定泛型的类型，则在中为了保证程序依然可以使用，会将T设置成Object类型，这样一来，就可以接收任何的数据类型，也就是说此时var的类型是Object，所有的泛型信息将被擦除，实际上，以上的程序就相当于以下的定义格式：
class Info{
public T getVar(){
return this.
public void setVar(T var){
this.var =
public String toString(){
// 覆写Object类中的toString()方法
return this.var.toString() ;
public class GenericsDemo11{
public static void main(String args[]){
Info i = new Info() ;
// 指定Object为泛型类型
i.setVar(&MLDN&) ;
// 设置字符串
System.out.println(&内容：& + i.getVar()) ;
泛型的安全警告
在泛型应用中最好在声明类的时候指定其内部的数据类型，例如：&Info&,但也可以不指定类型，这样一来用户在使用这样的类的时候就会出现不安全的警告信息，如下图：
1、泛型的产生意义：为了保证数据的安全性。
2、泛型的基本使用，由外部指定的其具体操作类型。