泛型

格式

访问权限 class 类名<泛型名称 1,泛型名称 2..>{			//泛型类
	访问权限 泛型名称 变量名;		//泛型属性
	访问权限 返回值类型 方法名<泛型名称>{
        
    }
}

泛型就是不确定的类型，在实例化或者调用的时候，从外部指定类型。如果不用泛型的话，类或者方法就只能固定是某一个类型

举个栗子

class Me<T>{			//T可以是任意字符，类型根据外部调用而定
	private T name;
	
    public void setName(T name){
        this.name=name;
    }
    
    public T getName(){
        return name;
    }
}

public class Main{
    public static void main(){
        Me<String> info=new Me<>();		//把类型指定为String，此时Me类中所有T = String
        info.setName("LIXIAONIAN");	
        System.out.println(info.getName);
        
        Me<Integer> num=new Me<>();		//类型指定为Integer，此时Me类中所有T = Integer
        info.setName(872);
        System.out.println(info.getName);
    }
}

多个泛型

一个类中有两个不同的类型，使用的时候也是根据外部选择的类型

class Me<T,E>{
	private T name;
    private E age;
    
    public Me(T name,E age){			//构造方法
        this.name=name;
        this.age=age;
    }
    
    public void setName(T name){
        this.name=name;
    }
    
    public void setAge(E age){
        this.age=age;
    }
    
    public T getName(){
        return name;
    }
    
    public E getAge(){
        return age;
    }
}

泛型安全警告

如果外部定义的时候，没有选择泛型类型，就会出现安全警告

上面没有指定类型，正确的写法是：

通配符

用于调用泛型对象时

public static void main(String[] args) {
    Zyy<String> info=new Zyy<>();		//定义对象，指定泛型为String
    info.setName("NIHAO");
    fun(info);		//调用fun()
}

public static void fun(Zyy temp){		//警告，Zyy是未指定类型的泛型类
    System.out.println(temp.getName());
}
//如果指定一种类型，那么只能传递这种类型的参数
//所以通配符来了，正确写法是：
public static void fun(Zyy<?> temp){	//Zyy<?> 表示可以使用任意类型的参数
    System.out.println(temp.getName());
}

受限泛型

上限：

class Me<T extends Number>{}		//这里的泛型类型只能指定Number的子类

格式如上所述，就是继承一个类，然后这个泛型的类型只能是这个类的子类

如果不是继承的类的子类，就会报错，就像上面只能是Number的子类(Integer,Byte,Short…)

下限：

class Me<T super String>{}		//这里泛型类型只能是String或者String的父类(Object)

用于通配符限制泛型类型

public void fun(Me<? extends Number> info){}	
//这里的通配符 ? 就会被限制为Number的子类

总结

泛型使得参数的传递很灵活方便，不用泛型那么只能传递一种类型的参数。泛型相当于是暂时设置一个标记，外部调用的时候再决定真正的类型