Java中的泛型类、泛型方法、泛型接口

学习笔记：泛型方法
泛型的本质是参数化类型，在使用或者调用的时候才传入参数类型。这种参数类型可以用到类、方法、接口中，分别称为泛型类、泛型方法、泛型接口。

泛型的定义格式：

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

形参出现在方法定义中，在整个方法体内都可以使用， 离开该方法则不能使用。实参出现在主函数中，进入被调函数后，实参变量也不能使用。
1-比如你定义一个函数public static int add(int a,int b)，这里的a和b就是形参。
2-当你进行函数调用的时候，add(1,2)，这里的1和2就是实参。

1、泛型类的定义格式

修饰符 class 类名<类型> {}
范例：public class Student<T> {}

此处的T可以随便写为任意修饰符，常见的如T 、E、K、 V等形式的参数常用语表示泛型

2、泛型类的方法格式

public class 类名{
    public <T> void 方法名(类型 参数名){ }}

范例：
public class Student{
      public <T> void show(T t){ }}

3、泛型接口的定义格式

修饰 interface 接口名<类型> {}

范例：public interface GenericInterface<T> {}

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

如果说我们不希望List<?>是任何泛型的父亲，只希望它代表某一泛型List的父亲，可以使用类型通配符的上限
类型通配符的上限：<?extends类型>
List<?extends Number>:它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
类型通配符的上限：<?super类型>
List<?super Number>:它表示的类型是Number或者其父型

//        类型通配符<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("-----------------------");

//        类型通配符上限：<?extend类型>
//        List<? extends Number> list4 = new ArrayList<Object>();
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        System.out.println("-----------------------");

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

范例

一、泛型类范例

//定义泛型类
public class Student<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public class GenericDemo {
    public static void main(String[] args) {
        Student<String> s = new Student<String>();
        s.setT("小袁");
        System.out.println(s.getT());

        Student<Integer> s1 = new Student<Integer>();
        s1.setT(20);
        System.out.println(s1.getT());
    }
}

二、泛型方法范例

//泛型方法改进
public class Generic{
    public <T> void show(T t){
        System.out.println(t);
    }
}

/*public class Generic {
    public void show(String s){
        System.out.println(s);
    }

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

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

//测试类
public class GenericDemo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("sek");
        g.show(18);
        g.show(true);
    }
}

二、泛型接口范例

//泛型接口
public interface GenericInterface<T> {
    void show(T t);
}

//实现泛型
public class GenericImpl<T> implements GenericInterface<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

//测试类
public class GenericDemo {
    public static void main(String[] args) {
        GenericImpl<String> g = new GenericImpl<String>();
        g.show("xiaoming");

        GenericImpl<Integer> g2 = new GenericImpl<Integer>();
        g2.show(20);
    }
}