java泛型

1、泛型的基本应用
泛型可以解决数据类型的安全性问题，其主要原理时在类声明时通过一个标识表示类中某个方法的返回值及参数类型。遮掩在类声明或实例化时只要制定好需要的具体类型即可。如：
【访问权限】 class 类名称<泛型类型标识符1，泛型类型标识符2>{【访问权限】 泛型类型标识 变量名称；
【访问权限】 泛型类型标识 方法名称（）{}；
}

1.1、泛型的使用
例：

package com.shuai.ChapterTen;
/**
 * 泛型
 * @author guai
 *
 */

class Point<T>{
	//此变量类型由外部决定
	private T var;   

	public T getVar() {
		return var;
	}

	public void setVar(T var) {
		this.var = var;
	}
	
}
public class GenericDemo {
	public static void main(String[] args) {
	        //定义对象是指定泛型对象 对象的具体数据类型
		Point<Integer> point=new Point<Integer>();
		point.setVar(30);
		System.out.println("Integer-->"+point.getVar()*2);
		
		
		
		Point <String> point2=new Point<String>();
		point2.setVar("东经10");
		System.out.println("String-->"+point2.getVar());
		
	}
}

结果：

注意：在设置数据类型时，必须设置一个类，即对于int，float等，必须使用包装类。

1.2、泛型应用中的构造函数
package com.shuai.ChapterTen;

/**
 * 泛型
 * 
 * @author guai
 *
 */

class Point<T> {
	// 此变量类型由外部决定
	private T var;
	//无参构造函数
	public Point() {
	}
	//有参构造函数
	public Point(T var) {
		this.var=var;
	}

	public T getVar() {
		return var;
	}

	public void setVar(T var) {
		this.var = var;
	}

}

public class GenericDemo {
	public static void main(String[] args) {

		Point<String> point2 = new Point<String>("构造函数");
		System.out.println("String-->" + point2.getVar());
		
	}
}

结果：

1.3、指定多个泛型类型

package com.shuai.ChapterTen;
/**
 * 设置多个泛型类型
 * @author guai
 *
 * @param <T>
 */
class Point1<T,K> {
	// 此变量类型由外部决定
	private T var;
	private K var1;

	public K getVar1() {
		return var1;
	}

	public void setVar1(K var1) {
		this.var1 = var1;
	}

	public T getVar() {
		return var;
	}

	public void setVar(T var) {
		this.var = var;
	}

}

public class MultipleGenerics {
	public static void main(String[] args) {
		Point1<String,Integer> p=new Point1<String,Integer>();
		p.setVar("guai");
		p.setVar1(18);
		System.out.println(p.getVar()+"已经"+p.getVar1()+"岁");
		
	}
}

结果：

2、通配符

2.1、通配符的使用在使用泛型进行引用传递时需要在接收对象时可以指定泛型类型，也可以不指定，也可以使用通配符来接收任意类型

package com.shuai.ChapterTen
/**
 * 泛型通配符
 * @author guai
 *
 */
class Info<T>{
	private T var;

	public T getVar() {
		return var;
	}

	public void setVar(T var) {
		this.var = var;
	}
}

public class GenericWildcard {
	public static void main(String[] args) {
		Info<String> i=new Info<String>();
		i.setVar("通配符");
		fun(i);
	}
	                        //指定泛型类型
	public static void fun(Info<String> i) {
		System.out.println(i.getVar());
	}
}

结果：

不指定泛型类型：

使用通配符 ？

2.2、受限泛型
在引用传递中，在泛型操作中可以设置一个泛型对象的范围上限和下限，上限使用extends关键字声明，表明泛型的类型可能是所指定的类型或者此类型的子类。上范围下限使用super关键字进行声明，表示泛型的类型可能时所指定的类型，或者时此类型的父类型。
当使用extends却超出上限时报错：

正常情况：

3、泛型与子类继承的限制

package com.shuai.ChapterTen;

/**
 * 泛型与子类继承的限制
 * 子类的泛型类型无法使用父类的泛型类型接收
 * @author guai
 *
 */
class Info<T>{
	private T var;

	public T getVar() {
		return var;
	}

	public void setVar(T var) {
		this.var = var;
	}
}
class InfoChile<T> extends Info<T>{
	
}
public class InheritLimit {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 
	}

}

用父类放行类型接收子类的泛型类型：

正常接收：

4、泛型接口
【访问权限】 interface 接口名称<泛型标识符>{}
1、在子类的定义上声明泛型类型
2、直接在接口中指定具体类型

package com.shuai.ChapterTen;
/**
 * 泛型接口的定义和两种实现方式
 * @author guai
 *
 * @param <T>
 */
interface info4<T>{
	public T getVar();
}
//在子类的定义上声明泛型类型
class Info4Impl<T> implements info4<T>{
	private T var;
	
	public void setVar(T var) {
		this.var=var;
	}
	
	@Override
	public T getVar() {
		// TODO Auto-generated method stub
		return this.var;
	}
}
//直接在接口中指定具体泛型
class Info4Impl1 implements info4<String>{
	private String var;
	
	public void setVar(String var) {
		this.var=var;
	}
	
	@Override
	public String getVar() {
		// TODO Auto-generated method stub
		return this.var;
	}
}
public class GenericInterfaceDemo {
	public static void main(String[] args) {
		Info4Impl<Integer> info4Impl=new Info4Impl<Integer>();
		info4Impl.setVar(18);
		System.out.println(info4Impl.getVar());
		
		Info4Impl1 info4Impl1=new Info4Impl1();
		info4Impl1.setVar("guai");
		System.out.println(info4Impl1.getVar());
	}

}

结果：

5、泛型数组

package com.shuai.ChapterTen;

/**
 * 泛型数组
 * @author guai
 *
 */
public class GenericArr {
	public static void main(String[] args) {
		Integer i[]=fun1(1,2,3,4,5);
		fun2(i);
	}
	      //接收可变参数，返回泛型数组
	@SafeVarargs
	public static <T> T[]fun1(T...arg){
		return arg;
	}
	public static <T> void fun2(T paeam[]) {
		System.out.println("接收泛型数组：");
		for(T t:paeam) {
			System.out.println(t+"，");
		}
	}
}

结果：