泛型

虾米姐 阅读:178 2022-06-06 14:06:34 评论:0

泛型

泛型概述

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

泛型也可以看成是一个变量,用来接收数据类型:

  • E e:Element 元素
  • T t:Type 类型

ArrayList集合在定义的时候,不知道集合中都会存储什么类型的数据,所有类型使用泛型

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

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

image-20210202010309896

/* 
	含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型 
	public interface Iterator<E> { 
		E next(); 
	} 
	Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的netxt方法泛型默认就是String 
	public final class Scanner implements Iterator<String> { 
		public String next() {} 
	} 
*/ 

使用泛型的好处

package jihe.fanxing.demo03.Generic; 
 
import java.util.ArrayList; 
import java.util.Iterator; 
 
public class Demo01Generic {
   
     
    public static void main(String[] args) {
   
     
        //show01(); 
        show02(); 
    } 
    /* 
        创建集合对象,使用泛型 
        好处: 
            1、避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型 
            2、把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候就会报错) 
        弊端: 
            泛型是什么类型,只能存储什么类型的数据 
     */ 
    private static void show02() {
   
     
        ArrayList<String> list = new ArrayList<>(); 
        list.add("abc"); 
        //list.add(1);//add(java.lang.String) in ArrayList cannot be applied to (int) 
 
        //使用迭代器遍历list集合 
        Iterator<String> it = list.iterator(); 
        while (it.hasNext()){
   
     
            String s = it.next(); 
            System.out.println(s + "--->" + s.length()); 
        } 
    } 
 
    /* 
        创建集合对象,不使用泛型 
        好处: 
            集合不使用泛型,默认类型就是Object类型,可以存储任意类型的数据 
        弊端: 
            不安全,会引发异常 
     */ 
    private static void show01() {
   
     
        ArrayList list = new ArrayList(); 
        list.add("abc"); 
        list.add(1); 
        //使用迭代器遍历list集合 
        //获取迭代器 
        Iterator it = list.iterator(); 
        //使用迭代器中的方法hasNext和next遍历集合 
        while (it.hasNext()){
   
     
            //取出元素也是Object类型 
            Object obj = it.next(); 
            System.out.println(obj); 
 
            //想要使用String类特有的方法,length获取字符串的长度;不能使用  多态 Object obj = "abc"; 
            //需要向下转型 
            //会抛出ClassCastException类型转换异常,不能把Iterator类型转换为String类型 
            String s = (String)obj; 
            System.out.println(s.length()); 
        } 
    } 
} 

泛型的定义和使用

反省,用来灵活的将数据类型应用到不同类、方法、接口当中。将数据类型作为参数进行传递。

定义和使用含有泛型的类

定义格式:

修饰符 class 类名<代表反省的变量> {}

package fanxing.Generic; 
/* 
    定义一个含有泛型的类,模拟ArrayList集合 
    泛型是一个未知的数据类型,当我们不确定什么数据类型的时候,可以使用泛型 
    泛型可以接受任意的数据类型,可以使用Integer,String,Student... 
    创建对象的时候确定泛型的数据类型 
 */ 
public class GnericClass<E> {
   
     
    private E name; 
 
    public E getName() {
   
     
        return name; 
    } 
 
    public void setName(E name) {
   
     
        this.name = name; 
    } 
} 
package fanxing.Generic; 
 
public class Demo02GenericClass {
   
     
    public static void main(String[] args) {
   
     
        //不屑泛型默认为Object类型 
        GnericClass gc = new GnericClass(); 
        gc.setName("只能是字符串"); 
        Object obj = gc.getName(); 
 
        //创建GnericClass对象,泛型使用Integer类型 
        GnericClass<Integer> gc2 = new GnericClass(); 
        gc2.setName(1); 
 
        Integer name = gc2.getName(); 
        System.out.println(name); 
 
        //创建GnericClass对象,泛型使用String类型 
        GnericClass<String> gc3 = new GnericClass(); 
        gc3.setName("小明"); 
 
        String name1 = gc3.getName(); 
        System.out.println(name1); 
    } 
} 
含有泛型的方法

定义格式:

修饰符 <代表泛型的变量> 返回值类型 方法名(参数) {}

例如:

package fanxing.Generic; 
/* 
    定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间 
 
    格式: 
        修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){ 
            方法体; 
        } 
    含有泛型的方法,在调用方法的时候确定泛型的数据类型 
    传递什么类型的参数,泛型就是什么泛型 
 */ 
public class GnericMethod {
   
     
    //定义一个含有泛型的方法 
    public <M> void method01(M m){
   
     
        System.out.println(m); 
    } 
 
    //定义一个含有泛型的静态方法 
    public static <S> void method02(S s){
   
     
        System.out.println(s); 
    } 
} 
package fanxing.Generic; 
/* 
    测试含有泛型的方法 
 */ 
public class Demo03GnericMethod {
   
     
    public static void main(String[] args) {
   
     
        //创建GenericMethod对象 
        GnericMethod gm = new GnericMethod(); 
 
        /* 
            调用含有泛型的方法method01 
            传递什么类型,泛型就是什么类型 
         */ 
        gm.method01(10); 
        gm.method01("abc"); 
        gm.method01(8.8); 
        gm.method01(true); 
 
        gm.method02("静态方法,不建议创建对象使用"); 
 
        //静态方法,通过类名.方法名(参数)可以直接使用 
        GnericMethod.method02("静态方法"); 
        GnericMethod.method02(1); 
    } 
} 
含有泛型的接口

定义格式:

修饰符 interface 接口名<代表泛型的变量> {}

例如:

package jihe.fanxing.demo03.Generic; 
/* 
    含有泛型的接口,第一种使用方式,定义接口的实现类,实现接口,指定接口的泛型 
    public interface Iterator<E>{ 
        E next(); 
    } 
    Scanner类实现了Iterator接口,并指定接口的泛型为String,所以它重写的next方法泛型默认就是String 
    public final class Scanner implements Iterator<String>{ 
        public String next() {} 
    } 
 */ 
public class GnericInterfaceImpl implements GnericInterface<String>{
   
     
    @Override 
    public void method(String s) {
   
     
        System.out.println(s); 
    } 
} 
package jihe.fanxing.demo03.Generic; 
/* 
    含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走 
    就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型 
    public interface List<E>{ 
        boolean add(E e); 
        E get(int index); 
    } 
    public class ArraryList<E> implements List<E>{ 
        public boolean add(E e) {} 
        public E get(int index) {} 
    } 
 */ 
public class GnericInterfaceImpl2<I> implements GnericInterface<I> {
   
     
    @Override 
    public void method(I i) {
   
     
        System.out.println(i); 
    } 
} 
package jihe.fanxing.demo03.Generic; 
 
public class Demo04GnericInterface {
   
     
    public static void main(String[] args) {
   
     
        //创建GnericInterfaceImpl对象 
        GnericInterfaceImpl gi1 = new GnericInterfaceImpl(); 
        gi1.method("字符串"); 
 
        //创建GnericInterfaceImpl2对象 
        GnericInterfaceImpl2<Integer> gi2 = new GnericInterfaceImpl2<>(); 
        gi2.method(10); 
 
        GnericInterfaceImpl2<Double> gi3 = new GnericInterfaceImpl2<>(); 
        gi3.method(10.0); 
    } 
} 

泛型通配符

当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。

通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符

此时只能接收数据,不能忘该集合中存储数据。

package jihe.fanxing.demo03.Generic; 
 
import java.util.ArrayList; 
import java.util.Iterator; 
 
/* 
    泛型的通配符: 
        ?:代表任意的数据类型 
    使用方式: 
        不能创建对象使用 
        只能作为方法的参数使用 
 */ 
public class Demo05Generic {
   
     
    public static void main(String[] args) {
   
     
        ArrayList<Integer> list01 = new ArrayList<>(); 
        list01.add(1); 
        list01.add(2); 
 
        ArrayList<String> list02 = new ArrayList<>(); 
        list02.add("a"); 
        list02.add("b"); 
 
        printArray(list01); 
        printArray(list02); 
    } 
    /* 
        定义一个方法,能遍历所有类型的ArrayList集合 
        这时候我们不知道ArrarList集合使用什么数据类型,可以使用泛型的通配符?来接收数据类型 
        注意: 
            泛型没有继承概念的 
    */ 
    public static void printArray(ArrayList<?> list){
   
     
        //使用迭代器遍历集合 
        Iterator<?> it = list.iterator(); 
        while(it.hasNext()){
   
     
            //it.next()方法,取出的元素是Object 
            Object o = it.next(); 
            System.out.println(o); 
        } 
    } 
} 
通配符高级使用—受限泛型

之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在Java的泛型中可以指定一个泛型的上限和下限。

泛型的上限

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

泛型的下限

  • 格式:类型名称 <? super 类> 对象名称
  • 意义:只能接收该类型及其父类型
package jihe.fanxing.demo03.Generic; 
 
import java.util.ArrayList; 
import java.util.Collection; 
 
/* 
    泛型的上限限定: ? extends E 代表使用的泛型只能是E类型的子类/本身 
    泛型的下限限定: ? super E   代表使用的泛型只能是E类型的父类/本身 
 */ 
public class Demo06Generic {
   
     
    public static void main(String[] args) {
   
     
        Collection<Integer> list1 = new ArrayList<Integer>(); 
        Collection<String> list2 = new ArrayList<String>(); 
        Collection<Number> list3 =  new ArrayList<Number>(); 
        Collection<Object> list4 =  new ArrayList<Object>(); 
 
        getElement1(list1); 
        //getElement1(list2); //报错 
        getElement1(list3); 
       // getElement1(list4); //报错 
 
        //getElement2(list1); //报错 
        //getElement2(list2); //报错 
        getElement2(list3); 
        getElement2(list4); 
 
        /* 
            类与类之间的继承关系 
            Integer extends Number extends Object 
            String extends Object 
         */ 
    } 
    //泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类 
    public static void getElement1(Collection<? extends Number> coll) {
   
    } 
    //泛型的下限:此时的泛型?,必须是Number类型的或者Number类型的父类 
    public static void getElement2(Collection<? super Number> coll) {
   
    } 
} 

标签:java
声明

1.本站遵循行业规范,任何转载的稿件都会明确标注作者和来源;2.本站的原创文章,请转载时务必注明文章作者和来源,不尊重原创的行为我们将追究责任;3.作者投稿可能会经我们编辑修改或补充。

搜索
排行榜
关注我们

一个IT知识分享的公众号