Java 定义和使用含有泛型的类、方法和接口 及 泛型通配符＜?＞的使用 及 泛型的上限限定和下限限定

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

/*
说明：泛型是一个未知的数据类型，当我们不确定使用什么数据类型的时候，可以使用泛型；
简单来说，就是在定义类或类的成员变量的类型的时候不把类型写死了。在创建对象的时候，想用啥类型就创建啥类型的对象。
 */
public class Person<E>{

    private E userName;

    private E age;

    public E getUserName() {
        return userName;
    }

    public void setUserName(E userName) {
        this.userName = userName;
    }

    public E getAge() {
        return age;
    }

    public void setAge(E age) {
        this.age = age;
    }
}

public class TestPerson {
    public static void main(String[] args) {
        //1.不写泛型默认为object类型
        Person person = new Person();
        person.setAge(18);
        Object age = person.getAge();
        System.out.println(age);

        //2.创建Person对象，泛型使用String类型
        Person<String> stringPerson = new Person<>();
        stringPerson.setAge("18");//不使用String类型的数据直接编译报错

        String age1 = stringPerson.getAge();
        System.out.println(age1);

    }
}

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

public class Method{

    //含有泛型的普通方法
    public <E> void sout1(E e){
        System.out.println(e);
    }

    //含有泛型的静态方法
    public static <E> void sout2(E e){
        System.out.println(e);
    }
}

public class TestMethod {

    public static void main(String[] args) {

        Method method = new Method();
        /*
        传递什么类型，泛型就是什么类型
         */
        method.sout1("abc");
        method.sout1(123);
        method.sout1(false);

        //类名调用静态方法
        Method.sout2("abc");
        Method.sout2(123);

    }
}

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

方式一：

public interface Inter<E> {

    public abstract void method(E e);
}

/*
 实现接口时传入泛型。
 */
public class InterImpl implements Inter<String>{

    /*
    这里必须为String类型的参数,要和泛型定义的一致。
     */
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

public class TestInter {

    public static void main(String[] args){

        InterImpl inter = new InterImpl();

        inter.method("abc");
    }
}

方式二：

public interface Inter<E> {

    public abstract void method(E e);
}

public class InterImpl<I> implements Inter<I>{
    
    @Override
    public void method(I i) {

        System.out.println(i);
    }
}

public class TestInter {

    public static void main(String[] args){

        /*
        创建对象时传入泛型。
         */
        InterImpl<String> stringInter = new InterImpl<>();
        stringInter.method("abc");//必须传入String类型的参数，和泛型保持一致

    }
}

四.泛型通配符<?>的使用

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

public class Test {

    /*
    说明：<?>中的?代表任意的数据类型;
    注意：不能创建对象时使用，只能作为方法的参数使用。
     */
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(11);
        list01.add(22);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("b");

        /*
        同一个方法传递不同类型的参数
         */
        printList(list01);
        printList(list02);
    }

    /*
    参数要传递Integer和String两种类型，所以必须使用通配符，不然报错。
     */
    public static void printList(ArrayList<?> list){
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();//只有Object类型才能同时接收不同的类型
            System.out.println(next);
        }

    }
}

五.泛型的上限限定和下限限定

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

public class Test {

    /*
    泛型的上限限定：? extends E 代表使用的泛型只能是E类型的子类/本身;
    泛型的下限限定: ? super E 代表使用的泛型只能是E类型的父类/本身。
     */
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<Number> list3 = new ArrayList<>();
        ArrayList<Object> list4 = new ArrayList<>();

        getE1(list1);
        getE1(list2);//因为不符合参数类型(编译报错)
        getE1(list3);
        getE1(list4);//因为不符合参数类型(编译报错)

        getE2(list1);//因为不符合参数类型(编译报错)
        getE2(list2);//因为不符合参数类型(编译报错)
        getE2(list3);
        getE2(list4);

    }

    /*
    说明：Integer extends Number extends Object;
         String extends Object
     */
    public static void getE1(Collection<? extends Number> collection){

    }

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

    }
}