泛型知识点

泛型

定义和理解

泛型也可以看成是一个变量，用来接收数据类型，当我们不知道使用什么类型的时候可以用泛型。
比如ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型。

创建集合不使用泛型

示例：ArrayList list=new ArrayList()；

好处：默认的类型是Object，可以存储任意类型的数据。
坏处：不安全，会引发异常。

创建集合使用泛型

示例：ArrayList<String> list=new ArrayList<>()；

好处：1.避免了类型转换的麻烦，存储的是什么类型，取出的是什么类型。
　　　2.把运行期间的异常，提升到了编译期。
坏处：泛型是什么类型，只能存储什么类型的数值。

泛型的类

定义泛型的类

public class testclass <E>{
    private E name;
    
    public E getName() {
        return name;
    }
    
    public void setName(E name) {
        this.name = name;
    }
}

不使用泛型的情况

//不写泛型默认为Object类型，不管存进去的类型是什么，取出来的都是Object
 testclass gc=new testclass();
 gc.setName("存进去的是字符串");
 Object obj=gc.getName();

使用泛型的情况

//泛型使用Integer,取出来的时候也是Integer
testclass<Integer> gc2=new testclass();
gc2.setName(1);
Integer name=gc2.getName();

含有泛型的方法

定义含有泛型的方法

格式：
修饰符<泛型> 返回值类型 方法名(参数列表(使用泛型)){
方法体;
}

public class GenericMethod {
    //定义一个含有泛型的普通方法
    public <M> void method01(M m){
        System.out.println(m);
    }
    //定义一个含有泛型的静态方法
    public static  <S> void methodStatic(S s){
        System.out.println(s);
    }
}

使用方法

GenericMethod gm=new GenericMethod();
//使用含有泛型的普通方法
gm.method01(10);
gm.method01(true);

//使用含有泛型的静态方法        
GenericMethod.methodStatic(10);
GenericMethod.methodStatic("abc"); 

泛型的接口

定义泛型的接口

public interface GenericInterface<I> {
    public abstract void method(I i);
}

实现泛型的接口方式一

//定义接口的实现类实现接口，并且指定接口的泛型
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

使用：

GenericInterfaceImpl1 gi1=new GenericInterfaceImpl1();
gi1.method("abc");

实现泛型的接口方式二

//接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

使用：

GenericInterfaceImpl1 gi1=new GenericInterfaceImpl1();
gi1.method("abc");

泛型通配符

泛型通配符的理解和使用

泛型的通配符：？ 代表任意的数据类型。
使用方法：不能创建对象使用，只能作为方法的参数使用。
但是一旦使用泛型的通配符之后，只能使用Object类中的共性方法，集合元素自身的方法无法使用。

使用举例：

受限泛型

泛型的上限： 类型名称<? extends 类>对象名称
意义：只能接收该类型及其子类
泛型的下限： 类型名称<? super 类>对象名称
意义：只能接收该类型及其父类型