JAVA泛型

  1 本文对Java泛型进行了全面的总结。文章内容包括普通泛型、通配符、受限泛型、泛型接口、泛型方法、返回泛型类型实例等等。

  2 AD： WOT2014课程推荐：实战MSA：用开源软件搭建微服务系统

  3 虽然Scala创始人Martin Odersky说当年正是因为Java泛型的丑陋，所以才想到要创建一个新的语言，不过这仍然不妨碍我们学习Java泛型。毕竟即使听说Java泛型不好用，但好不好用还是得会用了才知道。下面是一些有关Java泛型的总结：

  4 

  5 普通泛型

  6 

  7 class Point< T>{ // 此处可以随便写标识符号，T是type的简称 

  8 private T var ; // var的类型由T指定，即：由外部指定 

  9 public T getVar(){ // 返回值的类型由外部决定 

 10 return var ; 

 11  } 

 12  public void setVar(T var){ // 设置的类型也由外部决定 

 13 this.var = var ; 

 14  } 

 15 }; 

 16 public class GenericsDemo06{ 

 17  public static void main(String args[]){ 

 18  Point< String> p = new Point< String>() ; // 里面的var类型为String类型 

 19 p.setVar("it") ; // 设置字符串 

 20 System.out.println(p.getVar().length()) ; // 取得字符串的长度 

 21 } 

 22 }; 

 23 ----------------------------------------------------------

 24 

 25 class Notepad< K,V>{ // 此处指定了两个泛型类型 

 26 private K key ; // 此变量的类型由外部决定 

 27 private V value ; // 此变量的类型由外部决定 

 28 public K getKey(){ 

 29  return this.key ; 

 30  } 

 31  public V getValue(){ 

 32  return this.value ; 

 33  } 

 34  public void setKey(K key){ 

 35  this.key = key ; 

 36  } 

 37  public void setValue(V value){ 

 38  this.value = value ; 

 39  } 

 40 }; 

 41 public class GenericsDemo09{ 

 42  public static void main(String args[]){ 

 43  Notepad< String,Integer> t = null ; // 定义两个泛型类型的对象 

 44 t = new Notepad< String,Integer>() ; // 里面的key为String，value为Integer 

 45  t.setKey("汤姆") ; // 设置第一个内容 

 46 t.setValue(20) ; // 设置第二个内容 

 47 System.out.print("姓名；" + t.getKey()) ; // 取得信息 

 48 System.out.print("，年龄；" + t.getValue()) ; // 取得信息 

 49 

 50 } 

 51 }; 

 52 

 53 通配符

 54 

 55 class Info< T>{ 

 56  private T var ; // 定义泛型变量 

 57 public void setVar(T var){ 

 58  this.var = var ; 

 59  } 

 60  public T getVar(){ 

 61  return this.var ; 

 62  } 

 63  public String toString(){ // 直接打印 

 64 return this.var.toString() ; 

 65  } 

 66 }; 

 67 public class GenericsDemo14{ 

 68  public static void main(String args[]){ 

 69  Info< String> i = new Info< String>() ; // 使用String为泛型类型 

 70 i.setVar("it") ; // 设置内容 

 71 fun(i) ; 

 72  } 

 73  public static void fun(Info< ?> temp){ // 可以接收任意的泛型对象 

 74 System.out.println("内容：" + temp) ; 

 75  } 

 76 }; 

 77 

 78 受限泛型

 79 

 80 class Info< T>{ 

 81  private T var ; // 定义泛型变量 

 82 public void setVar(T var){ 

 83  this.var = var ; 

 84  } 

 85  public T getVar(){ 

 86  return this.var ; 

 87  } 

 88  public String toString(){ // 直接打印 

 89 return this.var.toString() ; 

 90  } 

 91 }; 

 92 public class GenericsDemo17{ 

 93  public static void main(String args[]){ 

 94  Info< Integer> i1 = new Info< Integer>() ; // 声明Integer的泛型对象 

 95 Info< Float> i2 = new Info< Float>() ; // 声明Float的泛型对象 

 96 i1.setVar(30) ; // 设置整数，自动装箱 

 97 i2.setVar(30.1f) ; // 设置小数，自动装箱 

 98 fun(i1) ; 

 99  fun(i2) ; 

100  } 

101  public static void fun(Info< ? extends Number> temp){ // 只能接收Number及其Number的子类 

102 System.out.print(temp + "、") ; 

103  } 

104 }; 

105 ----------------------------------------------------------

106 

107 

108 class Info< T>{ 

109  private T var ; // 定义泛型变量 

110 public void setVar(T var){ 

111  this.var = var ; 

112  } 

113  public T getVar(){ 

114  return this.var ; 

115  } 

116  public String toString(){ // 直接打印 

117 return this.var.toString() ; 

118  } 

119 }; 

120 public class GenericsDemo21{ 

121  public static void main(String args[]){ 

122  Info< String> i1 = new Info< String>() ; // 声明String的泛型对象 

123 Info< Object> i2 = new Info< Object>() ; // 声明Object的泛型对象 

124 i1.setVar("hello") ; 

125  i2.setVar(new Object()) ; 

126  fun(i1) ; 

127  fun(i2) ; 

128  } 

129  public static void fun(Info< ? super String> temp){ // 只能接收String或Object类型的泛型 

130 System.out.print(temp + "、") ; 

131  } 

132 }; 

133 

134 Java泛型无法向上转型

135 

136 class Info< T>{ 

137  private T var ; // 定义泛型变量 

138 public void setVar(T var){ 

139  this.var = var ; 

140  } 

141  public T getVar(){ 

142  return this.var ; 

143  } 

144  public String toString(){ // 直接打印 

145 return this.var.toString() ; 

146  } 

147 }; 

148 public class GenericsDemo23{ 

149  public static void main(String args[]){ 

150  Info< String> i1 = new Info< String>() ; // 泛型类型为String 

151  Info< Object> i2 = null ; 

152  i2 = i1 ; //这句会出错 incompatible types 

153  } 

154 }; 

155 

156 Java泛型接口

157 

158 interface Info< T>{ // 在接口上定义泛型 

159 public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型 

160 } 

161 class InfoImpl< T> implements Info< T>{ // 定义泛型接口的子类 

162 private T var ; // 定义属性 

163 public InfoImpl(T var){ // 通过构造方法设置属性内容 

164 this.setVar(var) ; 

165  } 

166  public void setVar(T var){ 

167  this.var = var ; 

168  } 

169  public T getVar(){ 

170  return this.var ; 

171  } 

172 }; 

173 public class GenericsDemo24{ 

174  public static void main(String arsg[]){ 

175  Info< String> i = null; // 声明接口对象 

176 i = new InfoImpl< String>("汤姆") ; // 通过子类实例化对象 

177 System.out.println("内容：" + i.getVar()) ; 

178  } 

179 }; 

180 ----------------------------------------------------------

181 

182 

183 interface Info< T>{ // 在接口上定义泛型 

184 public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型 

185 } 

186 class InfoImpl implements Info< String>{ // 定义泛型接口的子类 

187 private String var ; // 定义属性 

188 public InfoImpl(String var){ // 通过构造方法设置属性内容 

189 this.setVar(var) ; 

190  } 

191  public void setVar(String var){ 

192  this.var = var ; 

193  } 

194  public String getVar(){ 

195  return this.var ; 

196  } 

197 }; 

198 public class GenericsDemo25{ 

199  public static void main(String arsg[]){ 

200  Info i = null; // 声明接口对象 

201 i = new InfoImpl("汤姆") ; // 通过子类实例化对象 

202 System.out.println("内容：" + i.getVar()) ; 

203  } 

204 }; 

205 

206 Java泛型方法

207 

208 class Demo{ 

209  public < T> T fun(T t){ // 可以接收任意类型的数据 

210 return t ; // 直接把参数返回 

211 } 

212 }; 

213 public class GenericsDemo26{ 

214  public static void main(String args[]){ 

215  Demo d = new Demo() ; // 实例化Demo对象 

216 String str = d.fun("汤姆") ; // 传递字符串 

217 int i = d.fun(30) ; // 传递数字，自动装箱 

218 System.out.println(str) ; // 输出内容 

219 System.out.println(i) ; // 输出内容 

220 } 

221 }; 

222 

223 通过泛型方法返回泛型类型实例

224 

225 class Info< T extends Number>{ // 指定上限，只能是数字类型 

226 private T var ; // 此类型由外部决定 

227 public T getVar(){ 

228  return this.var ; 

229  } 

230  public void setVar(T var){ 

231  this.var = var ; 

232  } 

233  public String toString(){ // 覆写Object类中的toString()方法 

234 return this.var.toString() ; 

235  } 

236 }; 

237 public class GenericsDemo27{ 

238  public static void main(String args[]){ 

239  Info< Integer> i = fun(30) ; 

240  System.out.println(i.getVar()) ; 

241  } 

242  public static < T extends Number> Info< T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定 

243 Info< T> temp = new Info< T>() ; // 根据传入的数据类型实例化Info 

244  temp.setVar(param) ; // 将传递的内容设置到Info对象的var属性之中 

245 return temp ; // 返回实例化对象 

246 } 

247 }; 

248 

249 使用泛型统一传入的参数类型

250 

251 class Info< T>{ // 指定上限，只能是数字类型 

252 private T var ; // 此类型由外部决定 

253 public T getVar(){ 

254  return this.var ; 

255  } 

256  public void setVar(T var){ 

257  this.var = var ; 

258  } 

259  public String toString(){ // 覆写Object类中的toString()方法 

260 return this.var.toString() ; 

261  } 

262 }; 

263 public class GenericsDemo28{ 

264  public static void main(String args[]){ 

265  Info< String> i1 = new Info< String>() ; 

266  Info< String> i2 = new Info< String>() ; 

267  i1.setVar("HELLO") ; // 设置内容 

268 i2.setVar("汤姆") ; // 设置内容 

269 add(i1,i2) ; 

270  } 

271  public static < T> void add(Info< T> i1,Info< T> i2){ 

272  System.out.println(i1.getVar() + " " + i2.getVar()) ; 

273  } 

274 }; 

275 

276 Java泛型数组

277 

278 public class GenericsDemo30{ 

279  public static void main(String args[]){ 

280  Integer i[] = fun1(1,2,3,4,5,6) ; // 返回泛型数组 

281 fun2(i) ; 

282  } 

283  public static < T> T[] fun1(T...arg){ // 接收可变参数 

284 return arg ; // 返回泛型数组 

285 } 

286 public static < T> void fun2(T param[]){ // 输出 

287 System.out.print("接收泛型数组：") ; 

288 for(T t:param){ 

289  System.out.print(t + "、") ; 

290  } 

291  } 

292 }; 

293 

294 Java泛型的嵌套设置

295 

296 class Info< T,V>{ // 接收两个泛型类型 

297 private T var ; 

298  private V value ; 

299  public Info(T var,V value){ 

300  this.setVar(var) ; 

301  this.setValue(value) ; 

302  } 

303  public void setVar(T var){ 

304  this.var = var ; 

305  } 

306  public void setValue(V value){ 

307  this.value = value ; 

308  } 

309  public T getVar(){ 

310  return this.var ; 

311  } 

312  public V getValue(){ 

313  return this.value ; 

314  } 

315 }; 

316 class Demo< S>{ 

317  private S info ; 

318  public Demo(S info){ 

319  this.setInfo(info) ; 

320  } 

321  public void setInfo(S info){ 

322  this.info = info ; 

323  } 

324  public S getInfo(){ 

325  return this.info ; 

326  } 

327 }; 

328 public class GenericsDemo31{ 

329  public static void main(String args[]){ 

330  Demo< Info< String,Integer>> d = null ; // 将Info作为Demo的泛型类型 

331 Info< String,Integer> i = null ; // Info指定两个泛型类型 

332 i = new Info< String,Integer>("汤姆",30) ; // 实例化Info对象 

333 d = new Demo< Info< String,Integer>>(i) ; // 在Demo类中设置Info类的对象 

334 System.out.println("内容一：" + d.getInfo().getVar()) ; 

335  System.out.println("内容二：" + d.getInfo().getValue()) ; 

336  } 

337 }; 

转载于http://www.cnblogs.com/dk18stone/p/3738228.html