【Java笔记】（七）：泛型

介绍

泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型

它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

泛型定义格式：

• <类型>:指定一种类型的格式。这里的类型可以看成是形参
• <类型1,类型2…>:指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
• 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

泛型的优点

先看这段代码，这样就报错了！

public class Test {
    public static void main(String[] args) {
        ArrayList<Object> objectArrayList = new ArrayList<>();
        
        objectArrayList.add("hello");
        objectArrayList.add("world");
        objectArrayList.add(666);
        
        Iterator<Object> iterator = objectArrayList.iterator();
        while (iterator.hasNext()) {
            //报错java.lang.ClassCastException: 
            //java.lang.Integer cannot be cast to java.lang.String
            String next = (String) iterator.next();
            System.out.println(next);
        }
    }
}

ArrayList使用了泛型，我们可以指定具体类型的数据

public class Test {
    public static void main(String[] args) {
        ArrayList<String> objectArrayList = new ArrayList<>();
        
        objectArrayList.add("hello");
        objectArrayList.add("world");
        //objectArrayList.add(666);不能写，将运行时期的异常提前到了编译期
        
        Iterator<Object> iterator = objectArrayList.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();//不用强制转换
            System.out.println(next);
        }
    }
}

使用泛型的好处：

• 将运行时期的异常提前到了编译期
• 避免了类型强制转换（因为指定了固定的类型，所以只能放一种类型）

泛型类（创建对象的时候明确类型）

泛型类的定义格式：T可以写成任意字母，一般使用T、E、K、V

public class Generic<T> {
	//
}

泛型类

public class Generic<T> {
    private T name;

    public void setName(T name) {
        this.name = name;
    }
    
    public T getName() {
        return name;
    }
}

泛型测试类

public class GenericTest {
    public static void main(String[] args) {
        Test<String> test = new Test<>();//指定T为String类型
        test.setName("小黑龙");
        System.out.println(test.getName());
    }
}

泛型方法（调用方法的时候明确类型）

先看看这段代码

public class Test {
    public void show(String s) {
        System.out.println(s);
    }

    public void show(Integer s) {
        System.out.println(s);
    }

    public void show(Boolean s) {
        System.out.println(s);
    }
}

使用泛型类进行改善

public class Test<T> {
    public void show(T t) {
        System.out.println(t);
    }
	//但是使用的时候每次都需要去规定T的类型
    public static void main(String[] args) {
        Test<String> stringTest = new Test<>();
        stringTest.show("11111");

        Test<Integer> integerTest = new Test<>();
        integerTest.show(11111);

        Test<Boolean> booleanTest = new Test<>();
        booleanTest.show(true);
    }
}

泛型方法格式：帅到爆炸！！！酷毙了

public class Test {
    public <T> void show(T t) {
        System.out.println(t);
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.show("1111");
        test.show(1111);
        test.show(true);
    }
}

泛型接口

泛型接口：

public interface Generic<T> {
    void show(T t);
}

泛型实现类：

public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        GenericImpl<String> generic1 = new GenericImpl<>();
        generic1.show("11111");

        GenericImpl<Integer> generic2 = new GenericImpl<>();
        generic2.show(11111);
    }
}

类型通配符<?>

• List<?>可以表示元素类型未知的List，他的元素可以是任何类型

• <?>是类型通配符

• 类型通配符的上限：<? extends 类型>，泛型的类型(等号后面那部分)只能是该类型或该类型的子类

• 类型通配符的上限：<? super 类型>，泛型的类型只能是该类型或该类型的父类

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符<?>
        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<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
//        List<? super Number> list9 = new ArrayList<Integer>();//报错
    }
}