1. java 泛型详解(普通泛型、 通配符、 泛型接口)
  2.  
  3. 2013-02-04 19:49:49| 分类: JAVA | 标签:java |举报|字号 订阅
  4.  
  5. 下载LOFTER客户端
  6. JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0。这说明Java已经有大幅度的变化。本文将讲解JDK5.0支持的新功能-----Java的泛型.
  7.  
  8. 1Java泛型
  9.  
  10. 其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样,方法是这样的method(String str1,String str2 ),方法中参数str1str2的值是可变的。而泛型也是一样的,这样写class Java_GenericsK,V>,这里边的KV就象方法中的参数str1str2,也是可变。
  11.  
  12. 编写泛型类要注意:
  13.  
  14. 1) 在定义一个泛型类的时候,在 “<>”之间定义形式类型参数,例如:“class TestGenK,V>”,其中“K , V”不代表值,而是表示类型。
  15.  
  16. 2) 实例化泛型对象的时候,一定要在类名后面指定类型参数的值(类型),一共要有两次书写。例如:
  17.  
  18. TestGenString,String t=new TestGenString,String>();
  19.  
  20. 3) 泛型中<K extends Object>,extends并不代表继承,它是类型范围限制。
  21.  
  22. 普通泛型
  23. Java代码
  24. class Point<T>{ // 此处可以随便写标识符号,T是type的简称
  25. private T var ; // var的类型由T指定,即:由外部指定
  26. public T getVar(){ // 返回值的类型由外部决定
  27. return var ;
  28. }
  29. public void setVar(T var){ // 设置的类型也由外部决定
  30. this.var = var ;
  31. }
  32. };
  33. public class GenericsDemo06{
  34. public static void main(String args[]){
  35. Point<String> p = new Point<String>() ; // 里面的var类型为String类型
  36. p.setVar("it") ; // 设置字符串
  37. System.out.println(p.getVar().length()) ; // 取得字符串的长度
  38. }
  39. };
  40. ----------------------------------------------------------
  41. class Notepad<K,V>{ // 此处指定了两个泛型类型
  42. private K key ; // 此变量的类型由外部决定
  43. private V value ; // 此变量的类型由外部决定
  44. public K getKey(){
  45. return this.key ;
  46. }
  47. public V getValue(){
  48. return this.value ;
  49. }
  50. public void setKey(K key){
  51. this.key = key ;
  52. }
  53. public void setValue(V value){
  54. this.value = value ;
  55. }
  56. };
  57. public class GenericsDemo09{
  58. public static void main(String args[]){
  59. Notepad<String,Integer> t = null ; // 定义两个泛型类型的对象
  60. t = new Notepad<String,Integer>() ; // 里面的key为String,value为Integer
  61. t.setKey("汤姆") ; // 设置第一个内容
  62. t.setValue(20) ; // 设置第二个内容
  63. System.out.print("姓名;" + t.getKey()) ; // 取得信息
  64. System.out.print(",年龄;" + t.getValue()) ; // 取得信息
  65.  
  66. }
  67. };
  68. 通配符
  69. Java代码
  70. class Info<T>{
  71. private T var ; // 定义泛型变量
  72. public void setVar(T var){
  73. this.var = var ;
  74. }
  75. public T getVar(){
  76. return this.var ;
  77. }
  78. public String toString(){ // 直接打印
  79. return this.var.toString() ;
  80. }
  81. };
  82. public class GenericsDemo14{
  83. public static void main(String args[]){
  84. Info<String> i = new Info<String>() ; // 使用String为泛型类型
  85. i.setVar("it") ; // 设置内容
  86. fun(i) ;
  87. }
  88. public static void fun(Info<?> temp){ // 可以接收任意的泛型对象
  89. System.out.println("内容:" + temp) ;
  90. }
  91. };
  92. 受限泛型
  93. Java代码
  94. class Info<T>{
  95. private T var ; // 定义泛型变量
  96. public void setVar(T var){
  97. this.var = var ;
  98. }
  99. public T getVar(){
  100. return this.var ;
  101. }
  102. public String toString(){ // 直接打印
  103. return this.var.toString() ;
  104. }
  105. };
  106. public class GenericsDemo17{
  107. public static void main(String args[]){
  108. Info<Integer> i1 = new Info<Integer>() ; // 声明Integer的泛型对象
  109. Info<Float> i2 = new Info<Float>() ; // 声明Float的泛型对象
  110. i1.setVar(30) ; // 设置整数,自动装箱
  111. i2.setVar(30.1f) ; // 设置小数,自动装箱
  112. fun(i1) ;
  113. fun(i2) ;
  114. }
  115. public static void fun(Info<? extends Number> temp){ // 只能接收Number及其Number的子类
  116. System.out.print(temp + "、") ;
  117. }
  118. };
  119. ----------------------------------------------------------
  120. class Info<T>{
  121. private T var ; // 定义泛型变量
  122. public void setVar(T var){
  123. this.var = var ;
  124. }
  125. public T getVar(){
  126. return this.var ;
  127. }
  128. public String toString(){ // 直接打印
  129. return this.var.toString() ;
  130. }
  131. };
  132. public class GenericsDemo21{
  133. public static void main(String args[]){
  134. Info<String> i1 = new Info<String>() ; // 声明String的泛型对象
  135. Info<Object> i2 = new Info<Object>() ; // 声明Object的泛型对象
  136. i1.setVar("hello") ;
  137. i2.setVar(new Object()) ;
  138. fun(i1) ;
  139. fun(i2) ;
  140. }
  141. public static void fun(Info<? super String> temp){ // 只能接收String或Object类型的泛型
  142. System.out.print(temp + "、") ;
  143. }
  144. };
  145. 泛型无法向上转型
  146. Java代码
  147. class Info<T>{
  148. private T var ; // 定义泛型变量
  149. public void setVar(T var){
  150. this.var = var ;
  151. }
  152. public T getVar(){
  153. return this.var ;
  154. }
  155. public String toString(){ // 直接打印
  156. return this.var.toString() ;
  157. }
  158. };
  159. public class GenericsDemo23{
  160. public static void main(String args[]){
  161. Info<String> i1 = new Info<String>() ; // 泛型类型为String
  162. Info<Object> i2 = null ;
  163. i2 = i1 ; //这句会出错 incompatible types
  164. }
  165. };
  166. 泛型接口
  167. Java代码
  168. interface Info<T>{ // 在接口上定义泛型
  169. public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型
  170. }
  171. class InfoImpl<T> implements Info<T>{ // 定义泛型接口的子类
  172. private T var ; // 定义属性
  173. public InfoImpl(T var){ // 通过构造方法设置属性内容
  174. this.setVar(var) ;
  175. }
  176. public void setVar(T var){
  177. this.var = var ;
  178. }
  179. public T getVar(){
  180. return this.var ;
  181. }
  182. };
  183. public class GenericsDemo24{
  184. public static void main(String arsg[]){
  185. Info<String> i = null; // 声明接口对象
  186. i = new InfoImpl<String>("汤姆") ; // 通过子类实例化对象
  187. System.out.println("内容:" + i.getVar()) ;
  188. }
  189. };
  190. ----------------------------------------------------------
  191. interface Info<T>{ // 在接口上定义泛型
  192. public T getVar() ; // 定义抽象方法,抽象方法的返回值就是泛型类型
  193. }
  194. class InfoImpl implements Info<String>{ // 定义泛型接口的子类
  195. private String var ; // 定义属性
  196. public InfoImpl(String var){ // 通过构造方法设置属性内容
  197. this.setVar(var) ;
  198. }
  199. public void setVar(String var){
  200. this.var = var ;
  201. }
  202. public String getVar(){
  203. return this.var ;
  204. }
  205. };
  206. public class GenericsDemo25{
  207. public static void main(String arsg[]){
  208. Info i = null; // 声明接口对象
  209. i = new InfoImpl("汤姆") ; // 通过子类实例化对象
  210. System.out.println("内容:" + i.getVar()) ;
  211. }
  212. };
  213. 泛型方法
  214. Java代码
  215. class Demo{
  216. public <T> T fun(T t){ // 可以接收任意类型的数据
  217. return t ; // 直接把参数返回
  218. }
  219. };
  220. public class GenericsDemo26{
  221. public static void main(String args[]){
  222. Demo d = new Demo() ; // 实例化Demo对象
  223. String str = d.fun("汤姆") ; // 传递字符串
  224. int i = d.fun(30) ; // 传递数字,自动装箱
  225. System.out.println(str) ; // 输出内容
  226. System.out.println(i) ; // 输出内容
  227. }
  228. };
  229. 通过泛型方法返回泛型类型实例
  230. Java代码
  231. class Info<T extends Number>{ // 指定上限,只能是数字类型
  232. private T var ; // 此类型由外部决定
  233. public T getVar(){
  234. return this.var ;
  235. }
  236. public void setVar(T var){
  237. this.var = var ;
  238. }
  239. public String toString(){ // 覆写Object类中的toString()方法
  240. return this.var.toString() ;
  241. }
  242. };
  243. public class GenericsDemo27{
  244. public static void main(String args[]){
  245. Info<Integer> i = fun(30) ;
  246. System.out.println(i.getVar()) ;
  247. }
  248. public static <T extends Number> Info<T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定
  249. Info<T> temp = new Info<T>() ; // 根据传入的数据类型实例化Info
  250. temp.setVar(param) ; // 将传递的内容设置到Info对象的var属性之中
  251. return temp ; // 返回实例化对象
  252. }
  253. };
  254. 使用泛型统一传入的参数类型
  255. Java代码
  256. class Info<T>{ // 指定上限,只能是数字类型
  257. private T var ; // 此类型由外部决定
  258. public T getVar(){
  259. return this.var ;
  260. }
  261. public void setVar(T var){
  262. this.var = var ;
  263. }
  264. public String toString(){ // 覆写Object类中的toString()方法
  265. return this.var.toString() ;
  266. }
  267. };
  268. public class GenericsDemo28{
  269. public static void main(String args[]){
  270. Info<String> i1 = new Info<String>() ;
  271. Info<String> i2 = new Info<String>() ;
  272. i1.setVar("HELLO") ; // 设置内容
  273. i2.setVar("汤姆") ; // 设置内容
  274. add(i1,i2) ;
  275. }
  276. public static <T> void add(Info<T> i1,Info<T> i2){
  277. System.out.println(i1.getVar() + " " + i2.getVar()) ;
  278. }
  279. };
  280. 泛型数组
  281. Java代码
  282. public class GenericsDemo30{
  283. public static void main(String args[]){
  284. Integer i[] = fun1(1,2,3,4,5,6) ; // 返回泛型数组
  285. fun2(i) ;
  286. }
  287. public static <T> T[] fun1(T...arg){ // 接收可变参数
  288. return arg ; // 返回泛型数组
  289. }
  290. public static <T> void fun2(T param[]){ // 输出
  291. System.out.print("接收泛型数组:") ;
  292. for(T t:param){
  293. System.out.print(t + "、") ;
  294. }
  295. }
  296. };
  297. 泛型的嵌套设置
  298. Java代码
  299. class Info<T,V>{ // 接收两个泛型类型
  300. private T var ;
  301. private V value ;
  302. public Info(T var,V value){
  303. this.setVar(var) ;
  304. this.setValue(value) ;
  305. }
  306. public void setVar(T var){
  307. this.var = var ;
  308. }
  309. public void setValue(V value){
  310. this.value = value ;
  311. }
  312. public T getVar(){
  313. return this.var ;
  314. }
  315. public V getValue(){
  316. return this.value ;
  317. }
  318. };
  319. class Demo<S>{
  320. private S info ;
  321. public Demo(S info){
  322. this.setInfo(info) ;
  323. }
  324. public void setInfo(S info){
  325. this.info = info ;
  326. }
  327. public S getInfo(){
  328. return this.info ;
  329. }
  330. };
  331. public class GenericsDemo31{
  332. public static void main(String args[]){
  333. Demo<Info<String,Integer>> d = null ; // 将Info作为Demo的泛型类型
  334. Info<String,Integer> i = null ; // Info指定两个泛型类型
  335. i = new Info<String,Integer>("汤姆",30) ; // 实例化Info对象
  336. d = new Demo<Info<String,Integer>>(i) ; // 在Demo类中设置Info类的对象
  337. System.out.println("内容一:" + d.getInfo().getVar()) ;
  338. System.out.println("内容二:" + d.getInfo().getValue()) ;
  339. }
  340. };

java 泛型实例详解(普通泛型、 通配符、 泛型接口)的更多相关文章

  1. C#泛型实例详解

    本文以实例形式讲述了C#泛型的用法,有助于读者深入理解C#泛型的原理,具体分析如下: 首先需要明白什么时候使用泛型: 当针对不同的数据类型,采用相似的逻辑算法,为了避免重复,可以考虑使用泛型. 一.针 ...

  2. Java正则表达式实例详解

    创建正则表达式 你可以从比较简单的东西入手学习正则表达式.要想全面地掌握怎样构建正则表达式,可以去看JDK 文档的java.util.regex 的Pattern 类的文档. 字符 B 字符B \xh ...

  3. Java中JSON字符串与java对象的互换实例详解

    这篇文章主要介绍了在java中,JSON字符串与java对象的相互转换实例详解,非常不错,具有参考借鉴价值,需要的朋友可以参考下 在开发过程中,经常需要和别的系统交换数据,数据交换的格式有XML.JS ...

  4. 我的书籍《深入解析Java编译器:源码剖析与实例详解》就要出版了

    一个十足的技术迷,2013年毕业,做过ERP.游戏.计算广告,在大公司呆过,但终究不满足仅对技术的应用,在2018年末离开了公司,全职写了一本书<深入解析Java编译器:源码剖析与实例详解> ...

  5. Java中JSON字符串与java对象的互换实例详解(转)

    http://www.jb51.net/article/90914.htm 在开发过程中,经常需要和别的系统交换数据,数据交换的格式有XML.JSON等,JSON作为一个轻量级的数据格式比xml效率要 ...

  6. 详解C#泛型(二) 获取C#中方法的执行时间及其代码注入 详解C#泛型(一) 详解C#委托和事件(二) 详解C#特性和反射(四) 记一次.net core调用SOAP接口遇到的问题 C# WebRequest.Create 锚点“#”字符问题 根据内容来产生一个二维码

    详解C#泛型(二)   一.自定义泛型方法(Generic Method),将类型参数用作参数列表或返回值的类型: void MyFunc<T>() //声明具有一个类型参数的泛型方法 { ...

  7. 详解C#泛型(三)

    一.前面两篇文章分别介绍了定义泛型类型.泛型委托.泛型接口以及声明泛型方法: 详解C#泛型(一) 详解C#泛型(二) 首先回顾下如何构建泛型类: public class MyClass<T&g ...

  8. java中List的用法和实例详解

    java中List的用法和实例详解 List的用法List包括List接口以及List接口的所有实现类.因为List接口实现了Collection接口,所以List接口拥有Collection接口提供 ...

  9. 事件驱动模型实例详解(Java篇)

    或许每个软件从业者都有从学习控制台应用程序到学习可视化编程的转变过程,控制台应用程序的优点在于可以方便的练习某个语言的语法和开发习惯(如.net和java),而可视化编程的学习又可以非常方便开发出各类 ...

随机推荐

  1. 关于MySQL数据库事务的机制学习总结

    这几天面试多次被问到了数据库事务机制.隔离级别.乐观锁悲观锁类的问题,之前对这些只能说有所了解,有些概念还停留在记忆层面,没有理解,所以回答的不好.后面翻书学习了下,理解了一些东西,在此做一个记录. ...

  2. 在eclipse里面给maven项目打包

    eclipse中的“maven install”是用maven打包工程的意思. mvn install 是将用户打包好的jar包安装到本地仓库中,一般没有设置过的话默认在用户目录下的 .m2\下面. ...

  3. 洛谷 P3909 异或之积 题解

    原题链接 本人看了其它解法,发现本人的解法还是 首创 ! 而且我的解法好像和 \(\times 6\) 没什么关系 -- (如果没 \(\times 6\),我没还不用算逆元) 别人的思路呢,大都是从 ...

  4. JSON字符串带BOM头"ufeff"

    调用三方接口返回值JSON字符串带BOM头"\ufeff",JSON解析死活报错. 我是用SpringBoot的RestTemplate调用三方接口的,一开始返回值我是用对象接收返 ...

  5. 关于Anaconda安装以后使用Jupyter Notebook无法直接打开浏览器的解决方法

    关于Anaconda安装以后使用Jupyter Notebook无法直接打开浏览器的解决方法 1.首先打开Anoconda Prompt,输入命令 jupyter notebook --generat ...

  6. 在Keras中可视化LSTM

    作者|Praneet Bomma 编译|VK 来源|https://towardsdatascience.com/visualising-lstm-activations-in-keras-b5020 ...

  7. OpenCV-Python 图像平滑 | 十六

    目标 学会: 使用各种低通滤镜模糊图像 将定制的滤镜应用于图像(2D卷积) 2D卷积(图像过滤) 与一维信号一样,还可以使用各种低通滤波器(LPF),高通滤波器(HPF)等对图像进行滤波.LPF有助于 ...

  8. Leetcode_239. 滑动窗口最大值

    单调队列模板题,扫描一遍,队尾维护单调性,队头维护不超过大小为k的区间. code class Solution { public: vector<int> maxSlidingWindo ...

  9. Python python 五种数据类型--字典

    # 定义一个字典 var1 = {'a':20,'b':40}; var2 = dict(); print(type(var1)) print(type(var2)) # 长度 length = le ...

  10. IOS 获取系统时间戳

    IOS 获取系统时间戳常用方法 通用方法有如下三种: NSLog(); NSDate* dat = [NSDate dateWithTimeIntervalSinceNow:]; NSTimeInte ...