泛型的基本应用

泛型接口：

泛型即可以直接在类中进行操作，在Java中也可以在接口中定义和使用泛型
定义泛型接口：
声明泛型接口和声明泛型类的语法相似都是
访问权限 interface 接口名称 <标识符> {}

interface USB <T> {	//在接口上定义泛型
	public T getWrite();//定义抽象方法，返回值就是泛型类型
	
}

泛型接口的实现：
1 .在定义的子类上也声明泛型类型

package CS0328;
interface USB <T> {	//在接口上定义泛型
	public T getVar();//定义抽象方法，返回值就是泛型类型
	
}
class Test <T>  implements USB{	//定义泛型接口的子类
	private T var;
	public Test() {	//构造方法
		
	}
	public Test(T var) {	//通过构造方法设置属性内容
		this.var = var;
	}
	public T getVar() {
		return var;
	}

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

}
public class InterfaceDemo01{
	public static void main(String[] args) {
		USB <String> u = null;	//声明接口对象
		u = new Test<String>("张三");	//子类实例化对象
		System.out.println(u.getVar());
	}
}

或者

package CS0328;
interface USB <T> {	//在接口上定义泛型
	public T getVar();//定义抽象方法，返回值就是泛型类型
	
}
class Test <T>  implements USB{	//定义泛型接口的子类
	private T var;
	public Test() {	//构造方法
		
	}
	public Test(T var) {	//通过构造方法设置属性内容
		this.var = var;
	}
	public T getVar() {
		return var;
	}

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

}
public class InterfaceDemo01{
	public static void main(String[] args) {
		USB <String> u = null;	//声明接口对象
		u = new Test("张三");	//子类实例化对象
		System.out.println(u.getVar());
	}
}

泛型的方法：

泛型不仅可以为类中的属性定义泛型，也可以的定义方法，泛型方法坐在的类是否是泛型类无关。
格式：
泛型方法中可以定义泛型参数，此时参数的类型就是传入数据的类型（符合泛型的类型一致）

访问权限 <泛型标识> 泛型标识方法名称（泛型标识参数名称）

package CS0328;

class Demo{
   public <T> T fun(T t){
   	return t;
   }
}
public class FunDemo01 {
   public static void main(String[] args) {
   	//实例化Demo对象
   	Demo d = new Demo();
   	String str  = d.fun("小明");//传递字符串
   	int i = d.fun(20);	//传递数字
   	System.out.println(str);
   	System.out.println(i);
   }
   
}

可以使用泛型统一传入参数的类型,但是统一传入同一个方法的多个泛型参数不统一就会报错

package CS0328;

class Info <T>{	//指定上限，只能是数字类型
	private T var;  //外部决定该类型格式

	public T getVar() {
		return var;
	}

	public void setVar(T var) {
		this.var = var;
	}
	//覆写Object类中的toString方法
	public String toString() {
		return this.var.toString();
	}
}
public class FunDemo01 {
	public static void main(String[] args) {
		Info <String> i = new Info <String>();
		Info <String> i2 = new Info <String>();
		i.setVar("小明");
		i2.setVar("已经工作了");
		add(i,i2);
	}
	public static <T> void add(Info<T>i,Info<T>i2) {
		System.out.println(i.getVar()+ ","+i2.getVar());
	}
	
}

泛型的基本应用

泛型数组：

在使用泛型方法的时候也可以传递或者返回泛型数组哦

package CS0328;

public class CharDemo {
	public static void main(String[] args) {
		Integer i[] = fun(1,2,3,4,5,6,7,8);//返回泛型数组
		fun2(i);
	}
	//接收可变参数...表示可变长参数是这个位置可以传入任意个该类型参数,简单来说就是个数组
	public static <T> T[] fun(T ...a) {
		return a; //返回泛型数组
	}
	public static <T> void fun2(T param[]) {		//输出
		System.out.println("接收泛型数组：");
		for(T v : param) {
			System.out.print(v+" ");
		}
	}
}

泛型的嵌套设置：

所谓嵌套设置简单来说就是设置多个泛型

package CS0328;
class Demo <T,F>{
	private T v1;
	private F v2;
	public T getV1() {
		return v1;
	}
	public void setV1(T v1) {
		this.v1 = v1;
	}
	public F getV2() {
		return v2;
	}
	public void setV2(F v2) {
		this.v2 = v2;
	}
	public Demo() {
		
	}
	public Demo(T v1,F v2) {
		this.setV1(v1);
		this.setV2(v2);
	}
	
}
class Demo02 <S>{
	private S info;
	public Demo02(S info) {
		this.setInfo(	info);
	}
	
	public void setInfo(S info) {
		this.info = info;
	}
	public S getInfo() {
		return this.info;
	}
}
public class FXDemo01 {
	public static void main(String[] args) {
		//将demo作为Demo02的泛型类型
		Demo02<Demo<String,Integer>> d = null;	//将Demo作为Demo02的泛型对象
		Demo <String,Integer> d2= null;		// Demo指定两个泛型类型
		
		d2 = new Demo<String,Integer>("小明",20); //实例化Demo类对象
		d = new Demo02<Demo<String,Integer>>(d2);	//在Demo02类中设置Demo对象
		
		System.out.println("内容1字符串："+d.getInfo().getV1());	//输出
		System.out.println("内容2是数值型："+d.getInfo().getV2());
		
	}
}

一般泛型的使用都是放在集合上，后期介绍哈

泛型接口：

泛型的方法：

泛型数组：

泛型的嵌套设置：

相关推荐