泛型

泛型

1、泛型的概述

泛型是一种未知的数据类型，当我们不知道使用什么数据类型时，可以使用泛型。

泛型也可以看出是一个变量，用来接收数据类型

E/e： Element 元素

T/t: Type 类型

在创建集合对象的时候，就会确定泛型的数据类型

//ArrayList<E> var = new ArrayList<>();
//创建了一个String类型的集合
ArrayList<String> list = new ArrayList<>();

在确定E的具体类型之后，集合对应方法中的E全部都会变成所使用的具体数据类型

2、泛型使用的优缺点

1、创建集合对象，不使用泛型（不写尖括号<>）

//不使用泛型
ArrayList list = new ArrayList();

优点：

​ 集合不使用泛型，则默认类型为【Object】类型，可以存储任意类型的数据

缺点：

​ 在存储多种类型时，容易引发运行异常

Demo：

public static void main(String[] args){
    
    //不使用泛型，集合默认类型为Object类型
    ArrayList list = new ArrayList();
    //添加一个String类型
    list.add("abc");
    //添加一个Integer类型
    list.add(100);
    
    //使用迭代器遍历
    Iterator it = list.iterator();
    //不知道集合长度的情况下使用while循环进行遍历
    //使用hasNext();方法判断是否继续迭代

    while(it.hasNext()){
        //创建一个Object类型来接收
        Object obj = it.next();
        //打印
        System.out.println(obj);	// abc	100
    	//但是如果想要使用集合中元素对应类型的特有方法，则必须要进行向下转型
        String str = (String) obj;
        //获取字符串集合元素的长度
        System.out.println(str.length());
        //再次运行则会报错，因为元素中存在有Integer类型无法转换为String类型，无法使用String特有方法
        //则会抛出ClassCastException
    }
    
}

异常：

abc
3
100
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at NewType.Demo_01.main(Demo_01.java:25)

2、创建对象时，使用泛型

优点：

​ 1、避免了类型转换时的异常状况，存储的类型都为同一类型，方便类型转换的处理。

​ 2、把运行期间的异常(代码运行之后抛出异常)，转化到了编译期(写代码的时候若存在类型问题则会及时报错)。

缺点：

​ 存储类型单一，只能存储一种类型

3、泛型类的定义与使用

1、定义使用含有泛型的类

泛型类的定义格式：

public class 类名称<E>{
    ······
}

在说明这是一个泛型类之后里面的所有数据类型，都为不确定状态，均需要所有泛型【E】来代替

public class 类名称<E>{
    private E name;
    
    public GenericClass_demo_01() {
    }

    public GenericClass_demo_01(E name) {
        this.name = name;
    }

    public E getName() {
        return name;
    }

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

泛型是一个未知的数据类型，当我们不确定想使用什么类型，可以使用泛型

泛型可以接收任意的数据类型。在创建对象的时候可以确定泛型的数据类型

//创建对象时不确定数据类型
泛型类名称 var = new 泛型类名称();
//创建对象时确定数据类型
泛型类名称<E> var = new 泛型类名称();

Demo：泛型类

public class GenericClass_demo_01<E> {
        
    private E name;

    public GenericClass_demo_01() {
    }

    public GenericClass_demo_01(E name) {
        this.name = name;
    }

    public E getName() {
        return name;
    }

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

main(不确定泛型的数据类型):

public static void main(String[] args) {
        //创建对象时，不确定泛型的数据类型，在调用具体数据类型对应的方法时需要向下转型
        GenericClass_demo_01 one = new GenericClass_demo_01();
        one.setName("张三");
        Object name = one.getName();
        System.out.println(name);
        //获取字符串的长度，需要将其转换为String类型
        String str = (String) name;
        int length = str.length();
        System.out.println(length);
    }

main(确定泛型的数据类型)：

public static void main(String[] args) {
        //指明泛型类型为String类型
        GenericClass_demo_01<String> one = new GenericClass_demo_01<>();
        //指明类型之后 设置其他类型时会报错
        //one.setName(1);   错误
        //设置对应String类型则不会报错
        one.setName("张三");
        String name = one.getName();
        System.out.println(name);
        //直接使用String的length()操作方法
        int length = name.length();
        System.out.println(length);
    }

4、含有泛型方法的定义和使用

定义含有泛型的方法：泛型定义在方法的修饰符和返回值之间

格式：

修饰符 <E> 返回值类型 方法名称(参数列表){
   ······· 
}

含有泛型的方法，在调用方法的时候，会根据传递的参数的类型，来确定泛型的类型，传入的参数若是Integer类型，则泛型就是Integer类型

Demo(泛型存在的类):

public class GenericClass_method_Demo_01 {
		//修饰符 <E> 返回值类型 方法名称(参数列表){
   		//		······· 
		//}
        public <E> void method(E e){
            System.out.println("成员方法");
            System.out.println(e);
        }
}

main:

public static void main(String[] args) {
        //创建对象进行方法的调用
    	GenericClass_method_Demo_01 one = new GenericClass_method_Demo_01();
        //参数类型为String类型则此时泛型的类型为String类型
    	one.method("张三");
    	method1("张三")
}
	//静态泛型方法	
	public static <E> void method1(E e) {
        System.out.println("静态方法");
        System.out.println(e);
    }

运行结果：

成员方法
张三
静态方法
张三

5、含有泛型的接口的定义和使用

1、含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，同时并指明接口泛型的数据类型

//泛型接口
public interface 接口名称<E>{
    ······
}

泛型接口的实现类：

public class 实现类名称 implements 接口名称<具体类型>{
    ······
}

Demo(泛型接口)

//public interface 接口名称<E>{
//    ······
//}
public interface GenericClass_interface<E> {
    public abstract void method(E e);
}

实现类：

//在实现时指明泛型的数据类型为String类型，其重写的方法的参数也会随之变成String类型
public class GenericClass_interface_impl implements GenericClass_interface<String>{
	//抽象接口中的抽象方法
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

main：

public static void main(String[] args) {
        //创建实现类对象，进行方法的调用
    	GenericClass_interface_impl one = new GenericClass_interface_impl();
        one.method("泛型接口实现了！");
    }

2、第二种使用方式，接口使用什么泛型，实现类就使用什么泛型，类跟随着接口，相当于定义了一个含有泛型的类，创建对象的时候在确定泛型的类型

类似于上面泛型类的使用，此处不再举例

6、泛型通配符

通配符的基本使用

泛型的通配符：不知道使用什么类型来接受的时候，此时可以使用【?】,【?】表示未知通配符

此时只能接受数据，不能往该集合中存储数据

注意：

泛型没有继承的概念

泛型通配符：

​ ？： 代表任意的数据类型

使用方式：

​ 不能创建对象使用

​ 只能作为方法的参数使用