对 Java 中泛型理解

泛型的概念

  1. 泛型是一种末知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型
  2. 泛型也可以看成是一个变量用来接收数据类型
  3. E e：Element元素
  4. T t：Type类型

有无使用泛型的对比

不使用泛型

创建集合对象，不使用泛型

  1. 好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据。

    举例：

    public class Demo01Generic {
    public static void main(String[] args) {
        // 集合不使用泛型
        ArrayList arrayList = new ArrayList();

        // 向集合中添加数据，用于测试，这里添加了String类型的数据，和int类型的数据
        arrayList.add("ABC");
        arrayList.add(123);

        // 使用迭代器遍历集合
        // 第一步：获取送代器的实现类对象，并使用Iterator接口接收
        Iterator ite = arrayList.iterator();
        // 第二步：使用hasNext方法和next方法遍历集合，取出的元素的类型默认是Object类型
        while (ite.hasNext()) {
            System.out.println(
                    ite.next()
            );
        }
    }
}

    输出结果：
ABC
123

  2. 弊端：不安全，会引发异常

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

        ArrayList arrayList = new ArrayList();

        arrayList.add("ABC");
        arrayList.add(123);

        Iterator ite = arrayList.iterator();
        while (ite.hasNext()) {
            // 取出的数据，默认是Object类型
            Object object = ite.next();

            // 假如想使用String特有的length方法来获取字符串的长度，是不可以的
            // 需要将Object类型向下转型为String类型才能使用它的特有方法
            // 但是集合里面还有数据类型是Integer的数据，所以不能进行向下转型为String类型，
            // 如果强行转换，那么在运行是会抛出ClassCastException异常
            String string = (String)object;
            System.out.println(string.length());
        }
    }
}

    抛出错误：
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at XXXXXX.main(Demo02Generic.java:36)

使用泛型

创建集合对象，使用泛型

  1. 好处：
    1. 避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
    2. 把运行期昇常，提升到了编译期
  2. 弊端：泛型是什么类型，只能存储什么类型的数据

举例：

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

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

        ArrayList<String> arrayList = new ArrayList<>();

        arrayList.add("ABC");
        // 假如添加的数据的类型不是String类型，
        // 那么会抛出错误：方法 java,util.Collection.add(java.lang.String)不适用
        // arrayList.add(123);

        Iterator<String> ite = arrayList.iterator();
        while (ite.hasNext()) {

            String string = ite.next();

            System.out.println(
                    string.length()
            );
        }
    }
}

输出结果：
3

定义和使用含有泛型的类

说明

  1. 泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

  2. 定义和使用含有泛型的类：

    定义格式：

    修饰符 class 类名称<代表泛型的变量> { . . . }

举例

  1. 创建一个含有泛型的类

    public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

  2. 使用这个类

    public class DemoGenericClass {
    public static void main(String[] args) {
        // 使用泛型
        GenericClass<String> name1 = new GenericClass<>();
        name1.setName("使用泛型：这里只能添加指定类型的数据");
        String string = name1.getName();
        System.out.println(string);

        // 不使用泛型，默认是Object类型
        GenericClass name2 = new GenericClass();
        name2.setName("不使用泛型：这里能添加不同类型的数据");
        Object object = name2.getName();
        System.out.println(object);
    }
}

  3. 输出结果

    使用泛型：这里只能添加指定类型的数据
不使用泛型：这里能添加不同类型的数据

定义和使用含有泛型的方法

说明

  1. 定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间。

  2. 格式：

    修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)) {
    方法体
}

  3. 含有泛型的方法，在调用方法的时候确定泛型的数据类型。传递什么类型的参数，泛型就是什么类型。

举例

  1. 定义含有泛型的方法

    public class GenericMethod {
    /**
     * 定义一个含有泛型的方法
     */
    public <W> String method1(W w) {
        return  "一个含有泛型的方法：" + w;
    }

    /**
     * 定义一个含有泛型的静态方法
     */
    public static <Z> String method2(Z z) {
        return  "一个含有泛型的静态方法：" + z;
    }
}

  2. 使用这两个方法

    public class DemoGenericMethod {
    public static void main(String[] args) {
        // 创建类对象
        GenericMethod gm = new GenericMethod();

        // 调用含有泛型的普通方法
        System.out.println(
                gm.method1(666)
        );
        System.out.println(
                gm.method1("ABC")
        );
        System.out.println(
                gm.method1(0.999)
        );

        // 调用含有泛型的静态方法
        // 可以使用gm.method2()来调用静态方法
        // 不推荐使用创建对象来调用静态方法，推荐直接用类名称来调用
        System.out.println(
                GenericMethod.method2(666)
        );
        System.out.println(
                GenericMethod.method2("ABC")
        );
        System.out.println(
                GenericMethod.method2(0.999)
        );
    }
}

  3. 输出结果

    一个含有泛型的普通方法：666
一个含有泛型的普通方法：ABC
一个含有泛型的普通方法：0.999
一个含有泛型的静态方法：666
一个含有泛型的静态方法：ABC
一个含有泛型的静态方法：0.999

定义和使用含有泛型的接口

说明

  1. 含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型。
  2. 含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型。

举例

例子1

  1. 定义一个含有泛型的接口

    public interface GenericInterface<I> {
    /**
     * 接口的抽象方法
     * @param i 泛型参数
     */
    public abstract void method(I i);

}

  2. 创建接口实现类

    public class GenericInterfaceImplement implements GenericInterface<String>{
    @Override
    public void method(String s) {
        System.out.println(
                "含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型\n" 
                        + "这个方法传入指定类型参数是：" + s
        );
    }
}

  3. 测试含有泛型的接口

    public class DemoGenericInterfaceImplement {
    public static void main(String[] args) {
        GenericInterfaceImplement gii = new GenericInterfaceImplement();

        gii.method("666999");
    }
}

  4. 输出结果：

    含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型
这个方法传入指定类型参数是：666999

例子2

  1. 创建一个含有泛型的接口

    public interface GenericInterface<I> {
    /**
     * 接口的抽象方法
     * @param i 泛型参数
     */
    public abstract void method(I i);

}

  2. 创建接口的实现类

    public class GenericInterfaceImplement<I> implements GenericInterface<I>{

    @Override
    public void method(I i) {
        System.out.println(
                "含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走\n"
                        + "创建对象的时候传入指定类型参数是：" + i
        );
    }
}

  3. 测试含有泛型的接口

    public class DemoGenericInterfaceImplement {
    public static void main(String[] args) {
        GenericInterfaceImplement01<Integer> gii = new GenericInterfaceImplement01<>();

        gii.method(2020);
    }
}

泛型通配符

  1. 通配符基本使用泛型的通配：不知道使用什么类型来接收的时候，此时可以使用?，?表示未知通配符，即：表示任意的数据类型。
  2. 使用方式：不能创建对象使用，只能作为方法的参数使用。
  3. 注意：一但使用泛型的通配符，那么，只能使用Object类中的共性方法，集合中元素的自身方法无法使用。

举例

  1. 创建一个遍历集合的方法

    public class IteratorArrayList {
    // 由于不知道接收的ArrayList的数据是什么类型，所以使用泛型通配符?
    public static void printArrayList(ArrayList<?> arrayList) {
        // 使用迭代器遍历集合
        Iterator<?> ite = arrayList.iterator();
        while (ite.hasNext()) {
            // next()方法取出的元素是Object，可以接收任意的数据类型
            Object object = ite.next();
            System.out.println(object);
        }
    }
}

  2. 测试这个方法

    public class DemoIteratorArrayList {
    public static void main(String[] args) {
        // Integer类型数据
        ArrayList<Integer> arrayList1 =  new ArrayList<>();
        arrayList1.add(1);
        arrayList1.add(2);
        arrayList1.add(3);
        arrayList1.add(4);
        arrayList1.add(5);
        // 遍历Integer数据类型的集合
        IteratorArrayList.printArrayList(arrayList1);

        System.out.println("==========================================");

        // String数据类型
        ArrayList<String> arrayList2 =  new ArrayList<>();
        arrayList2.add("一号元素");
        arrayList2.add("二号元素");
        arrayList2.add("三号元素");
        arrayList2.add("四号元素");
        arrayList2.add("五号元素");
        // 遍历String数据类型的集合
        IteratorArrayList.printArrayList(arrayList2);
    }
}

  3. 输出结果：

    1
2
3
4
5
==========================================
一号元素
二号元素
三号元素
四号元素
五号元素
posted @ 2020-01-13 01:29  LeeHua  阅读(405)  评论(0)  编辑  收藏  举报