泛型的使用方法以及注意事项

/*1使用泛型可以解决类型转换的问题：在编译器发现问题，而不是运行期才发现
 * 2泛型只能是引用类型，不能是基本类型
 * 3方法中如果有泛型，那么传入的参数类型必须和方法中声明的类型完全一致
 * 如果希望方法中的泛型可以接收任意类型那么不能使用object，可以使用通配符？(问号)
 * 4一个泛型类的参数可以是一般的引用类型的参数，也可以是一个泛型类
 * 5泛型类可以是继承泛型类
 * 6在泛型中不可以用泛型的变量加一个泛型的变量
 * */
class    More<K, V> {//多种参数类型的泛型
K lonK;
V latV;


public More(K lonK, V latV) {
super();
this.lonK = lonK;
this.latV = latV;
}
//多参类型的返回值方法
public K getNumber(K number) {
return number;
}
}
public class Generic<T> {
//只用一个参数的泛型
T lon, lat;
//泛型的构造方法
public Generic(T lon, T lat) {
super();
this.lon = lon;
this.lat = lat;
}



//用来测试泛型的主函数
public static void main(String[] args) {
//单独参数类型的泛型的引用
Generic<String> g = new Generic<String>("东经120", "北纬31");
/*
* String lon=g.lon; String lat=g.lat;
*/
System.out.println(g.lat);
/*
* System.out.println(lon); System.out.println(lat);
*/
Generic<Integer> g2 = new Generic<>(120, 31);
int lat1 = g2.lat;//对象的类型转换并
int lon1 = g2.lon;
System.out.println(lat1);
System.out.println(lon1);
//创建一个基本类型的字符串泛型并开辟内存空间
Base<String> base = new Base<>();
//多种参数类型的泛型的调用
More<String, Integer> g3 = new More<String, Integer>("东经120", 30);
System.out.println(g3.latV);
/*
* String b=base; System.out.println(base);
*/
show2(base);// 表明现在泛型可以接收任意类型




//创建一个新的泛型类其参数为一个泛型类
GenDemo<GenDemo<Stud>> gen1=new GenDemo<GenDemo<Stud>>();
GenDemo<Stud> gen2=new GenDemo<Stud>();//参数泛型类的创建
gen2.setData(new Stud("zhangsan"));//参数泛型类的参数赋值
gen1.setData(gen2);
System.out.println(gen1.getData().getData());

//泛型继承泛型的测试
SubClass <String,Integer> sub=new SubClass<String, Integer>("zhangsan",20);
System.out.println(sub.show1());
}


public static void show1(Base<Object> b) {


}


// 使用通配符？(无限定型)来使用泛型可以接收任意类型
public static void show2(Base<?> b) {


}


public static void show3(Base<? extends Number> b) {
// 表示传入的泛型只能是number及其子类(有上限型通配符)
}


public static void show4(Base<? super String> b) {
// 表示泛型只能是string及其父类(有下限型通配符)
}
}


class Base<K> {
}


class IntegerDemo {
Integer i = 2;
int a = i;
/*
* 包装类如何与字符串相互转换 包装类转换字符串
*/
String i2 = "" + 5;
String i3 = String.valueOf(i);
// 字符串转换基本类型
int i4 = Integer.valueOf(i2);
}




//创建一个学生对象作为最终的参数
class Stud{
private String name;
public Stud  (String name) {
this.name=name;
}
public String  toString () {
return "我是："+name;
}
}
class GenDemo <T>{//创建一个泛型类
private T data;
//定义一个无参的泛型 方法和下面的构成重载
public GenDemo () {
}
public GenDemo (T data) {
this.data=data;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}

}
//创建一个父类让子类去继承
class SuperClass<T1>{
private T1 var1;
public SuperClass (T1 var1) {
this.var1=var1;
}
public T1 show1() {
return var1;
}
}
//创建一个接口让子类泛型去实现
interface IInfor<T2>{
public void show2(T2 var2) ;
}
//创建一个子类，并继承父类实现他的方法,实现一个接口
class SubClass<T1,T2>extends SuperClass<T1> implements IInfor<T2>{
private T2 var2;
//构造方法
public SubClass(T1 var1, T2 var2) {
super(var1);
this.var2 = var2;
}
public T1 show1() {
return super.show1();
}
//实现接口的方法
public void show2(T2 var3) {
System.out.println(var3);
System.out.println(var2);
}
}