* 测试一下泛型嵌套
* 创建两个泛型类
* 1.class GenericNest<T,T1>
* 2.class GenericNest1<V>
package generic;
/**
* 测试一下泛型嵌套
* 创建两个泛型类
* 1.class GenericNest<T,T1>
* 2.class GenericNest1<V>
* @author Mixi
*
*/
//泛型类1
class GenericNest<T,T1> {
//成员变量
private T name;
private T1 address;
//构造方法
public GenericNest() {
// TODO Auto-generated constructor stub
}
public GenericNest(T name, T1 address) {
super();
this.name = name;
this.address = address;
}
//get/set方法
public T getName() {
return name;
}
public void setName(T name) {
this.name = name;
}
public T1 getAddress() {
return address;
}
public void setAddress(T1 address) {
this.address = address;
}
}
//泛型类2
class GenericNest1<V>{
//成员变量
private V user;
//构造方法
public GenericNest1() {
// TODO Auto-generated constructor stub
}
public GenericNest1(V user) {
super();
this.user = user;
}
public V getUser() {
return user;
}
public void setUser(V user) {
this.user = user;
}
}
2.测试类
package generic;
/**
* 测试类
* 测试泛型嵌套效果
* 其实泛型嵌套就是无线套娃,将第一个类的泛型当成第二个类的泛型,从而第二个类的泛型可以获取到第一个类的值,且第二个类还可以有多个泛型
* 下面的例子GenericNest1<V>,其实还可以加多个泛型eg:GenericNest1<V,V1,T...>
* @author Mixi
*
*/
public class GenericNestTest {
public static void main(String[] args) {
//创建一个GenericNest对象 一般在创建对象时就需要传入具体引用类型
//GenericNest<T,T1> g1 = new GenericNest<T,T1>(); //
/*GenericNest<String,String> g1 = null; //传入引用类型才不会报错
GenericNest1<GenericNest<String,String>> g2 = null;//GenericNest1的泛型装的是GenericNest
g1 = new GenericNest<String,String>("你好","帅哥");
g2 = new GenericNest1<GenericNest<String,String>>(g1);//这里类型只能是<GenericNest<String,String>>,传入g1
*/ GenericNest<String,String> g3 = new GenericNest<String,String>("帅哥","上海");
GenericNest1<GenericNest<String,String>> g4 = new GenericNest1<GenericNest<String,String>>(g3);
//输出结果
System.out.println(g4.getUser().getName());//帅哥
System.out.println(g4.getUser().getAddress()); //上海
}
}
结论:
测试泛型嵌套效果
* 其实泛型嵌套就是无线套娃,将第一个类的泛型当成第二个类的泛型,从而第二个类的泛型可以获取到第一个类的值,且第二个类还可以有多个泛型
* 下面的例子GenericNest1<V>,其实还可以加多个泛型eg:GenericNest1<V,V1,T...>
自己的一个小结论,回到定义学生类,其实也可以用到泛型,就不用分别定义int String .类型。直接泛型类定义学生类,直接避免了在设计初期就把类型写死的尴尬场景。