java泛型学习示例
java泛型(generics)是jdk5开始引入的一个新特性，允许在定义类和接口的时候使用类型参数(type parameter)。声明的类型参数在使用时用具体的类型来替换，现在泛型最主要的应用是在jdk5中的新集合类框架中，map, list均有用到。其中的优点不言而喻，我们可以横向扩展更多的类，缺点呢，其实也就是他的优点，因为这需要我们在使用泛型类的时候，要很清楚自己的代码目地，不能使用错误的类型。
最基本的泛型类
package com.garinzhang.javabase.generic.e1;
/**
* 最基本的泛型类，类型由自己定义
* @author garin zhang
*
* @param <t>
*/
public class point<t> {
private t var;
public t getvar() {
return var;
}
public void setvar(t var) {
this.var = var;
}
}
package com.garinzhang.javabase.generic.e1;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
point<string> p = new point<string> ();
p.setvar("coder");
system.out.println(p.getvar());
}
}
多个泛型类型
package com.garinzhang.javabase.generic.e2;
/**
* 多个泛型类型，一般多个最好是以靠近t的字母，如s,r等
* @author garin zhang
*
* @param <t>
* @param <s>
*/
public class notepad<t, s> {
private t key;
private s value;
public t getkey() {
return this.key;
}
public s getvalue() {
return this.value;
}
public void setkey(t key) {
this.key = key;
}
public void setvalue(s value) {
this.value = value;
}
}
package com.garinzhang.javabase.generic.e2;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
notepad<string, integer> p = new notepad<string, integer> ();
p.setkey("coder");
p.setvalue(99999);
system.out.println("key: " + p.getkey());
system.out.println("value: " + p.getvalue());
}
}
在方法参数中使用通配符"?"
package com.garinzhang.javabase.generic.e3;
/**
* 该例子关键在main方法里
* @author garin zhang
*
* @param <t>
*/
public class info<t> {
private t key;
public t getkey() {
return this.key;
}
public void setkey(t key) {
this.key = key;
}
@override
public string tostring() {
return this.key.tostring();
}
}
package com.garinzhang.javabase.generic.e3;
/**
* 在方法参数中使用通配符
* @author garin zhang
*
*/
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
info<string> i = new info<string>();
i.setkey("coder");
fun(i);
info<integer> j = new info<integer>();
j.setkey(9999);
fun(j);
}
public static void fun(info<?> temp) {
system.out.println("content: " + temp);
}
}
向上转型失败
package com.garinzhang.javabase.generic.e4;
/**
* 该例子关键在main方法里
* @author garin zhang
*
* @param <t>
*/
public class info<t> {
private t key;
public t getkey() {
return this.key;
}
public void setkey(t key) {
this.key = key;
}
@override
public string tostring() {
return this.key.tostring();
}
}
package com.garinzhang.javabase.generic.e4;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
info<string> streg = new info<string>();
info<object> objeg;
// 编译错误"type mismatch: cannot convert from info<string> to info<object>"
// 向上转型失败，string -> object
// objeg = streg;
}
}
泛型在接口中的使用
package com.garinzhang.javabase.generic.e5;
/**
* 该例子关键在main方法里
* @author garin zhang
*
* @param <t>
*/
interface info<t> {
public t getvar();
}
package com.garinzhang.javabase.generic.e5;
/**
* 泛型类
* @author garin zhang
*
* @param <t>
*/
public class infoimpl<t> implements info<t> {
private t var;
public infoimpl(t var) {
this.setvar(var);
}
public void setvar(t var) {
this.var = var;
}
public t getvar() {
return this.var;
}
}
package com.garinzhang.javabase.generic.e5;
/**
* 非泛型类
* @author garin zhang
*
* @param <t>
*/
public class infoimpl1 implements info<string> {
private string var;
public infoimpl1(string var) {
this.setvar(var);
}
public void setvar(string var) {
this.var = var;
}
public string getvar() {
return this.var;
}
}
package com.garinzhang.javabase.generic.e5;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
info<string> streg = new infoimpl<string>("coder");
system.out.println("content: " + streg.getvar());
info<string> streg1 = new infoimpl1("coder1");
system.out.println("content: " + streg1.getvar());
}
}
通配符和extends, super的使用
package com.garinzhang.javabase.generic.e6;
/**
* 该例子关键在main方法里
* @author garin zhang
*
* @param <t>
*/
public class info<t> {
private t key;
public t getkey() {
return this.key;
}
public void setkey(t key) {
this.key = key;
}
@override
public string tostring() {
return this.key.tostring();
}
}
package com.garinzhang.javabase.generic.e6;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
info<string> streg = new info<string>();
streg.setkey("coder");
// 编译报错"the method fun(info<? extends number>) in the type genericexample is not applicable for the arguments (info<string>)"
// uptypelimit(i);
// 使用integer，number类型均可以
info<integer> integ = new info<integer>();
integ.setkey(9999);
uptypelimit(integ);
// 编译报错"the method downtypelimit(info<? super string>) in the type genericexample is not applicable for the arguments (info<integer>)"
// downtypelimit(integ);
// 由于使用的是super，downtypelimit只能接收string本身和object
// 查看了string的继承关系，没有继承其他类，只有object
downtypelimit(streg);
info<object> objeg = new info<object>();
objeg.setkey(999);
downtypelimit(objeg);
}
/**
* <? extends t> 表示类型的上界，表示参数化类型的可能是t 或是 t的子类
* @param temp
*/
public static void uptypelimit(info<? extends number> temp) {
system.out.println("content: " + temp);
}
/**
* <? super t> 表示类型下界（java core中叫超类型限定），表示参数化类型是此类型的超类型（父类型），直至object
* 在此例中，表示t只能为object或string，因为string只继承于object
* @param temp
*/
public static void downtypelimit(info<? super string> temp) {
system.out.println("content: " + temp);
}
}
方法泛型，方法里面多个泛型
package com.garinzhang.javabase.generic.e7;
/**
* 方法泛型，方法里面多个泛型
* @author garin zhang
*
* @param <t>
*/
public class info {
/**
* 格式：方法修饰付 <以逗号隔开的类型列表>返回值类型方法名(参数列表)
* 例如：public <t, s> t fun(t t, s s)
* @param t
* @param s
* @return
*/
public <t, s> t fun(t t, s s) {
system.out.println(s.tostring());
return t;
}
}
package com.garinzhang.javabase.generic.e7;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
info info = new info();
string str = info.fun("coder", "print second generic param");
system.out.println(str);
int i = info.fun(30, "print second param again");
system.out.println(i);
}
}
方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定
package com.garinzhang.javabase.generic.e8;
/**
* extends
* @author garin zhang
*
* @param <t>
*/
public class info<t extends number> {
private t var;
public t getvar() {
return this.var;
}
public void setvar(t var) {
this.var = var;
}
@override
public string tostring() {
return this.var.tostring();
}
}
package com.garinzhang.javabase.generic.e8;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
info<integer> integ = fun(30); // 这里类型已经确定为integer
system.out.println(integ.getvar());
}
/**
* 方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定
* @param param
* @return
*/
public static <t extends number> info<t> fun(t param) {
info<t> temp = new info<t>();
temp.setvar(param);
return temp;
}
}
让方法中传入两个参数类型保持一致
package com.garinzhang.javabase.generic.e9;
/**
* 查看main
* @author garin zhang
*
* @param <t>
*/
public class info<t> {
private t var;
public t getvar() {
return this.var;
}
public void setvar(t var) {
this.var = var;
}
@override
public string tostring() {
return this.var.tostring();
}
}
package com.garinzhang.javabase.generic.e9;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
info<string> i1 = new info<string>();
i1.setvar("hello");
info<string> i2 = new info<string>();
i2.setvar("coder");
info<integer> i3 = new info<integer>();
i3.setvar(999);
add(i1, i2);
//编译错误"the method add(info<t>, info<t>) in the type genericexample is not applicable for the arguments (info<string>, info<integer>)"
// add(i1, i3);
}
/**
* 方法中传入两个参数类型必须一致
* @param param
* @return
*/
public static <t> void add(info<t> i1, info<t> i2) {
system.out.println(i1.getvar() + ":" + i2.getvar());
}
}
泛型，可变参数，类似于javascript里的arguments对象
package com.garinzhang.javabase.generic.e10;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
integer i[] = fun(1, 2, 3, 4, 5, 6);
fun2(i);
}
public static <t> t[] fun(t... arg) {
return arg;
}
public static <t> void fun2(t param[]) {
system.out.println("generic array: ");
for(t t : param) {
system.out.println(t + " ,");
}
}
}
泛型嵌套：使用泛型类做为参数；根据返回值类型确定返回值
package com.garinzhang.javabase.generic.e11;
/**
* 接受两个泛型类型
* @author garin zhang
*
* @param <t>
*/
public class info<t, v> {
private t var;
private v value;
public t getvar() {
return this.var;
}
public void setvar(t var) {
this.var = var;
}
public v getvalue(){
return this.value;
}
public void setvalue(v value) {
this.value = value;
}
@override
public string tostring() {
return this.var.tostring();
}
}
package com.garinzhang.javabase.generic.e11;
/**
* 接受1个泛型类型
* @author garin zhang
*
* @param <t>
*/
public class demo<s> {
private s info;
public demo(s info) {
this.setinfo(info);
}
public void setinfo(s info) {
this.info = info;
}
public s getinfo() {
return this.info;
}
}
package com.garinzhang.javabase.generic.e11;
import java.util.list;
import com.google.common.collect.lists;
public class genericexample {
/**
* @param args
*/
public static void main(string[] args) {
demo<info<string, integer>> d;
info<string, integer> i;
i = new info<string, integer>();
i.setvar("coder");
i.setvalue(999);
d = new demo<info<string,integer>>(i);
system.out.println("content: " + d.getinfo().getvar());
system.out.println("content: " + d.getinfo().getvalue());
system.out.println(query(1, 2, 3, 4, 5).tostring()); // [1, 2, 3, 4, 5]
// 警告"type safety: a generic array of object&comparable<?>&serializable is created for a varargs parameter"
system.out.println(query(1, 2, 3, "stringtype").tostring()); // [1, 2, 3, stringtype]
system.out.println(query("i ", "am ", "a ", "coder").tostring());// [i , am , a , coder]
list<string> list = lists.newarraylist("i ", "am ", "a ", "coder");
system.out.println(list.tostring()); // [i , am , a , coder]
}
/**
* 通过返回值确定泛型类型，这个方法里面的返回值类型，是由方法的定义自动生成的
* @param elements
* @return
*/
public static <e> list<e> query(e... elements) {
// https://github.com/exitsoft/exit-web-framework/commit/1d2f1098a2a4b6abab175b793e2308aa8bd0ea16.
// import com.google.common.collect.lists;
// <dependency>
// <groupid>com.google.guava</groupid>
// <artifactid>guava</artifactid>
// <version>16.0.1</version>
// </dependency>
return lists.newarraylist(elements);
}
}
上一篇： pycharm安装图文教程