泛型的基本应用

骑猪看日落 2022-02-28 19:44 172阅读 0赞

## 泛型接口： ##

泛型即可以直接在类中进行操作，在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());
    	}
    	
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQxMTU2OQ_size_16_color_FFFFFF_t_70]

### 泛型数组： ###

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

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());
    		
    	}
    }

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQxMTU2OQ_size_16_color_FFFFFF_t_70]: /images/20220227/34f1ffd7cee54f3ba7982b76b8a852be.png