java泛型

泛型的使用

/*
泛型是一个未知的数据类型
创建对象的时候确定泛型的数据类型
 */

public class GenericExercise<E> {
    private E name;

    public E getName() {
        return name;
    }

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

public class Test {
    public static void main(String[] args) {
        // 不写泛型默认为object类型
        GenericExercise<String> genericExercise = new GenericExercise<>();
        genericExercise.setName("亚索");
        String name = genericExercise.getName();
        System.out.println(name);
    }
}

创建含有泛型的方法

/*
定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间
在传入参数时确定泛型的数据类型
 */

public class GenericExercise<E>{
    private E value;

    public GenericExercise(E value){
        this.value = value;
    }

    public E getValue() {
        return value;
    }

    public void setValue(E value) {
        this.value = value;
    }

    public void methodOne(E e){
        System.out.println(e);
    }

    // 创建一个静态方法
    public static <E> void methodTwo(E e){
        System.out.println(e);
    }
}

public class Test {
    public static void main(String[] args) {
        GenericExercise<Integer> genericExercise = new GenericExercise<>(123);
        int num = genericExercise.getValue();
        GenericExercise.methodTwo("盖伦");
        System.out.println(num);
    }
}

含有泛型的接口

public interface GenericInterface<E> {
    public abstract void methodOne(E e);
}

/*
1、定义接口的实现类，实现接口，指定接口的泛型
2、接口使用寿命泛型，实现类就使用什么泛型，在创建对象的时候确定泛型的数据类型
 */

//public class GenericInterfaceImpl implements GenericInterface<String> {
//    @Override
//    public void methodOne(String s) {
//        System.out.println(s);
//    }
//}


public class GenericInterfaceImpl<E> implements GenericInterface<E>{
    @Override
    public void methodOne(E e) {
        System.out.println(e);
    }
}

public class Test {
    public static void main(String[] args) {
//        GenericInterfaceImpl genericInterface = new GenericInterfaceImpl();
//        genericInterface.methodOne("亚索");
        GenericInterfaceImpl<Integer> genericInterface = new GenericInterfaceImpl<>();
        genericInterface.methodOne(123456);
    }
}

---

泛型的通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示，但是一旦使用泛型的通配符后，只能使用object类中的共性方法，集合中元素自身方法无法使用。

不能创建对象使用，只能作为方法的参数使用
定义的时候不能使用

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

public class GenericInterrogationExercise {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("盖伦");
        strings.add("亚索");
        strings.add("剑圣");

        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(123);
        integers.add(456);
        integers.add(789);

        printArrayList(strings);
        printArrayList(integers);
    }

    private static void printArrayList(ArrayList<?> list) {
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            // 取出的元素是object可以接受任意的数据类型的数据
            Object o = iterator.next();
            System.out.println(o);
        }
    }
}

受限泛型

/*
    泛型的上限限定 ？ extends E 使用的泛型只能是E类型的子类/本身
    泛型的下限限定 ？ super E  使用的泛型只能是E类型的父类/本身
 */

import java.util.ArrayList;
import java.util.Collection;

public class GenericInterrogationExercise {
    public static void main(String[] args) {
        Collection<Integer> integersOne = new ArrayList<>();
        Collection<String> integersTwo = new ArrayList<>();
        Collection<Number> integersThree = new ArrayList<>();
        Collection<Object> integersFour = new ArrayList<>();

        getElementOne(integersOne);
        // getElementOne(integersTwo);  // Error
        getElementOne(integersThree);
        // getElementOne(integersFour);  // Error

        // getElementTwo(integersOne);  // Error
        // getElementTwo(integersTwo);  // Error
        getElementTwo(integersThree);
        getElementTwo(integersFour);

        /*
        Integer extends Number extends Object
        String extends Object
         */

    }

    public static void getElementOne(Collection<? extends Number> collection){ }

    public static void getElementTwo(Collection<? super Number> collection){ }

}