Java知识点--泛型

为什么使用泛型

举一个例子

如果不使用泛型，我们想获取Dog对象的name和age，在遍历的过程中就需要向下转型，因为如果不使用泛型，集合中元素的数据类型默认是Object，所以必须向下转型，才能获取name和age。但是严重影响了程序的运行效率。

import java.util.ArrayList;
import java.util.Iterator;

public class Generic01 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("jack", 3));
        arrayList.add(new Dog("tom", 5));
        arrayList.add(new Dog("james", 4));
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            Dog dog1 = (Dog) next;
            System.out.println("name=" + dog1.getName() + "," + "age=" + dog1.getAge());
        }
    }
}
class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

所以需要使用泛型对程序进行改进。

改进版

创建集合时，在<>中填写数据类型，填写后，集合中元素的数据类型就是填写的数据类型。
因此在下面的例子中，集合中只能加入Dog类，所以想获取Dog对象的name和age，就不需要向下转型，提高了程序的运行效率。

import java.util.ArrayList;
import java.util.Iterator;

public class Generic02 {
    public static void main(String[] args) {
        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog("jack", 10));
        dogs.add(new Dog("tom", 1));
        dogs.add(new Dog("sam", 5));
        Iterator<Dog> iterator = dogs.iterator();
        while (iterator.hasNext()) {
            Dog next = iterator.next();
            System.out.println(next.getName() + "," + next.getAge());
        }
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

泛型的注意事项

1、泛型只能是引用类型。
ArrayList< Integer > arraylist1 = new ArrayList<>();（√）
ArrayList< int > arraylist2 = new ArrayList<>();（×）
2、指定泛型后，可以传入该类型或其子类。
例如：ArrayList< Object > arraylist1 = new ArrayList<>();
arraylist1.add(“jack”);
arraylist1.add(10);
因为String和Integer都是Object的子类。
3、普通成员可以使用泛型。
4、使用泛型的数组，不可初始化。
例如：T arr[ ] = new T [8];（×）
因为数组需要根据数据类型进行开辟空间，而现在数据类型不确定，所以无法开辟空间。
5、<?>:支持所有泛型类型。
<? extends A>:支持A类及A的子类。
<? super A>:支持A类及A的父类。

重点：方法使用泛型与泛型方法不同

泛型方法

语法：访问修饰符 < T，R…> 返回类型 方法名（参数列表）{}

class A <T,R>{
	public<E> void m1(E e){
	}
}	

1、泛型方法可以定义在普通类中，也可以定义在泛型类中。
2、泛型方法被调用时，类型会确定。
例如: A < String，Double> a = new A();
a.m1(10);
说明E的数据类型是Integer。
3、泛型方法可以使用静态方法。

class A <T,R>{
	public static<E> void m1(E e){
	}
}	

使用 A.m1(10);就可以确定E的数据类型是Integer。

方法使用泛型

方法的参数类型是类的泛型。

class Person<E> {
    public void m1(E e){
    }
}

静态方法不能使用泛型。

class Person<E> {
    public static void m1(E e){
    }
}

因为泛型类的类型是在创建对象时才可以确定，但是静态方法不需要创建对象即可调用，因此该方法的参数类型无法确定。