泛型

泛型

泛型的概述与好处

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
好处:
1. 把运行时期出现的问题提前到了编译期间
2. 避免了强制类型转换
实例

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
//注释的代码是不用泛型的代码
public class generics01 {
    public static void main(String[] args) {
//        Collection c = new ArrayList();
        Collection<String> c = new ArrayList<>();
        c.add("hello");
        c.add("world");
        c.add("java");
//        c.add(100);  把本该运行时出现的问题提前到了编译时期

//        Iterator it = c.iterator();
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
//            String s = (String) it.next();//ClassCastException
            String s = it.next();//不用强制类型装换
            System.out.println(s);
        }
    }
}

泛型类

java 中泛型标记符：

标记符	英文字母	含义
E	Element	元素
T	Type	Java类
K	Key	键
V	Value	值
N	Number	数值类型
?		表示不确定的Java类

实例

/*
    创建一个泛型类
 */
public class generics02<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}
/*
    测定类
 */
//通过一个类完成多个类的操作
class generics02Deom{
    public static void main(String[] args) {
        generics02<String> g1 = new generics02<>();
        g1.setT("冷冷");
        System.out.println(g1.getT());

        generics02<Integer> g2 = new generics02<>();
        g2.setT(18);
        System.out.println(g2.getT());

        generics02<Boolean> g3 = new generics02<>();
        g3.setT(true);
        System.out.println(g3.getT());
    }
}

泛型方法

你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

下面是定义泛型方法的规则：

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的 ）。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）。
  实例

public class generics03 <T>{
//    public void show(String s){
//        System.out.println(s);
//    }
//
//    public void show(Integer i){
//        System.out.println(i);
//    }
//
//    public void show(Boolean flag){
//        System.out.println(flag);
//    }
    //泛型类的泛型方法 改进
    public void show(T t){
        System.out.println(t);
    }
}

/*
    测试类
 */
class generics03Demo{
    public static void main(String[] args) {
//        generics03 g = new generics03();
//        g.show("杨幂");
//        g.show(18);
//        g.show(false);
//        System.out.println("--------");
        generics03<String> g1 = new generics03<>();
        g1.show("杨幂");

        generics03<Integer> g2 = new generics03<>();
        g2.show(18);

        generics03<Boolean> g3 = new generics03<>();
        g3.show(true);
    }
}

泛型接口

/*
    泛型接口
 */
public interface generics04<T> {
    void show(T t);
}
/*
    泛型接口实现类
 */
class generics04Imp <T> implements generics04<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}
/*
    测试类
*/
class generics04Demo{
    public static void main(String[] args) {
        generics04<String> g1 = new generics04Imp<>();
        g1.show("杨幂");

        generics04<Integer> g2 = new generics04Imp<>();
        g2.show(17);
    }
}

类型通配符

类型通配符：< ？>
List<?>:表示元素类型未知的list,它的元素可以匹配任何的类型
这种带通配符的list仅表示它是各种泛型list的父类，并不能把元素添加到其中

• 类型通配符上限：<? extends 类型 >
  List<? extends Number>它表示的类型是Number或者其子类型
• 类型通配符下限：<? super 类型 >
  List<? super Number>它表示的类型是Number或者其父类型
  实例

public class generics05 {
    public static void main(String[] args) {
        /*
        java.lang.Object
            java.lang.Number
                java.lang.Integer
         */

        // 类型通配符：<？>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();

        // 类型通配符上限：<? extends 类型 >
//        List<? extends Number> list4 = new ArrayList<Object>();// 父类
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();// 子类

        // 类型通配符上限：<? super 类型 >
//        List<? super Number> list7 = new ArrayList<Integer>();//子类
        List<? super Number> list8 = new ArrayList<Number>();
        List<? super Number> list9 = new ArrayList<Object>();
    }
}