8. 泛型

1.泛型概述

泛型：就是一种不确定的数据类型。

2.泛型的使用

①定义和使用含有泛型的类
格式：修饰符 class 类名<代表泛型的变量> { }
②含有泛型的方法
格式：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
演示：

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

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
	public  <K> K hello(K k){//泛型方法1
        return k;
    }
    public  <K> void hello1(K k){//泛型方法2
        System.out.println("泛型方法");
    }
}

public class Test {
    public static void main(String[] args) {
        Person<String> p=new Person<>();
        p.setT("hello");
        System.out.println(p.getT());
		p.hello("hello");//调用方法时，确定泛型的类型
        p.hello(11);
    }
}

③含有泛型的接口
格式：修饰符 interface接口名<代表泛型的变量> { }
1、定义子类时确定泛型的类型

public interface A<T> {//定义泛型接口A
    void add(T t);
    void del(T t);

}

public class B implements A<String> {//定义子类B实现泛型接口A
    @Override
    public void add(String s) {

    }

    @Override
    public void del(String s) {

    }
}

public class Test {//测试类
    public static void main(String[] args) {
        B b=new B();
        b.add("hello");
    }
}

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

public interface A<T> {//定义泛型接口A
    void add(T t);
    void del(T t);

}

public class B<T> implements A<T> {
    @Override
    public void add(T t) {

    }

    @Override
    public void del(T t) {

    }
}

public class Test {//测试类
    public static void main(String[] args) {
        B b=new B<String>();
        b.add("hello");
    }
}

3.泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。

public class Person<T> {
    private T t;

    public T getT() {
        return t;
    }

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

public class Test {
    public static void main(String[] args) {
        Person<String> p=new Person<>();
		Person<Integer> p1=new Person<>();
		ff2(p);
        ff2(p1);

    }
    public static void  ff2(Person<?> person){

    }
}

在泛型中可以指定一个泛型的上限和下限。

泛型的上限：

格式： 类型名称 <? extends 类 > 对象名称
意义： 只能接收该类型及其子类

public class Person<T> {
    private T t;

    public T getT() {
        return t;
    }

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

public class Test {
    public static void main(String[] args) {
        Person<String> p=new Person<>();
		Person<Integer> p1=new Person<>();
		ff1(p);
        ff1(p1);//报错

    }
     public static void  ff1(Person<? extends  String> person){

    }
}

泛型的下限：

格式： 类型名称 <? super 类 > 对象名称
意义： 只能接收该类型及其父类型

public class Person<T> {
    private T t;

    public T getT() {
        return t;
    }

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

public class Test {
    public static void main(String[] args) {
        Person<String> p=new Person<>();
		Person<Integer> p1=new Person<>();
		ff(p);
        ff(p1);//报错

    }
     public static void  ff(Person<? super  String> person){

    }
}