Java泛型

泛型就是指在对象建立时不指定类中属性的具体类型，而由外部在声明及实例化对喜爱时指定类型。

在泛型的指定中无法指定基本数据类型的，必须设置成一个类，这样在设置一个数字时就必须使用包装类。

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//泛型名：Point
//属性：
//方法：
class Point<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	

}



//主类
//Function        : 	Generics_demo
public class Generics_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Point<Integer> p = new Point<Integer>();	//里面的var类型为Integer类型
//		p.setVar(30);  														//设置数字，自动装箱
//		System.out.println(p.getVar()*2);					//计算结果，按数字取出
		Point<String> p = new Point<String>();	//里面的var类型为Integer类型
		p.setVar("张三");  														//设置数字，自动装箱
		System.out.println(p.getVar().length());					//计算结果，按数字取出
	}

}

 

泛型的构造方法

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//泛型名：Point
//属性：
//方法：
class Point<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
	public Point(T var) {					//构造方法
		super();
		this.var = var;
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	

}



//主类
//Function        : 	Generics_demo
public class Generics_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Point<Integer> p = new Point<Integer>();	//里面的var类型为Integer类型
//		p.setVar(30);  														//设置数字，自动装箱
//		System.out.println(p.getVar()*2);					//计算结果，按数字取出
		
//		Point<String> p = new Point<String>();	//里面的var类型为Integer类型
//		p.setVar("张三");  														//设置数字，自动装箱
//		System.out.println(p.getVar().length());					//计算结果，按数字取出
		
		Point<String> p = new Point<String>("张三");
		System.out.println("内容："+p.getVar());	
	}

}

 

指定多个泛型类型

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//泛型名：Point
//属性：
//方法：
class Point<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
	public Point(T var) {					//构造方法
		super();
		this.var = var;
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	

}

//泛型名：Notepad
//属性：
//方法：
class Notepad<K,V>{								//此处T可以是任意的标识符号，T是type的简称
	private K key;											//此变量的类型由外部决定
	private V value;										//此变量的类型由外部决定
	
	public Notepad(K key, V value) {		//构造方法
		super();
		this.key = key;
		this.value = value;
	}
	public K getKey() {
		return key;
	}
	public void setKey(K key) {
		this.key = key;
	}
	public V getValue() {
		return value;
	}
	public void setValue(V value) {
		this.value = value;
	}
	
}




//主类
//Function        : 	Generics_demo
public class Generics_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Point<Integer> p = newdd Point<Integer>();	//里面的var类型为Integer类型
//		p.setVar(30);  														//设置数字，自动装箱
//		System.out.println(p.getVar()*2);					//计算结果，按数字取出
		
//		Point<String> p = new Point<String>();	//里面的var类型为Integer类型
//		p.setVar("张三");  														//设置数字，自动装箱
//		System.out.println(p.getVar().length());					//计算结果，按数字取出
		
//		Point<String> p = new Point<String>("张三");
//		System.out.println("内容："+p.getVar());
		
		Notepad<String,Integer> t = new Notepad<String,Integer>("张三",18);
		System.out.println(t.getKey());
		System.out.println(t.getValue());
		
	}
}

 

通配符

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//泛型名：Point
//属性：
//方法：
class Point<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
	public Point(T var) {					//构造方法
		super();
		this.var = var;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	

}

//泛型名：Notepad
//属性：
//方法：
class Notepad<K,V>{								//此处T可以是任意的标识符号，T是type的简称
	private K key;											//此变量的类型由外部决定
	private V value;										//此变量的类型由外部决定
	
	public Notepad(K key, V value) {		//构造方法
		super();
		this.key = key;
		this.value = value;
	}
	public K getKey() {
		return key;
	}
	public void setKey(K key) {
		this.key = key;
	}
	public V getValue() {
		return value;
	}
	public void setValue(V value) {
		this.value = value;
	}
	
}




//主类
//Function        : 	Generics_demo
public class Generics_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

		Point<String> p = new Point<String>("张三");
		fun(p);
	}
	
	public static void fun(Point<?> point){			//使用泛型接收Point的对象
		System.out.println("内容：" + point);
	}
	
}

 

受限泛型

在引用传递中，在泛型操作中也可以设置一个泛型对象的范围上限和范围下限。

范围上限使用extends关键字声明，标识参数化的类型可能是所指定的类型或者是此类型的子类。

范围下限使用super关键字声明，标识参数化的类型可能是所指定的类型，或者是此类型的父类型，或是Object类。

 

范围上限

import java.awt.datatransfer.FlavorTable;

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//泛型名：info
//属性：
//方法：
class info<T extends Number>{	//在声明的地方指定泛型的上限范围
//class info<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
	public info(T var) {					//构造方法
		super();
		this.var = var;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	

}




//主类
//Function        : 	Generics_extends_demo
public class Generics_extends_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		info<Float> i1 = new info<Float>(10.1f);			//声明并实例化Float类型的泛型对象
		info<Integer> i2 = new info<Integer>(10);		//声明并实例化Integer类型的泛型对象
		fun(i1);																		//是数字可以传递
		fun(i2);																		//是数字可以传递
	}
	
	public static void fun(info<?> temp){			//使用泛型接收info的对象
//	public static void fun(info<? extends Number> temp){			//使用泛型接收info的对象
		System.out.println("temp:" + temp);
	}
		
	

}

 

范围下限

import java.awt.datatransfer.FlavorTable;

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//泛型名：info
//属性：
//方法：
//class info<T extends Number>{	//在声明的地方指定泛型的上限范围
class info<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
	public info(T var) {					//构造方法
		super();
		this.var = var;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	

}




//主类
//Function        : 	Generics_extends_demo
public class Generics_extends_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
//		info<Float> i1 = new info<Float>(10.1f);			//声明并实例化Float类型的泛型对象
//		info<Integer> i2 = new info<Integer>(10);		//声明并实例化Integer类型的泛型对象
		
		info<Object> i1 = new info<Object>(new Object());	//声明并实例化Object类型的泛型对象
		info<String> i2 = new info<String>("张三");					//声明并实例化String类型的泛型对象
		fun(i1);																		//是数字可以传递
		fun(i2);																		//是数字可以传递
	}
	
//	public static void fun(info<?> temp){			//使用泛型接收info的对象
//	public static void fun(info<? extends Number> temp){			//使用泛型接收info的对象
	public static void fun(info<? super String> temp){			//使用泛型接收info的对象
		System.out.println("temp:" + temp);
	}
		
	

}

 

泛型接口

定义泛型接口

定义子类方式<1>——在子类的定义上声明泛型类型

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//接口名：info
//属性：
//方法：
interface Info_1<T>{
	public T getVar();
}

//泛型类名：info
//属性：
//方法：
class InfoImp<T> implements Info_1<T>{
	
	private T var;							//定义属性
	
	public InfoImp(T var) {		//构造方法
		super();
		this.var = var;
	}

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

	@Override
	public T getVar() {
		// TODO 自动生成的方法存根
		return this.var;
	}
	
}

//主类
//Function        : 	Generics_extends_demo
public class Generics_Interface_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		InfoImp<String> p = new InfoImp<String>("张三");
		System.out.println("内容："+p.getVar());
	}

}

定义子类方式<2>——直接在接口中指定具体类型

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//接口名：info
//属性：
//方法：
interface Info_1<T>{
	public T getVar();
}

//泛型类名：info
//属性：
//方法：
class InfoImp implements Info_1<String>{//定义泛型接口的子类，指定类型为String
//class InfoImp<T> implements Info_1<T>{	//定义泛型接口的子类
	
//	private T var;							//定义属性
	private String var;							//定义属性
	
//	public InfoImp(T var) {		//构造方法
	public InfoImp(String var) {		//构造方法
		super();
		this.var = var;
	}

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

	@Override
//	public T getVar() {
	public String getVar() {
		// TODO 自动生成的方法存根
		return this.var;
	}
	
}

//主类
//Function        : 	Generics_extends_demo
public class Generics_Interface_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		InfoImp p = new InfoImp("张三");
		System.out.println("内容："+p.getVar());
	}

}

 

定义泛型方法

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common


//类名：Demo_Generics
//属性：
//方法：
class Demo_Generics{
	public <T> T fun(T t){		//可以接收任意类型的数据
		return t;
	}
}

//接口名：info
//属性：
//方法：
interface Info_1<T>{
	public T getVar();
}

//泛型类名：info
//属性：
//方法：
class InfoImp implements Info_1<String>{//定义泛型接口的子类，指定类型为String
//class InfoImp<T> implements Info_1<T>{	//定义泛型接口的子类
	
//	private T var;							//定义属性
	private String var;							//定义属性
	
//	public InfoImp(T var) {		//构造方法
	public InfoImp(String var) {		//构造方法
		super();
		this.var = var;
	}

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

	@Override
//	public T getVar() {
	public String getVar() {
		// TODO 自动生成的方法存根
		return this.var;
	}
	
}

//主类
//Function        : 	Generics_extends_demo
public class Generics_Interface_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		InfoImp p = new InfoImp("张三");
//		System.out.println("内容："+p.getVar());
		
		Demo_Generics d = new Demo_Generics();
		String str = d.fun("张三");		//传递字符串
		int i = d.fun(30);							//传递数字，自动装箱
		System.out.println(str);
		System.out.println(i);
	}

}

 

通过泛型方法返回泛型类实例

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//泛型名：info
//属性：
//方法：
class info<T extends Number>{	//在声明的地方指定泛型的上限范围
//class info<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
//	public info(T var) {					//构造方法
//		super();
//		this.var = var;
//	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	

}




//主类
//Function        : 	Generics_extends_demo
public class Generics_extends_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
				
		info<Integer> i = fun(30);						//传递整数到fun()方法
		System.out.println(i.getVar());

	}
		
	public static <T extends Number> info<T> fun (T param){	//fun返回的参数类型是info<T>
		info<T> temp = new info<T>();		//根据传入的数据类型实例化info对象
		temp.setVar(param);							//将传递的内容设置到info类中的var属性之中
		return temp;										//返回实例化对象
		
	}

}

 

//=================================================
// File Name       :	Generics_demo
//------------------------------------------------------------------------------
// Author          :	Common

//泛型名：info
//属性：
//方法：
//class info<T extends Number>{	//在声明的地方指定泛型的上限范围
class info<T>{								//此处T可以是任意的标识符号，T是type的简称
	private T var;								//此变量的类型由外部决定
	
//	public info(T var) {					//构造方法
//		super();
//		this.var = var;
//	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return this.var.toString();
	}

	public T getVar() {					//返回值的类型由外部决定
		return var;
	}

	public void setVar(T var) {	//设置的类型由外部指定
		this.var = var;
	}
	

}




//主类
//Function        : 	Generics_extends_demo
public class Generics_extends_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
			
		info<String> i1 = new info<String>();		//设置String为泛型类型
		info<String> i2 = new info<String>();		//设置String为泛型类型
		i1.setVar("HELLO");									//设置内容
		i2.setVar("张三");										//设置内容
		add(i1,i2);
	}
		
	
	public static <T> void add(info<T> i1,info<T> i2){
		System.out.println(i1.getVar()+""+i2.getVar());
	}

}

 

泛型数组

程序从fun1()方法返回一个泛型数组，在fun1()方法接收参数时使用了可变参数传递方式，然后将fun1()返回的泛型数组内容交给fun2()方法进行输出。

//=================================================
// File Name       :	Generics_array_demo
//------------------------------------------------------------------------------
// Author          :	Common



//主类
//Function        : 	Generics_array_demo
public class Generics_array_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Integer i[] = fun1(1,2,3,4,5);				//返回泛型数组
		fun2(i);												//输出数组内容
	}
	
	public static <T> T[] fun1(T...arg){	//接收可变参数，返回泛型数组
		return arg;											//返回泛型数组
	}

	public static <T> void fun2(T param[]){
		System.out.println("接收泛型数组：");	//接收泛型数组
		for(T t:param){
			System.out.println(t+"、");
		}
		System.out.println();
	}
	
}

 

泛型应用

一个人有联系方式、基本信息等，这些信息的类型可以通过泛型进行声明，然后传给Person

//=================================================
// File Name       :	Generics_array_demo
//------------------------------------------------------------------------------
// Author          :	Common

//接口名：Generics_array_interface
//属性：
//方法：
interface Generics_array_interface{		//定义一个标识接口，此接口没有定义任何方法
	
}

//类名：Contact
//属性：
//方法：
class Contact implements Generics_array_interface{		//实现Generics_array_interface接口

	private String address;				//联系地址
	private String telephone;				//联系方式
	private String zipcode;					//邮政编码
	
	public Contact(String address, String telephone, String zipcode) {	//构造方法
		super();
		this.address = address;
		this.telephone = telephone;
		this.zipcode = zipcode;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getTelephone() {
		return telephone;
	}

	public void setTelephone(String telephone) {
		this.telephone = telephone;
	}

	public String getZipcode() {
		return zipcode;
	}

	public void setZipcode(String zipcode) {
		this.zipcode = zipcode;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
			return "联系方式："+"\n"+"联系电话："+this.telephone+"联系地址："+this.address+"邮政编码："+this.zipcode;
	}
	
	
}

//类名：Introduction
//属性：
//方法：
class Introduction implements Generics_array_interface{
	private String name;
	private String sex;
	private int age;
	
	public Introduction(String name, String sex, int age) {	//构造方法
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public String toString(){			//覆写Object类中的toString()方法
		return "基本信息："+"\n"+"姓名："+this.name+"性别："+this.sex+"年龄："+this.age;
	}
	
}

//类名：Person_
//属性：
//方法：
class Person_ <T extends Generics_array_interface>{
	private T info;

	public Person_(T info) {	//构造方法
		super();
		this.info = info;
	}

	public T getInfo() {
		return info;
	}

	public void setInfo(T info) {
		this.info = info;
	}

	@Override
	public String toString() {			//覆写Object类中的toString()方法
		return this.info.toString();
	}
	
}

//主类
//Function        : 	Generics_array_demo
public class Generics_array_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
//		Integer i[] = fun1(1,2,3,4,5);				//返回泛型数组
//		fun2(i);												//输出数组内容
		
		Person_ <Contact> per = null;	//声明Person_对象，同时指定Contact类型
		per = new Person_<Contact>(new Contact("北京市","010010101010","100876"));//实例化Person_对象，同时设置信息
		System.out.println(per);
	}
	
//	public static <T> T[] fun1(T...arg){	//接收可变参数，返回泛型数组
//		return arg;											//返回泛型数组
//	}
//
//	public static <T> void fun2(T param[]){
//		System.out.println("接收泛型数组：");	//接收泛型数组
//		for(T t:param){
//			System.out.println(t+"、");
//		}
//		System.out.println();
//	}
	
}

 

转载于:https://www.cnblogs.com/tonglin0325/p/5257309.html