java泛型
一、泛型类的定义
public class Ponit {
private T x;
public Ponit(T x, T y) {
this.x = x;
this.y = y;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
private T y;
}
（2）、多泛型变量定义
上在我们只定义了一个泛型变量T，那如果我们需要传进去多个泛型要怎么办呢？
只需要在类似下面这样就可以了：
public class MorePonit <T,U,M,N>{
private T x;
private U name;
private M modle;
public U getName() {
return name;
}
public void setName(U name) {
this.name = name;
}
public M getModle() {
return modle;
}
public void setModle(M modle) {
this.modle = modle;
}
public N getNumber() {
return number;
}
public void setNumber(N number) {
this.number = number;
}
private N number;
public Ponit(T x, T y) {
this.x = x;
this.y = y;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
private T y;
}
二、泛型接口定义及使用
在接口上定义泛型与在类中定义泛型是一样的，代码如下：
interfaceInfo<T>{// 在接口上定义泛型
publicTgetVar();// 定义抽象方法，抽象方法的返回值就是泛型类型
publicvoidsetVar(T x);
}
class Info<U,T,K> Implimplements Info<U>{// 定义泛型接口的子类
privateU var ;
privateT x;
privateK y;
publicInfoImpl(U var){// 通过构造方法设置属性内容
this.setVar(var) ;
}
publicvoidsetVar(U var){
this.var = var ;
}
publicUgetVar(){
returnthis.var ;
}
}
三、泛型函数的使用
1、上面我们讲解了类和接口的泛型使用，下面我们再说说，怎么单独在一个函数里使用泛型。比如我们在新建一个普通的类StaticFans，然后在其中定义了两个泛型函数：
public class StaticFans {
//静态函数
public static void StaticMethod(T a){
Log.d("harvic","StaticMethod: "+a.toString());
}
//普通函数
public void OtherMethod(T a){
Log.d("harvic","OtherMethod: "+a.toString());
}
}
上面分别是静态泛型函数和常规泛型函数的定义方法，与以往方法的唯一不同点就是在返回值前加上来表示泛型变量。其它没什么区别
使用方式如下：
/静态方法
StaticFans.StaticMethod("adfdsa");//使用方法一
StaticFans.<String>StaticMethod("adfdsa");//使用方法二
//常规方法
StaticFans staticFans =newStaticFans();
staticFans.OtherMethod(newInteger(123));//使用方法一
staticFans.<Integer>OtherMethod(newInteger(123));//使用方法二
2.有返回值的泛型方法
public static BaseParsergetParser(String json) {
try {
String s = DesUtils.decrypt(json);
if (TextUtils.isEmpty(s)) {
return null;
}else {
return JSON.parseObject(s, new TypeReference() {});
}
}catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static<T> T parser(String data, Type bean) {
try {
if (TextUtils.isEmpty(data)) {
return null;
}else {
return JSON.parseObject(data, bean);
}
}catch (Exception e) {
e.printStackTrace();
return null;
}
}
注意到，我们用的Class object来传递类的class对象，即我们上面提到的SuccessModel.class。
这是因为Class也是一泛型，它是传来用来装载类的class对象的，它的定义如下：
publicfinalclassClass<T>implementsSerializable{
…………
}
public static<T> T getBean(String data, Class bean) {
try {
if (TextUtils.isEmpty(data)) {
return null;
}else {
return JSON.parseObject(data, bean);
}
}catch (Exception e) {
e.printStackTrace();
return null;
}
}
public static<T> List<T> getList(String data, Class bean) {
try {
if (TextUtils.isEmpty(data)) {
return null;
}else {
return JSON.parseArray(data, bean);
}
}catch (Exception e) {
e.printStackTrace();
return null;
}
}
2、Java泛型编程中使用extends关键字指定泛型参数类型的上边界(后面还会讲到使用super关键字指定泛型的下边界)，即泛型只能适用于extends关键字后面类或接口的子类。
Java泛型编程的边界可以是多个，使用如语法来声明，其中只能有一个是类，并且只能是extends后面的第一个为类，其他的均只能为接口(和类/接口中的extends意义不同)。
使用了泛型边界之后，泛型对象就可以使用边界对象中公共的成员变量和方法。
//静态函数
public static <T extens Point &Serializable> void StaticMethod(T a){
a.getModle();
Log.d("harvic","StaticMethod: "+a.toString());
}
//多个泛型也可以绑定
public static <T extens Point &Serializable,U extends Point> T foo(T a, U b){
…………
}
