泛型的使用

泛型类：

/**
 * 泛型类
 * @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());	
	}
}