JAVA泛型基础

JAVA泛型

泛型类

泛型类的基本概念： 泛型类就是将类型作为参数传递给泛型类，然后泛型类中的所有方法就根据你传递的类型参数来决定

举个例子

*定义一个泛型类

public class GeneralType <Type>{
    Type object;
    public GeneralType(Type object)
    {
        this.object = object;
    }
    public Type getObj()
    {
        return object;
    }
}

---

我们在定义一个测试类来使用这个泛型类

public class Test{
    public static void main(String[] args) {
        ShowType st = new ShowType();
        GeneralType<Integer> i = new GeneralType<Integer>(2);
        GeneralType<String> s = new GeneralType<String>("Hello");
        System.out.println("i.object="+(Integer)i.getObj());
    }
}

我们看这一行代码的输出结果System.out.println("i.object="+(Integer)i.getObj());

i.object=2

如果我们输入这一行代码System.out.println("s.object="+(Integer)s.getObj());

编译就会报错，因为我们传进去的Type是String,所以object的类型是String,不能转化为Integer

从上面的例子可以看到，泛型类就是根据你传入的类型参数来决定该类中的方法应该处理什么类型的数据，像一些容器也是泛型类，容器中可以装各种类型的数据

---

泛型方法

泛型方法基本概念：泛型方法中的参数类型可根据传入的参数进行相应的改变

举个例子

定义一个泛型方法

Class GeneralMethod
{
    <Type> void printClassName(Type object)
    {
        System.out.println(object.getClass().getName());
    }
}

---

定义一个测试类

public class Test{
    public static void main(String[] args) {
        GeneralMethod gm = new GeneralMethod();
        gm.printClassName("Hello");
        gm.printClassName(3);
    }
}

这样输出的结果为

java.lang.String
java.lang.Integer

因为我们传入的参数不同，所以泛型函数的处理也不同

通配符

**基本概念：**我们知道，在前面的泛型类中，实例化了各种不同参数的对象，如果我们要处理这些对象时，不知道对象的object,那就没法处理了，因此我们可以使用通配符

举个例子

定义一个泛型类

public class GeneralType <Type>{
    Type object;
    public GeneralType(Type object)
    {
        this.object = object;
    }
    public Type getObj()
    {
        return object;
    }
}

再定义一个用来输出泛型类实例化对象的object的类

public class ShowType {
    public void show(GeneralType<?> o)
    {
        System.out.println(o.getObj().getClass().getName());
    }
}

再使用测试类来测试

public class Test{
    public static void main(String[] args) {
        ShowType st = new ShowType();
        GeneralType<Integer> i = new GeneralType<Integer>(2);		
		GeneralType<String> s = new GeneralType<String>("Hello");
        st.show(i);
        st.show(s);
    }
}

输出的结果为

java.lang.Integer
java.lang.String

如果不使用通配符，直接以泛型类作为show的参数，那么编译会报错

有限制的泛型

**基本概念：**如果你定义的泛型类不希望接收所有的类型参数，那么你可以使用受限制的泛型类

基本语法：public class GeneralType <Type extends 某一类>

这样，如果你传入的参数Type不是"某一类"的子类的话，那么编译就会报错

举个例子：

定义一个受限制的泛型类

public class GeneralType <Type extends Number>{
    Type object;
    public GeneralType(Type object)
    {
        this.object = object;
    }
    public Type getObj()
    {
        return object;
    }
}

定义一个测试类

public class Test{
    public static void main(String[] args) {
        GeneralType<Integer> i = new GeneralType<Integer>(2);		
//		GeneralType<String> s = new GeneralType<String>("Hello");
        System.out.println(i.getObj().getClass().getName());
    }
}

注释掉的那一行因为String不是Number的子类，所以不能使用GeneralType泛型类