83.Java泛型

泛型(Generic)

当集合中存储的对象类型不同时，那么会导致程序在运行的时候的转型异常

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

public class Demo5 {
    public static void main(String[] args) {
        ArrayList arr = new ArrayList();
        arr.add(new Tiger("华南虎"));
        arr.add(new Tiger("东北虎"));
        arr.add(new Sheep("喜羊羊"));
        System.out.println(arr);
        Iterator it = arr.iterator();
        while (it.hasNext()) {
            Object next = it.next();
            Tiger t = (Tiger) next;
            t.eat();
        }

    }
}
class Tiger {
    String name;

    public Tiger() {

    }

    public Tiger(String name) {
        this.name = name;
    }

    @Override
    public String toString() {

        return "Tiger@name:" + this.name;
    }

    public void eat() {
        System.out.println(this.name + "吃羊");
    }
}

class Sheep {
    String name;

    public Sheep() {

    }

    public Sheep(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Sheep@name:" + this.name;
    }

    public void eat() {
        System.out.println(this.name + "吃青草");
    }
}

原因 :发现虽然集合可以存储任意对象,但是如果需要使用对象的特有方法,那么就需要类型转换,如果集合中存入的对象不同,可能引发类型转换异常.

[Tiger@name:华南虎, Tiger@name:东北虎, Sheep@name:喜羊羊]
华南虎吃羊
东北虎吃羊
Exception in thread "main" java.lang.ClassCastException: cn.itcast.gz.map.Sheep cannot be cast to cn.itcast.gz.map.Tiger
    at cn.itcast.gz.map.Demo5.main(Demo5.java:17)

出现问题:

存入的是特定的对象,取出的时候是Object对象,需要强制类型转换,可能诱发类型转换异常.

无法控制存入的是什么类型的对象,取出对象的时候进行强转时可能诱发异常.而且在编译时期无法发现问题.

虽然可以再类型转换的时候通过if语句进行类型检查(instanceof),但是效率较低.(例如吃饭的时候,还需要判断米饭里有没有沙子,吃饭效率低).可以通过给容器加限定的形式规定容器只能存储一种类型的对象.

就像给容器贴标签说明该容器中只能存储什么样类型的对象。

所以在jdk5.0后出现了泛型

泛型应用:

格式

1. 集合类<类类型>  变量名  = new  集合类<类类型>();

public class Demo5 {
    public static void main(String[] args) {
        // 使用泛型后,规定该集合只能放羊,老虎就进不来了.
        ArrayList<Sheep> arr = new ArrayList<Sheep>();
        arr.add(new Sheep("美羊羊"));
        arr.add(new Sheep("懒洋洋"));
        arr.add(new Sheep("喜羊羊"));
        // 编译失败
        // arr.add(new Tiger("东北虎"));
        System.out.println(arr);
        Iterator<Sheep> it = arr.iterator();
        while (it.hasNext()) {
            // 使用泛型后,不需要强制类型转换了
            Sheep next = it.next();
            next.eat();
        }

    }
}

1. 将运行时的异常提前至编译时发生。

2. 获取元素的时候无需强转类型，就避免了类型转换的异常问题

格式  通过<> 来指定容器中元素的类型.

什么时候使用泛型:当类中操作的引用数据类型不确定的时候,就可以使用泛型类.

JDK5.0之前的Comparable

package java.lang;
public interface Comparable {

    public int compareTo(Object o);
}

JDK5.0之后的Comparable

package java.lang;
public interface Comparable<T> {

    public int compareTo(T o);
}

这里的<T>表示泛型类型,随后可以传入具体的类型来替换它.

细节一

声明好泛型类型之后,集合中只能存放特定类型元素

public class Demo6 {
    public static void main(String[] args) {
        //创建一个存储字符串的list
        ArrayList<String> arr=new ArrayList<String>();
        arr.add("gz");
        arr.add("itcast");
        //存储非字符串编译报错.
        arr.add(1);
    }
}

细节二:

泛型类型必须是引用类型

public class Demo6 {
    public static void main(String[] args) {
        // 泛型类型必须是引用类型,也就是说集合不能存储基本数据类型
        // ArrayList<int> arr2=new ArrayList<int>();

        // 使用基本数据类型的包装类
        ArrayList<Integer> arr2 = new ArrayList<Integer>();
        
        
    }
}

细节三: 使用泛型后取出元素不需要类型转换.

public class Demo6 {
    public static void main(String[] args) {

        ArrayList<String> arr = new ArrayList<String>();
        arr.add("gzitcast");
        arr.add("cditcast");
        arr.add("bjitcast");
        //使用泛型后取出元素不需要类型转换.
        String str=arr.get(0);
        System.out.println();
    }
}