关键词：

文章目录

• ①. 泛型的概述
• ②. 泛型 - 类class
• ③. 泛型 - 接口
• ④. 泛型 - 通配符 ?
• ⑤. 泛型 - 方法
• ⑥. 泛型上下边界

①. 泛型的概述

• ①. 泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)

• ②. 把元素的类型设计成一个参数,这个类型参数叫做泛型

• ③. 程序的运行结果会以崩溃结束
  java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
  ArrayList可以存放任意类型,例子中添加了一个String类型,添加了一个Integer类型,再使用时都以String的方式使用,因此程序崩溃了。为了解决类似这样的问题(在编译阶段就可以解决),泛型应运而生

		 List arrayList = Lists.newArrayList();
		 arrayList.add("aaaa");
		 arrayList.add(100);
		
		 for(int i = 0; i< arrayList.size();i++)
		     String item = (String)arrayList.get(i);
		 

• ④. 泛型的特点:泛型只在编译阶段有效。看下面的代码：
  泛型类型在逻辑上看以看成是多个不同的类型,实际上都是相同的基本类型

        List<String> stringArrayList = Lists.newArrayList();
        List<Integer> integerArrayList = Lists.newArrayList();

        Class classStringArrayList = stringArrayList.getClass();
        Class classIntegerArrayList = integerArrayList.getClass();

        if (classStringArrayList.equals(classIntegerArrayList)) 
            // 下面这里会输出
            System.out.println("泛型测试,类型相同");
        

②. 泛型 - 类class

• ①. 泛型类可能有多个参数,此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>

//此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时,必须指定T的具体类型
public class Generic<T> 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;

    public Generic(T key)  //泛型构造方法形参key的类型也为T,T的类型由外部指定
        this.key = key;
    

    public T getKey() //泛型方法getKey的返回值类型为T,T的类型由外部指定
        return key;
    

class Notepad<K,V>       // 此处指定了两个泛型类型  
    private K key ;     // 此变量的类型由外部决定  
    private V value ;   // 此变量的类型由外部决定  
    public K getKey()  
        return this.key ;  
      
    public V getValue()  
        return this.value ;  
      
    public void setKey(K key)  
        this.key = key ;  
      
    public void setValue(V value)  
        this.value = value ;  
      

• ②. 泛型类的构造器如下：public GenericClass()
  而下面是错误的：public GenericClass()

• ③. 泛型的指定中不能使用基本数据类型,可以使用包装类替换

//泛型的类型参数只能是类类型(包括自定义类),不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同,即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

//传入的实参类型需与泛型的类型参数类型相同,即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");

• ④. 定义的泛型类,就一定要传入泛型类型实参么？并不是这样,在使用泛型的时候如果传入泛型实参,则会根据传入的泛型实参做相应的限制,此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话,在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型

public class Generic<T>
    public static void main(String[] args) 
        Generic generic = new Generic("111111");
        Generic generic1 = new Generic(4444);
        Generic generic2 = new Generic(55.55);
        Generic generic3 = new Generic(false);

        /**
         * 泛型测试,key is:111111
         * 泛型测试,key is:4444
         * 泛型测试,key is:55.55
         * 泛型测试,key is:false
         */
        System.out.println("泛型测试,key is:"+generic.getKey());
        System.out.println("泛型测试,key is:"+generic1.getKey());
        System.out.println("泛型测试,key is:"+generic2.getKey());
        System.out.println("泛型测试,key is:"+generic3.getKey());
    
    //key这个成员变量的类型为T,T的类型由外部指定
    private T key;

    public Generic(T key)  //泛型构造方法形参key的类型也为T,T的类型由外部指定
        this.key = key;
    

    public T getKey() //泛型方法getKey的返回值类型为T,T的类型由外部指定
        return key;
    

③. 泛型 - 接口

• ①. 泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中,可以看一个例子

//定义一个泛型接口
public interface Generator<T> 
    public T next();

• ②. 当实现泛型接口的类,未传入泛型实参时：

/**
 * 未传入泛型实参时,与泛型类的定义相同,在声明类的时候,需将泛型的声明也一起加到类中
 * 即：class FruitGenerator<T> implements Generator<T>
 * 如果不声明泛型,如：class FruitGenerator implements Generator<T>,编译器会报错："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>
    @Override
    public T next() 
        return null;
    

• ③. 当实现泛型接口的类,传入泛型实参时：

/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参,形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时,如已将泛型类型传入实参类型,则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator<T>,public T next();中的的T都要替换成传入的String类型。
 */
public class FruitGenerator implements Generator<String> 

    private String[] fruits = new String[]"Apple", "Banana", "Pear";

    @Override
    public String next() 
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    

④. 泛型 - 通配符 ?

• ①. 我们知道Ingeter是Number的一个子类,同时在特性章节中我们也验证过Generic<Ingeter>与Generic<Number>实际上是相同的一种基本类型。那么问题来了,在使用Generic<Number>作为形参的方法中,能否使用Generic<Ingeter>的实例传入呢？在逻辑上类似于Generic<Number>和Generic<Ingeter>是否可以看成具有父子关系的泛型类型呢

		Generic<Integer> gInteger = new Generic<Integer>(123);
		Generic<Number> gNumber = new Generic<Number>(456);
		// 这里直接会报错
		gInteger.showKeyValue1(gInteger);
		public void showKeyValue1(Generic<Number> obj)
		     System.out.println("泛型测试,key is:"+obj);
		 

• ②. 回到上面的例子,如何解决上面的问题？总不能为了定义一个新的方法来处理Generic<Integer>类型的类,这显然与java中的多台理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic<Integer>和Generic<Number>父类的引用类型。由此类型通配符应运而生

		public void showKeyValue1(Generic<?> obj)
		   System.out.println("泛型测试,key is:"+obj);
		

• ③. 类型通配符一般是使用？代替具体的类型实参,注意了,此处’？’是类型实参,而不是类型形参 。重要说三遍!此处’？’是类型实参,而不是类型形参 ! 此处’？’是类型实参,而不是类型形参 !再直白点的意思就是,此处的？和Number、String、Integer一样都是一种实际的类型,可以把？看成所有类型的父类。是一种真实的类型。

⑤. 泛型 - 方法

• ①. 泛型方法定义
  
  

• ②. 区别泛型方法、普通方法

public class GenericTest 
   //这个类是个泛型类,在上面已经介绍过
   public class Generic<T>     
        private T key;

        public Generic(T key) 
            this.key = key;
        

        //我想说的其实是这个,虽然在方法中使用了泛型,但是这并不是一个泛型方法。
        //这只是类中一个普通的成员方法,只不过他的返回值是在声明泛型类已经声明过的泛型。
        //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey()
            return key;
        

        /**
         * 这个方法显然是有问题的,在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E,所以在使用E做形参和返回值类型时,编译器会无法识别。
        public E setKey(E key)
             this.key = keu
        
        */
    

    /** 
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少,这表明这是一个泛型方法,并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个 
     *    如：public <T,K> K showKeyName(Generic<T> container)
     *        ...
     *        
     */
    public <T> T showKeyName(Generic<T> container)
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适,只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    

    //这也不是一个泛型方法,这就是一个普通的方法,只是使用了Generic<Number>这个泛型类做形参而已。
    public void showKeyValue1(Generic<Number> obj)
   
    

    //这也不是一个泛型方法,这也是一个普通的方法,只不过使用了泛型通配符?
    //同时这也印证了泛型通配符章节所描述的,?是一种类型实参,可以看做为Number等所有类的父类
    public void showKeyValue2(Generic<?> obj)
     
    

     /**
     * 这个方法是有问题的,编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T,并未声明泛型类型E,因此编译器并不知道该如何处理E这个类型。
    public <T> T showKeyName(Generic<E> container)
        ...
      
    */

    /**
     * 这个方法也是有问题的,编译器会为我们提示错误信息："UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过,因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
    public void showkey(T genericObj)

    
    */

• ③. 当然这并不是泛型方法的全部,泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的,当泛型方法出现在泛型类中时,我们再通过一个例子看一下

public class GenericFruit 
    class Fruit
        @Override
        public String toString() 
            return "fruit";
        
    

    class Apple extends Fruit
        @Override
        public String toString() 
            return "apple";
        
    

    class Person
        @Override
        public String toString() 
            return "Person";
        
    

    class GenerateTest<T>
        public void show_1(T t)
            System.out.println(t.toString());
        

        //在泛型类中声明了一个泛型方法,使用泛型E,这种泛型E可以为任意类型。可以类型与T相同,也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>,因此即使在泛型类中并未声明泛型,编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t)
            System.out.println(t.toString());
        

        //在泛型类中声明了一个泛型方法,使用泛型T,注意这个T是一种全新的类型,可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t)
            System.out.println(t.toString());
        
    

    public static void main(String[] args) 
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类,所以这里可以
        generateTest.show_1(apple);
        //编译器会报错,因为泛型类型实参指定的是Fruit,而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    

• ④. 泛型方法与可变参数

public <T> void printMsg( T... args)
    for(T t : args)
        Log.d("泛型测试","t is " + t);
    

printMsg("111",222,"aaaa","2323.4",55.55);

• ⑤. 如果静态方法要使用泛型的话,必须将静态方法也定义成泛型方法

public class StaticGenerator<T> 
    /**
     * 如果在类中定义使用泛型的静态方法,需要添加额外的泛型声明(将这个方法定义成泛型方法)
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t)..,此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t)

    

⑥. 泛型上下边界

• ①. 在使用泛型的时候,我们还可以为传入的泛型类型实参进行上下边界的限制,如：类型实参只准传入某种类型的父类或某种类型的子类

public void showKeyValue1(Generic<? extends Number> obj)
  

Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

//这一行代码编译器会提示错误,因为String类型并不是Number类型的子类
//showKeyValue1(generic1);
showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);

• ②. 如果我们把泛型类的定义也改一下:

public class Generic<T extends Number>
    private T key;

    public Generic(T key) 
        this.key = key;
    

    public T getKey()
        return key;
    

//这一行代码也会报错,因为String不是Number的子类
Generic<String> generic1 = new Generic<String>("11111");

• ③. 再来一个泛型方法的例子：

//在泛型方法中添加上下边界限制的时候,必须在权限声明与返回值之间的<T>上添加上下边界,即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container),编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container)
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;

• ④. 泛型的上下边界添加,必须与泛型的声明在一起
  <? extends Number> (无穷小, Number]:只允许泛型为Number及Number子类的引用调用
  <? super Number> [Number , 无穷大):只允许泛型为Number及Number父类的引用调用
  <? extends Comparable>：只允许泛型为实现Comparable接口的实现类的引用调用

java泛型使用上下边界通配符解决泛型擦除问题(代码片段)

文章目录前言一、使用上边界通配符示例二、分析字节码的附加信息前言上一篇博客【Java泛型】泛型用法(泛型编译期擦除|上界通配符＜?extendsT＞|下界通配符＜?superT＞)一、泛型擦除章节中,讲到了泛型擦除问题,... 查看详情

java泛型泛型用法(泛型类用法|泛型方法用法|泛型通配符?|泛型安全检查)(代码片段)

文章目录一、泛型类用法二、泛型方法用法三、泛型通配符<?>四、泛型安全检查五、完整代码示例1、泛型类/方法2、main函数一、泛型类用法泛型类用法:使用时先声明泛型,如果不声明泛型,则表示该类的泛型是Object类型;泛型... 查看详情

深入java泛型（三泛型的上下边界）(代码片段)

...入Java泛型三、泛型的上下边界3.1<?extendsE>：上界通配符（UpperBoundsWildcards）3.2<?superE>：下界通配符（LowerBoundsWildcards）3.3上下通配符的副作用三、泛型的上下边界?extendE是泛型的上边界， 查看详情

深入java泛型（三泛型的上下边界）(代码片段)

...入Java泛型三、泛型的上下边界3.1<?extendsE>：上界通配符（UpperBoundsWildcards）3.2<?superE>：下界通配符（LowerBoundsWildcards）3.3上下通配符的副作用三、泛型的上下边界?extendE是泛型的上边界，?superT是... 查看详情

java泛型

...如果实例的给定类型不同，则实例的类型不兼容。9.泛型通配符?可 查看详情

java泛型(代码片段)

...型接口5.泛型方法5.限定类型变量6.泛型的约束和局限性7.通配符类型总结前言提示：以下是本篇文章正文内容，下面案例可供参考一、泛型1.泛型的好处1.适用于多种数据类型执行相同的代码.2.泛型中的类型在使用指定时,... 查看详情

java筑基.泛型,反射,注解-利用注解加反射练习(代码片段)

...参数变量子类不明确泛型类的类型参数变量限定类型变量通配符泛型注解元注解注解的应用场景反射:注解+反射练习泛型:把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型泛型类/*1:把泛型定义在类上2... 查看详情

java示例代码_在静态上下文中对特定对象使用泛型类

java示例代码_在静态上下文中对特定对象使用泛型类 查看详情

尚硅谷_java零基础教程（泛型generics）--学习笔记(代码片段)

...泛型方法2、自定义泛型demo四、泛型在继承上的体现五、通配符的使用1、有限制的通配符六、泛型应用举例一、为什么要有泛型1、为什么要有泛型(Generic)泛型的设计背景：集合容器类在设计阶段/声明阶段不能确定这个容器 查看详情

java_泛型笔记(代码片段)

...例化Java_泛型类Java_泛型方法Java_泛型在继承上的体现Java_通配符的使用Java_泛型简介集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛 查看详情

java泛型和内部类(代码片段)

...的定义-类型边界Number类2.泛型方法3.泛型中的父子类型4.通配符？通配符上界通配符下界5.泛型的限制三、内部类1.本地内部类2.实例内部类3.静态内部类4.匿名内部类一、泛型的概述1.概念我们都用过Java集合类，比如Arra 查看详情

java示例代码_在Java中将泛型类传递给方法

java示例代码_在Java中将泛型类传递给方法 查看详情

java--泛型--泛型接口&泛型方法(代码片段)

泛型接口  packagecom.model.fanxing;/***@Description:测试类*@Author:张紫韩*@Crete2021/6/3022:14*泛型接口和实现类*1.泛型接口的实现类，是一个泛型类，那么要保证实现接口的泛型类的反省表示中要包含泛型接口的泛型标识*2.泛型接口... 查看详情

java中泛型的深入理解(代码片段)

...本介绍自定义泛型类自定义泛型方法自定义泛型接口泛型通配符和上下限泛型深入泛型基本介绍泛型的概述:泛型：是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式：<数据类... 查看详情

java泛型概述与应用(代码片段)

...1.3泛型方法1.3.1示例代码1.4泛型接口1.4.1示例代码1.5类型通配符1.5.1类型通配符:<?>1.5.2类型通配符上限:<?extends类型>1.5.3类型通配符下限:<?super类型>1.5.4泛型通配符的使用泛型1.1泛型概述泛型是JDK5中引入的特性，它... 查看详情

java泛型泛型简介(泛型类|泛型方法|静态方法的泛型|泛型类与泛型方法完整示例)(代码片段)

文章目录一、泛型简介二、泛型类三、泛型方法四、静态方法的泛型五、泛型类与泛型方法完整示例一、泛型简介泛型可以简单理解为参数化类型,主要作用在类,方法,接口上;java泛型与C++模板:Java中的泛型,是仿照C++中... 查看详情

第9章泛型

...型接口、类　　从泛型派生子类　　并不存在泛型类类型通配符　　使用类型通配符　　设定类型通配符的上限　　设定类型形参的上限泛型方法　　定义泛型方法　　泛型方法和类型通配符的区别　　Java7的“菱形&r 查看详情

聊聊java泛型(代码片段)

目录引子好处泛型通配符泛型位置  出现在类或者接口上  出现在方法中使用，包括返回值，参数  出现在变量声明中  注意事项泛型边界分类无边界 上界下界作用时机类型擦除部分擦除哪些被擦除了，哪些没被... 查看详情