Java基础 -- 泛型

java基础 – 泛型

一、介绍与定义

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

定义泛型的方法

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

二、泛型的作用域

1.首先在集合中，由于集合类们都是泛型，你可以在声明集合对象的时候就确定数据类型如:

ArrayList<String> list = new ArrayList<String>();

这样的好处：

​ 假如给list传入了其他类型的值编译器将会在编辑代码大的时候就会报错，假如没有确定String型的话在运行的期间才会报错

+++

2.泛型类

​ 泛型类的定义格式：

• 格式：修饰符 class 类名 {}

• 范例：public class Generic {}

  此处 T 可以随便写为任意标识，常见的有T、E、K、V等形式的参数常用于表示泛型

实例：

class Student {
    private String name;

    public String getName() {
        return name;
    }

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

class Teacher {
    private Integer age;

    public Integer getAge() {
        return age;
    }

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

public class Generic<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 s = new Student();
        s.setName("林青霞");
        System.out.println(s.getName());

        Teacher t = new Teacher();
        t.setAge(30);
//        t.setAge("30");
        System.out.println(t.getAge());
        System.out.println("--------");
        
        //以上为旧的平常方法，下面的就是利用泛型来实现了

        Generic<String> g1 = new Generic<String>();
        g1.setT("林青霞");
        System.out.println(g1.getT());

        Generic<Integer> g2 = new Generic<Integer>();
        g2.setT(30);
        System.out.println(g2.getT());

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

3.泛型方法

泛型类的定义格式：

• 格式：修饰符 返回类型 方法名(T t) {}

• 范例：public void show(T t) {}

  实例：

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

class test{
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.show("风清扬");
        stu1.show(30);
        stu1.show("耍剑与饮酒");
    }
}

4.泛型接口

泛型接口的定义格式：

• 格式：修饰符 interface 接口名 {}
• 范例：public interface Generic) {}

实例：

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 GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new GenericImpl<String>();
        g1.show("林青霞");
        g1.show("李白");
        Generic<Integer> g2 = new GenericImpl<Integer>();
        g2.show(30);
    }
}

三、类型通配符

实际开发中好像使用较少，猜测一般用来晦涩的限制一些情况

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

类型通配符上限：<? extends 类型>
List<? extends Number>：它表示的类型是Number或者其子类型

类型通配符下限：<? super 类型>
List<? super Number>：它表示的类型是Number或者其父类型

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符：<?>
        List<?> list1 = new ArrayList<Object>();	
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();
        System.out.println("--------");

        //类型通配符上限：<? extends 类型>
//        List<? extends Number> list4 = new ArrayList<Object>(); 
        //上面的那行会报错，因为上限是Number，而Object是Number的父类
        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>();
        //上面的那行会报错，因为下限是Number，而Interger是Number的子类
    }
}