Java 泛型的参数、类与方法

---

泛型

• 泛型的本质是类型参数化，也就是将数据类型指定为一个参数，继而变成一个类型的变量，提高了代码的可读性；
• 泛型最大的优点是提供了类型安全；

---

1. 泛型参数

a. 未知通配符 ?

• 当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符 <?> 表示；
• 泛型不写或者用 <?> 表示，都默认是 Object；

import java.util.ArrayList;
import java.util.Collection;

public class test {
    public static void getElement(Collection<?> coll) {
        System.out.println("Java 通配符");
    }

    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        getElement(list1);
        Collection<String> list2 = new ArrayList<String>();
        getElement(list2);
    }
}

b. 限定泛型参数

• 可以对泛型的参数类型进行限定；
• 分为泛型的上限 <? extends 类 >（只能接收该类型及其子类）和泛型的下限 <? super 类 >（只能接收该类型及其父类型）；
• 例如，数据类型 Byte Double Float Integer Long Short 是 Number 类的子类，把类型参数限定为 Number 后只有 Number 的子类才能作为实际类型参数；

class ltdArray<T extends Number> {
    int n;
    int index;
    Object arr[];

    ltdArray(int n) {
        this.n = n;
        index = 0;
        arr = new Object[n];
    }

    public void add(T obj) {
        arr[index++] = obj;
    }

    public int length() {
        return index;
    }

    public T indexOf(int i) {
        return (T) arr[i];
    }
}

public class test {
    public static void main(String[] args) {
        ltdArray<Integer> arr = new ltdArray<Integer>(2);
        arr.add(1);
        arr.add(2);
        for (int i = 0; i < arr.length(); i++) {
            System.out.println(arr.indexOf(i));
        }
    }
}

c. 可变方法参数

• 可以通过泛型，让方法的形参个数可变；

public class test {
    static <T> void print(T t) {
        System.out.println("1. " + t);
    }

    static <T> void print(T... ts) {//形参是可变参数的泛型方法
        System.out.print("2. ");
        for (int i = 0; i < ts.length; i++)
            System.out.print(ts[i] + " ");
        System.out.println();
    }

    public static void main(String args[]) {
        print("s");//输出1. s
        print("s", "s");//输出2. s s
        print("My age is ", 18);//输出2. My age is  18
    }
}

d. 多个泛型参数

• 一个参数区中可以存在多个泛型参数，用 , 隔开；

---

2. 泛型类与接口

• 类是对属性和行为的封装，泛型类可以将封装方式相同但属性类型不同的多个类用一个泛型表示；
• 泛型类或泛型接口通过类型参数来抽象数据类型，类型参数可以用来指定成员变量、方法的参数或方法返回值的类型；

interface G<T> {
    void add(T obj);

    int length();

    T indexOf(int i);
}

class Array<T> implements G<T> {
    int n;
    int index;
    Object arr[];

    Array(int n) {
        this.n = n;
        index = 0;
        arr = new Object[n];
    }
    
	@Override
    public void add(T obj) {
        arr[index++] = obj;
    }
    
	@Override
    public int length() {
        return index;
    }
    
	@Override
    public T indexOf(int i) {
        return (T) arr[i];//强转为指定类型，保证输出值的类型安全
    }
}

public class test {
    public static void main(String[] args) {
        Array<Integer> arr = new Array<Integer>(2);
        arr.add(1);//如果不是指定类型，编译时会报错，不加泛型约束不会报错
        arr.add(2);
        for (int i = 0; i < arr.length(); i++) {
            System.out.println(arr.indexOf(i));
        }
    }
}

---

3. 泛型方法

public class test{
	//定义有一个类型参数的泛型方法,如果void变成T则法返回值类型也为T
	public static <T> void function(T t) {
		System.out.println(t);
	}
	public static void main(String[] args) {
		function("s");
		function(1);
	}
}