泛型

泛型

一、概念

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候我们可以使用泛型。可以看成是一个变量，用来接收数据类型。

//ArrayList集合在定义的时候不知道存储什么类型的数据，使用泛型定义
public class ArrayList<E>{//E代表的是未知的数据类型
    public boolean add(E e){}
}

在创建集合对象的时候能够确定泛型的数据类型。

ArrayList<String> list =  new ArrayList<>();//此时E的类型就是String,会把数据类型作为参数传递，把String 赋值给E
ArrayList<Person> list1= new ArrayList<>();//此时E的类型就是Person.

二、使用泛型的好处

不使用泛型：不安全，容易引发异常。

public class DemoGeneric{
    public static void main(String[]args){
        show01();
    }
    /*
    	1.不使用泛型，默认的类型就是Object.
    */
    private static void show01(){
        ArrayList list  =new ArrayList();
        list.add("abc");
        list.add(1);
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
            it.length();//引发异常，子类方法不能执行，使用之前需要强制类型转换。
        }
    }
    
     /*
    	2.使用泛型
    	好处：避免了类型转换的麻烦，存储什么类型，取出就是什么类型。
    		把运行期异常，提升到了编译期。
    */
    private static void show02(){
        ArrayList<String> list  =new ArrayList<>();
        list.add("abc");
        list.add(1);//报错
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.print(it.next());
            System.out.println(it.length(););
        }
    }
}

三、泛型类的定义和使用

定义格式：

​ 定义一个含有泛型的类，模拟ArrayList集合。

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

pubic class Demo{
    public static void main(String[]args){
        GenericClass<String> gc= newGenericClass<>();
       String name = gc.getNmae();
         GenericClass<Integer> gc1= newGenericClass<>();
        Integer name1 = gc1.getNmae();
    }
}

四、泛型方法的定义

//泛型定义在方法的修饰符和返回值类型之间。
//含有泛型的方法，在调用方法的时候确定泛型的数据类型
//静态方法也可以用泛型
public class GenericMethod{
    public <E> void method01(E e){
        System.out.println(e);
    }
     public static <S> void method02(S s){
        System.out.println(s);
    }
}

public class Demo{
    public static void main(String args[]){
        GenericMethod gm = new GenericMethod();
        gm.method01(10);
        GenericMethod.method02("静态方法");
    }
}

五、含有泛型的接口

Scanner类实现了Iterator 接口，并指定接口的泛型为String.

public interface Genericinterface<I>{
    
}
//含有泛型的接口
public class GenericinterfaceImpl1<I> implements Genericinterface<I>{
    
}
public class Demo{
    public static void main(String args[]){
        GenericinterfaceImpl1 gi1 =  new  GenericinterfaceImpl1();
        gil.method("string");
    }
}

含有泛型的第二种使用方式：接口使用什么泛型，则实现类就使用什么方法。

六、泛型通配符

泛型通配符**？**表示，不知道使用什么类型来接受的时候，可以使用？表示通配符。代表任意的数据类型。

使用方式：不能创建对象使用；智能作为方法的参数使用。

public class GenericDemo{
     public static void main(String args[]){
        ArrayList<Integer> list0= new ArrayList<>();
         list01.add(1);
         list01.add(2);
    }
    
    public static void printArray(ArrayList<?> list){//泛型没有继承概念，不能使用<Object>
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
            
        }
    }
}

泛型使用：受限泛型

泛型的上限限定：？ extends E 代表使用的泛型只能是E类型的子类或本身。

泛型的下限限定：？ supper E 代表使用的泛型只能是E类型的父类或本身。

method(Collection<? extends Number> coll){
    
}
method(Collection<? supper Number> coll){
    
}