泛型

【泛型】Java中的泛型,泛型类,泛型接口,泛型方法,泛型擦除 这篇文章总结一下Java中的泛型相关知识点,包括:泛型概念、泛型优缺点、泛型通配符、泛型上下界、泛型使用(泛型类、泛型接口、泛型方法)、泛型擦除等内容。 一、泛型概念 (1)什么是泛型 什么是泛型??? 泛型(Generic),是一种参数化数据类型,它允许我们在编写程序代码的时候不用具体指定需要什么数据类型,而是等到具体使用的时候,将数据类型以参数的形式传递给程序,这就是泛型程序设计。 (2)为什么需要泛型 我们来看看下面这个栗子 假设现在有个需求,通过集合保存元素,需要保存String字 阅读详情

1了解泛型

ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语:
整个称为ArrayList<E>泛型类型
ArrayList<E>中的E称为类型变量或类型参数
整个ArrayList<Integer>称为参数化的类型
ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
ArrayList<Integer>中的<>念着typeof
ArrayList称为原始类型




参数化类型与原始类型的兼容性:
参数化类型可以引用一个原始类型的对象,编译报告警告,例如, Collection<String> c = new Vector();//可不可以,不就是编译器一句话的事吗?
原始类型可以引用一个参数化类型的对象,编译报告警告,例如, Collection c = new Vector<String>();//原来的方法接受一个集合参数,新的类型也要能传进去




参数化类型不考虑类型参数的继承关系:
Vector<String> v = new Vector<Object>(); //错误!///不写<Object>没错,写了就是明知故犯
Vector<Object> v = new Vector<String>(); //也错误!




编译器不允许创建泛型变量的数组。即在创建数组实例时,数组的元素不能使用参数化的类型,例如,下面语句有错误:
  Vector<Integer> vectorList[] = new Vector<Integer>[10];






附言:
3. 泛型中的类型参数严格说明集合中装载的数据类型是什么和可以加入什么类型的数据,记住:Collection<String>和Collection<Object>是两个没有转换关系的参数化的类型。
  假设Vector<String> v = new Vector<Object>();可以的话,那么以后从v中取出的对象当作String用,而v实际指向的对象中可以加入任意的类型对象;假设Vector<Object> v = new Vector<String>();可以的话,那么以后可以向v中加入任意的类型对象,而v实际指向的集合中只能装String类型的对象。


2通配符

通配符:
问题:
定义一个方法,该方法用于打印出任意参数化类型的集合中的所有数据,该方法如何定义呢?
错误方式:
public static void printCollection(Collection<Object> cols) {
for(Object obj:cols) {
System.out.println(obj);
}
/* cols.add("string");//没错
cols = new HashSet<Date>();//会报告错误!*/
}
正确方式:
public static void printCollection(Collection<?> cols) {
for(Object obj:cols) {
System.out.println(obj);
}
//cols.add("string");//错误,因为它不知自己未来匹配就一定是String
cols.size();//没错,此方法与类型参数没有关系
cols = new HashSet<Date>();
}
总结:
使用?通配符可以引用其他各种参数化的类型,?通配符定义的变量主要用作引用,可以调用与参数化无关的方法,不能调用与参数化有关的方法。


附言:
/*Cols<Object> 中的Object只是说明Cols<Object> 实例对象中的方法接受的参数是Object
Cols<Object> 是一种具体类型,new HashSet<Date>也是一种具体类型,两者没有兼容性问题。
*/


Collection<?>  a可以与任意参数化的类型匹配,但到底匹配的是什么类型,只有以后才知道,所以,
a=new ArrayList<Integer>和a=new ArrayList<String>都可以, 但a.add(new Date())或a.add(“abc”)都不行,












通配符的扩展:
限定通配符的上边界:
正确:Vector<? extends Number> x = new Vector<Integer>();
错误:Vector<? extends Number> x = new Vector<String>();
限定通配符的下边界:
正确:Vector<? super Integer> x = new Vector<Number>();
错误:Vector<? super Integer> x = new Vector<Byte>();
提示:
限定通配符总是包括自己。
?只能用作引用,不能用它去给其他变量赋值
Vector<? extends Number> y = new Vector<Integer>();
Vector<Number> x = y;
上面的代码错误,原理与Vector<Object > x11 = new Vector<String>();相似,
只能通过强制类型转换方式来赋值。








案例:
能写出下面的代码即代表掌握了Java的泛型集合类:
 HashMap<String,Integer> hm = new HashMap<String,Integer>();
  hm.put("zxx",19);
  hm.put("lis",18);
  
  Set<Map.Entry<String,Integer>> mes= hm.entrySet();
  for(Map.Entry<String,Integer> me : mes) {
   System.out.println(me.getKey() + ":" + me.getValue());
  }
对在jsp页面中也经常要对Set或Map集合进行迭代:
<c:forEach items=“${map}” var=“entry”>
${entry.key}:${entry.value}
</c:forEach>





3定义泛型

Java的泛型方法没有C++模板函数功能强大,java中的如下代码无法通过编译:
<T> T add(T x,T y) {
return (T) (x+y);
//return null;
}
用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前,也就是紧邻返回值之前。按照惯例,类型参数通常用单个大写字母表示。




交换数组中的两个元素的位置的泛型方法语法定义如下:
static <E> void swap(E[] a, int i, int j) {
E t = a[i];
a[i] = a[j];
a[j] = t;
}//或用一个面试题讲:把一个数组中的元素的顺序颠倒一下




只有引用类型才能作为泛型方法的实际参数,swap(new int[3],3,5);语句会报告编译错误。




除了在应用泛型时可以使用extends限定符,在定义泛型时也可以使用extends限定符,例如,Class.getAnnotation()方法的定义。并且可以用&来指定多个边界,如<V extends Serializable & cloneable> void method(){}




普通方法、构造方法和静态方法中都可以使用泛型。




也可以用类型变量表示异常,称为参数化的异常,可以用于方法的throws列表中,但是不能用于catch子句中。




在泛型中可以同时有多个类型参数,在定义它们的尖括号中用逗号分,例如:
public static <K,V> V getValue(K key) { return map.get(key);}








附言:
1.Java中的泛型类型(或者泛型)类似于 C++ 中的模板。但是这种相似性仅限于表面,Java 语言中的泛型基本上完全是在编译器中实现,用于编译器执行类型检查和类型推断,然后生成普通的非泛型的字节码,这种实现技术称为擦除(erasure)(编译器使用泛型类型信息保证类型安全,然后在生成字节码之前将其清除)。这是因为扩展虚拟机指令集来支持泛型被认为是无法接受的,这会为 Java 厂商升级其 JVM 造成难以逾越的障碍。所以,java的泛型采用了可以完全在编译器中实现的擦除方法。 
例如,下面这两个方法,编译器会报告错误,它不认为是两个不同的参数类型,而认为是同一种参数类型。
private static void applyGeneric(Vector<String> v){
}


private static void applyGeneric(Vector<Date> v){
}


2.
测试代码:
String[] strs = new String[]{"a","b","c"};
swap(strs,1,2);
System.out.println(Arrays.asList(strs));


4. 只有引用类型才能作为泛型方法的实际参数,对于add方法,使用基本类型的数据进行测试没有问题,这是因为自动装箱和拆箱了。 swap(new int[3],3.5);语句会报告编译错误,这是因为编译器不会对new int[3]中的int自动拆箱和装箱了,因为new int[3]本身已经是对象了,你想要的有可能就是int数组呢?它装箱岂不弄巧成拙了。


7.用下面的代码说明对异常如何采用泛型:
private static <T extends Exception> sayHello() throws T
{
try{
 
}catch(Exception e){
   throw (T)e;
}
}


8.演示两个泛型参数的例子没有什么实际意义,以后有机会的话,应该换成一个有实际意义的例子。






4类型参数的类型推断

编译器判断范型方法的实际类型参数的过程称为类型推断,类型推断是相对于知觉推断的,其实现方法是一种非常复杂的过程。






根据调用泛型方法时实际传递的参数类型或返回值的类型来推断,具体规则如下:
当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了,那么根据调用方法时该处的实际应用类型来确定,这很容易凭着感觉推断出来,即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型,例如:
swap(new String[3],3,4)--static <E> void swap(E[] a, int i, int j)
当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了,如果调用方法时这多处的实际应用类型都对应同一种类型来确定,这很容易凭着感觉推断出来,例如:
add(3,5)--static <T> T add(T a, T b) 
当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了,如果调用方法时这多处的实际应用类型对应到了不同的类型,且没有使用返回值,这时候取多个参数中的最大交集类型,例如,下面语句实际对应的类型就是Number了,编译没问题,只是运行时出问题:
fill(new Integer[3],3.5f)--static <T> void fill(T[] a, T v) 
当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了,如果调用方法时这多处的实际应用类型对应到了不同的类型, 并且使用返回值,这时候优先考虑返回值的类型,例如,下面语句实际对应的类型就是Integer了,编译将报告错误,将变量x的类型改为float,对比eclipse报告的错误提示,接着再将变量x类型改为Number,则没有了错误:
int x =(3,3.5f)--static <T> T add(T a, T b) 
参数类型的类型推断具有传递性,下面第一种情况推断实际参数类型为Object,编译没有问题,而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型,编译将出现问题:
copy(new Integer[5],new String[5])--static <T> void copy(T[] a,T[]  b);
copy(new Vector<String>(), new Integer[5])--static <T> void copy(Collection<T> a , T[] b);








附言:
对于前面的add方法,下面这两条语句都可以运行:
System.out.println(add(2.0f,3.5));
System.out.println(add(1.5f,"abc"));


集合内容拷贝进数组中时:
copy(new Integer[5],new ArrayList<Integer>());//没问题
copy(new String[5],new ArrayList<Integer>());//有问题





5定义泛型类型

如果类的实例对象中的多处都要用到同一个泛型参数,即这些地方引用的泛型类型要保持同一个实际类型时,这时候就要采用泛型类型的方式进行定义,也就是类级别的泛型,语法格式如下:
public class GenericDao<T> {
private T field1;
public void save(T obj){}
public T getById(int id){}
}






类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的,例如,如下两种方式都可以:
GenericDao<String> dao = null;
new genericDao<String>();




注意:
在对泛型类型进行参数化时,类型参数的实例必须是引用类型,不能是基本类型。
当一个变量被声明为泛型时,只能被实例变量、方法和内部类调用,而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的,所以静态成员不应该有类级别的类型参数。




问题:类中只有一个方法需要使用泛型,是使用类级别的泛型,还是使用方法级别的泛型?






附言:
先不用泛型的方式定义一个PersonDao和一个Person实体对象,写完后,话锋一转,告诉大家一个项目中有很多实体类型和要编写很多Dao,有什么好办法吗?


泛型类:
class GenericDAO<T> {


public  void save(T t) {


}


public void delete(int id) {


}


public  void update(T t) {


}


public T findById(int id)
{
return null;
}


public Set<T> findByConditions(String conditions) {
return null;
}
}


测试代码:
 GenericDAO<ReflectPoint> dao1 = new GenericDAO<ReflectPoint>();
 dao1.save(new ReflectPoint(3,3));
 //dao1.update("abc");
 dao1.update(new ReflectPoint(5,3));
 
 GenericDAO<String> dao2 = new GenericDAO<String>();
 dao2.save("abc");
 //dao2.update(new ReflectPoint(3,3));
 dao2.update("xx");




6泛型的继承
继承时,对泛型父类的类型参数不实例化
代码…
继承时,对泛型父类的类型参数实例化
代码…





7通过反射获得泛型的参数化类型

示例代码:
	Class GenericalReflection {
		  private Vector<Date> dates = new Vector<Date>();
		  public void setDates(Vector<Date> dates) {
		    this.dates = dates;
		  }
		  public static void main(String[] args) {
		   Method methodApply = GenericalReflection.class.getDeclaredMethod("applyGeneric", Vector.class);
		   ParameterizedType pType = (ParameterizedType)
		                    (methodApply .getGenericParameterTypes())[0];
		            System.out.println("setDates("
		                    + ((Class) pType.getRawType()).getName() + "<"
		                    + ((Class) (pType.getActualTypeArguments()[0])).getName()
		                    + ">)" );
		  }
	}



泛型DAO的应用:
public abstract class DaoBaseImpl<T> implements DaoBase<T> {
	protected Class<T> clazz;
	public DaoBaseImpl() {
		Type type = this.getClass().getGenericSuperclass();
		ParameterizedType pt = (ParameterizedType) type;
		this.clazz = (Class) pt.getActualTypeArguments()[0];
		System.out.println("clazz = " + this.clazz);
	}
	}
public class ArticleDaoImpl extends DaoBaseImpl<Article> implements ArticleDao {
	}




备注:
private static void applyGeneric(Vector<String> v){

}
-------------------------------------------------------
Method methodApply = GenericTest.class.getDeclaredMethod("applyGeneric", Vector.class);
Type[] paramTypes = methodApply.getGenericParameterTypes();

ParameterizedType param = (ParameterizedType)(paramTypes[0]);
System.out.println(param.getRawType());
System.out.println(param.getActualTypeArguments()[0]);
System.out.println(((Class)param.getRawType()).getName() + "<" 
+ ((Class)param.getActualTypeArguments()[0]).getName()
+ ">");



我用 AI Agent 全自动跑 COMSOL 仿真:从建模到后处理,踩了 10+ 个深坑 本文探讨了利用AI通过COMSOL Java API实现AI芯片液冷冷板全流程自动化仿真的实践。针对700W高功耗AI芯片的散热需求,构建了包含4颗Chiplet和微通道冷板的三维液冷模型。通过严格设计的Prompt工程,AI Agent成功完成了从几何建模到结果验证的全过程,最终实现了芯片最高温度54°C的良好散热效果。文章重点分享了10个关键问题的解决经验,包括流体连通性验证、网格顺序控制、离散阶数选择、收敛判据优化等,并建立了包含流场/热场/网格独立性的三重验证体系。实践表明,AI可高效处理重复性工作 阅读详情

相关推荐

HEVC/VVC中R-Lambda码率控制算法原理

文章目录1. 比特分配1.1 GOP级比特分配1.2 帧级比特分配1.3 LCU级比特分配2. 码率控制2.1 λ的计算和更新2.2 参数QP的确定 VVC中码率控制算法沿用了HEVC中经典的R-λ码率控制模型,R-λ由中科大的李斌博士提出(详情参考JCTVC-K0103)。R-λ模型的基础为视频编码中 R(比特 bpp)和 D(失真 MSE)之间的双曲线模型,即 D(R)=CR−KD(R) = ...

Aidoneus_y 6138

Java高新技术之泛型

一、泛型的由来 Jdk 1.5以前的集合类中存在什么问题       ArrayList collection = new ArrayList();       collection.add(1);       collection.add(1L);       collection.add("abc");       int i = (Integer) collection.

Coder 812

BurpSuite实战:5分钟搞定DVWA的CSRF漏洞测试(附详细截图)

本文详细介绍了如何使用BurpSuite在DVWA靶场中进行CSRF漏洞测试,包括环境配置、攻击原理剖析、分步攻击演示及企业级防御方案。通过实战案例,帮助读者深入理解CSRF漏洞的危害与防护措施,提升Web应用安全防护能力。

weixin_30879169的博客 495

java选择题(集合,线程等)

1.ArrayList类的底层数据结构是(  ) A、数组结构 B、链表结构 C、哈希表结构 D、红黑树结构   2.LinkedList类的特点是(  ) A、查询快 B、增删快  C、元素不重复 D、元素自然排序   3.Vector类的特点是(  ) A、线程同步 B、线程不同步 C、增删快 D、底层是链表结构   4.关于迭代器说法错误的是() A、...

全场梦游c的博客 3万+

冰河木马实验(V8.4)

简述: 百科词条 冰河木马开发于1999年,跟灰鸽子类似,在设计之初,开发者的本意是编写一个功能强大的远程控制软件。但一经推出,就依靠其强大的功能成为了黑客们发动入侵的工具,并结束了国外木马一统天下的局面,跟后来的灰鸽子等等成为国产木马的标志和代名词。 冰河的服务器端程序为G-server.exe,客户端程序为G-client.exe,默认连接端口为7626。其中攻击者使用G-client.e...

野原新之助 1万+

Matlab使用GitHub的踩坑记录(持续更新)

Matlab使用git的踩坑记录前言Matlab设置Git的官方帮助文档系统配置新建Git两种代码管理方式典型源代码管理SVN分布式源代码管理 Git注意:SVN和Git都可以用GitHub创建新的库 前言 作为Git初学者,对Git的代码版本管理非常非常喜欢,给了我极大的安全感。特别是想到之前的几次Matlab、Latex和python的代码莫名其妙被折腾没了又没法找回的悲剧,决定慢慢的走入gi...

voluntry的博客 7299

下列关于java泛型的说法正确_下列关于泛型的说法不正确的一项是:( )_学小易找答案...

【简答题】请将审计实训任务最终的完成情况拍照上传,注意页面上要有自己的名字。【其它】找出点、线、面、体,不同的立体造型各3种,并注明它们材料、颜色、特点、表达的效果等。制作成PPT。【其它】作业: 1、分组,5人一组,不超过五人。 2、撰写小剧本,确定小组成员分工。 3、拍摄图片 4、上传作业包括:学习委员统计分组情况,标注小组长。 每个组上交剧本和分工文档【其它】(1)收集各种塑料为基本材质,设...

weixin_39638057的博客 2144

Hierarchical-Localization 环境配置与依赖管理全攻略

本文提供了Hierarchical-Localization(hloc)视觉定位工具箱从零开始的环境配置与依赖管理全攻略。针对Windows、Ubuntu和macOS三大操作系统,详细解析了Python版本选择、PyTorch与CUDA版本匹配、pycolmap版本锁定等核心依赖的安装步骤,并汇总了权重文件格式、NumPy版本、路径配置等常见问题的排查与解决方案,旨在帮助用户高效搭建稳定的hloc开发环境。

weixin_29066781的博客 335

java泛型总结2-2 面试题总结

(改编自网络) 1. Java中的泛型是什么 ? 使用泛型的好处是什么?   泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。 好处:   1、类型安全,提供编译期间的类型检测 2、前后兼容 3、泛化代码,代码可以更多的重复利用 4、性能较高,用GJ(泛型JAVA)编写的代码可以为java编译器和虚拟机带来更多...

iteye_6988的博客 329

【保姆级教程】教你如何轻松获取MIMIC数据使用权限

文章非常详细地介绍了MIMIC数据库申请使用的全部步骤。

越努力 越幸运 6603

RK3588S之CPU--benchmark(一)

本章会基于RK3588S来介绍有关CPU常用的benchmark工具及测试过程

文艺小少年的博客 1500

黑马程序员---泛型与泛型的反射

------------- java培训、android培训、java博客、java学习型技术博客、期待与您交流! -------------- 1、HashMap对应泛型的使用 HashMap&lt;String,Integer&gt; maps =new HashMap&lt;String,Integer&gt;(); maps.put("lisi",23); maps.put("...

kuyuyingzi的专栏 182

2026软考中级-软件设计师笔记(送最新视频教程)

核心口诀:运控存输输(运算器、控制器、存储器、输入、输出)例题(2019年上半年):核心公式:数字签名流程:数字证书作用:死锁4个必要条件:死锁判断公式:处理策略:程序设计语言的四大核心成分:顺序表操作(时间复杂度):链表操作(时间复杂度):核心思想:频率高的字符用短编码,频率低的用长编码 → 最小化总编码长度构造步骤(贪心算法):前提:有序表(升序/降序) 步骤:时间复杂度:O(log₂n) 例:查找中核心思想:用哈希函数将关键字映射到存储位置 哈希冲突:不同关键字映射到同一位置 → 用链地址法或开放定址

36万+

C#泛型入门泛型类、泛型集合、泛型方法、泛型约束、泛型委托

泛型集合和ArrayList的装箱拆箱、常见的泛型类型、泛型类和泛型方法、泛型约束、 泛型委托泛型很难理解?不然在接触的一个新的概念的时候,总会感觉难以理解,当你掌握并能熟练地使用的时候,发现这个概念其实简单的,我相信大多数码农都会有这种似曾相识的感觉。可能大多数人刚学习泛型的时候觉得很难理解,当然我也是这样的,所以便写下这篇文章加深一下对泛型的印象。

dotNet全栈开发 4万+

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

一篇带你玩转泛型,泛型详解,什么是泛型,泛型缓存,协变与逆变,泛型方法,为什么使用泛型,泛型接口,ASP.Net泛型,泛型Generic

泛型是C#2.0推出的新语法,不是语法糖,而是2.0由框架升级提供的功能。我们在编写代码时,经常会遇到功能非常相似的模块,只是他们处理的数据不一样(参数类),有没有一种方法用同一个方法来处理传入不同类型的参数呢?泛型就可以解决这个问题。List 就是泛型,带有""括号的都是泛型,List是一个集合,也有可能是一组 泛型集合。泛型的用处是用一个东西来满足不同类型的需求。泛型命名空间。

Sx_Oracle的博客 2387

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

c#泛型使用详解:泛型特点、泛型继承、泛型接口、泛型委托

泛型:通过参数化类型来实现在同一份代码上操作多种数据类型。利用“参数化类型”将类型抽象化,从而实现灵活的复用。在.NET类库中处处都可以看到泛型的身影,尤其是数组和集合中,泛型的存在也大大提高了程序员的开发效率。更重要的是,C#的泛型比C++的模板使用更加安全,并且通过避免装箱和拆箱操作来达到性能提升的目的。因此,我们很有必要掌握并善用这个强大的语言特性。 C#泛型特点: 1、如果实例

zdhlwt2008的博客 1万+

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

Java泛型详解:Java泛型集合、泛型类、泛型方法、泛型的使用

在 Java 1.5 之前没有泛型,通常需要使用强制类型转换的方式将一种数据类型转换为另一种数据类型,这种转换要求开发者对实际参数的类型具有可预知性。对于强制类型转换错误的情况,编译器可能不会提示错误,但是在运行时会出现异常,这是一个安全隐患。 为了解决这一隐患,从 Java 1.5 开始提供了泛型。泛型可以在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高了代码的重用率。本节将详...

jijiangpeng的博客 7487

c#: 泛型接口、泛型方法

泛型可以自定义泛型接口、泛型类、泛型方法、泛型事件、泛型委托。 1>自定义泛型接口 和普通接口一样,一个泛型接口通常也是与某些对象相关的约定规程。泛型接口的声明如下: interface  [接口名] { [接口体] } 在c#中,通过尖括号“。一般来说,声明泛型接口与声明非泛型接口遵循相同的规则。 泛型接口定义完成之后,就要定义此接口的子类。定义泛型接口的子类有以下两种方法。

匆匆那年 1万+

Java泛型——为何要有泛型

对于String类类型来说,它是继承自Object的,而Integer的直接父类是Number,因此会有Integer无法转String的错误。泛型类是在实例化类的时候指明泛型的具体类型,那么泛型方法就是在调用方法时指明泛型的具体类型。在实现传入泛型实参的泛型接口的实现类定义中,实现类即使不声明泛型,也不会编译错误。在实现未传入泛型实参的泛型接口的实现类定义中,实现类要声明泛型,否则会编译错误。为了避免这样可能的错误,引入泛型,使编译器在编译阶段就提示不匹配的类类型。方法返回了一个更加特定的返回类型。

xiaovie的博客 1811

Java泛型的其他应用——泛型接口、泛型方法、泛型数组以及泛型的嵌套设置

学习目标 掌握泛型接口的使用 掌握泛型方法的定义的及使用 掌握泛型数组的使用 掌握泛型的嵌套设置 之前所有的操作都是在类中直接使用泛型操作的,那么,对于Java来说,也可以直接在接口中定义及使用泛型。 定义泛型接口 在JDK1.5之后,不仅仅可以声明泛型类,也可以声明泛型接口,声明泛型接口和声明泛型类的语法类似,也是在接口名称后面加上,如下格式所示: [访问权限]

1万+

java 泛型详解(普通泛型、 通配符、 泛型接口,泛型数组,泛型方法

Java代码Java代码Java代码Java代码Java代码Java代码Java代码。

2401_84619530的博客 1588

Java之泛型,什么是泛型?为什么用泛型?(泛型详解)

1.为什么会有泛型呢? 早期的Object类型可以接受任意的对象类型,但是在实际使用中,会有类型转化的问题,存在隐患,所以Java提供泛型解决这个安全问题 2.什么是泛型? 泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类...

围巢 4050

java泛型——泛型类、泛型方法、泛型接口

泛型Java 泛型Java 泛型是什么泛型类泛型类的格式泛型类举例泛型方法泛型方法的格式泛型方法举例泛型接口泛型接口的格式泛型接口举例 Java 泛型 Java 泛型是什么 官方定义: 泛型是Java SE 1.5的新特性,泛型的本质就是参数化类型,也就是说所操作的数据类型被指定为一个参数 这种参数类型可以用在类、接口和方法的创建中,分别成为泛型类、泛型接口、泛型方法 优缺点: ​ 优点:可以不用再类型转换了 ​ 缺点:降低了代码的可读性 泛型类 泛型类:当一个类要操作的引用数据类型不确定的时候,可

一个小小的码农 6635

C#入门级——泛型、泛型类、泛型接口、泛型方法和泛型委托

C#入门级——泛型、泛型类、泛型接口、泛型方法和泛型委托

dlwlrma_516的博客 5098

泛型、泛型擦除、泛型通配符

1、泛型定义        将对象的类型作为参数,指定到其他类或方法上,从而保证类型转换的安全性和稳定性,这就是泛型。泛型的本质是参数化类型,也就是把所操作的数据类型指定一个参数,使代码可以用于多种类型。        泛型是JDK1.5的新特性,Java语言...

xingze的博客 1880

Java泛型(泛型类、泛型方法、泛型接口)

目录标题泛型引入1. 泛型类特点2. 最简单泛型类3. 泛型方法4. 泛型接口5. 泛型类可是同时设置多个类型参数6. 泛型的类型参数可以是泛型类7. 泛型类可以继承泛型类8. 泛型类可以实现泛型接口 泛型引入 如果我们需要产生多个对象,每个对象的逻辑完全一样,只是对象内的成员变量的类型不同,那我们如何去做? 此时,我们就引入了泛型。 泛型:让数据类型变得参数化。定义泛型时,对应的数据类型是不确定的。泛型方法被调用时,才指定具体类型 这样就解决了多个相似的类(方法、接口 )创建的问题,一个泛型类即可代替所

one goto one 的博客 4454
上一篇: 散列与散列码
下一篇: 第2章 Java内存区域与内存溢出异常--《深入理解 Java 虚拟机》笔记
partner4java
博客等级 码龄17年 481粉丝 183原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值