泛型类:
/**
* 泛型类
* @author 64120
*
*/
public class GenerisDemo01 {
public static void main(String[] args) {
Point<Integer> point = new Point();
point.setVar(30);
System.out.println(point.getVar());
}
}
class Point<T>{
private T var;
public T getVar() {
return var;
}
public void setVar(T var) {
this.var = var;
}
}
泛型接口:
用两种实现方式
方式1:
public interface info <T>{
public T getVar();
}
class infoImpl<T> implements info<T>{
private T var;
public infoImpl(T var) {
this.var = var;
}
public void setVar(T var) {
this.var = var;
}
@Override
public T getVar() {
return this.var;
}
}
//测试类
public class TestInfo {
public static void main(String[] args) {
infoImpl<String> i = new infoImpl("泛型");
System.out.println(i.getVar());
}
}
方式2:
public interface info <T>{
public T getVar();
}
class infoImpl implements info<String>{
private String var;
public infoImpl(String var) {
this.var = var;
}
public void setVar(String var) {
this.var = var;
}
@Override
public String getVar() {
return this.var;
}
}
//测试类
public class TestInfo {
public static void main(String[] args) {
infoImpl i = new infoImpl("泛型");
System.out.println(i.getVar());
}
}
泛型方法:
/**
- 调用泛型方法的时候,不需要像泛型类那样告诉编译器是什么类型,编译器自动推断出类型
*/
/**
* 调用泛型方法的时候,不需要像泛型类那样告诉编译器是什么类型,编译器自动推断出类型
*
*/
public class GenerisDemo02 {
public static void main(String[] args) {
//动态方法
Test test = new Test();
test.Name("无返回值的泛型方法");
System.out.println(test.fun("有返回值的泛型方法"));
//静态的方法不需要实例化直接通过类名调用
Test.flag("静态无返回值泛型方法");
System.out.println(Test.flag2("静态有返回值泛型方法"));
//可变参数
String[] arr = new String[] {"a","b","c","d","e"};
test.Method(arr);
}
}
class Test{
//没有返回值的泛型方法
public <T> void Name(T name ) {
System.out.println(name);
}
//带有返回值的泛型方法
public <T> T fun (T t) {
return t;
}
//注意!!:静态方法中使用泛型,静态方法无法访问类上定义的泛型
public static <T> void flag(T flag) {
System.out.println(flag);
}
public static <T> T flag2(T flag) {
return flag;
}
//泛型方法的可变参数
public <T> void Method (T...args) {
for(T t:args) {
System.out.println(t);
}
}
}
泛型通配符:
public class Generic <T> {
private T flag;
public void setFlag( T flag) {
this.flag = flag;
}
public T getFlag() {
return this.flag;
}
}
public class ShowMsg {
public void showMsg(Generic<?> generic) {
System.out.println(generic.getFlag());
}
}
public class Test01 {
public static void main(String[] args) {
Generic<Integer> generic = new Generic<>();
generic.setFlag(20);
Generic<String> generic2 = new Generic<String>();
generic2.setFlag("lili");
ShowMsg showMsg = new ShowMsg();
showMsg.showMsg(generic);
showMsg.showMsg(generic2);
}
}
可以对统配符的上下限进行限定:
使用extends 对统配符进行上限限定,如下,如果类ShowMsg 的实例调用showMsg时使用了字符类型则报错!!
public class ShowMsg {
public void showMsg(Generic<? extends Number> generic) {
System.out.println(generic.getFlag());
}
}
此限定同样适用于泛型类,如:,对泛型进行限定。
使用super 对统配符进行下限限定,此限定不适用于泛型类
public class ShowMsg {
public void showMsg(Generic<? super Number> generic) {
System.out.println(generic.getFlag());
}
}