精华内容
下载资源
问答
  • 泛型方法的定义和使用
    2022-06-05 23:35:13

    1.泛型方法的定义和语法

    1.1 定义

    泛型方法 是在调用方法的时候指明泛型的具体类型。
    【泛型方法 能够使方法独立于类的处理指定的类型。】

    1.2 语法

    修饰符 <T,E,…> 返回值类型 方法名(形参列表){
    。。。。。。
    }

    • 修饰符与返回值类型中间的 泛型标识符 <T,E,…>,是 泛型方法的标志,只有这种格式声明的方法才是泛型方法。
    • 泛型方法声明时的 泛型标识符 <T,E,…> 表示在方法可以使用声明的泛型类型。
    • 与泛型类相同,泛型标识符可以是任意类型,常见的如T,E,K,V 等。
    • 泛型方法可以声明为 static 的,并且与普通的静态方法是一样的。

    2.泛型方法的使用

    2.1 普通泛型方法

    声明

    /**
     * author : northcastle
     * createTime:2021/10/23
     * 泛型方法的定义
     */
    public class GenericMethod {
    
        //1.普通的泛型方法
        public <T> String commonMethod(String name,T t){
            String res = "";
            res += name +"-&#
    更多相关内容
  • 下面小编就为大家带来一篇浅谈java中定义泛型和定义泛型方法的写法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java泛型方法定义和使用

    千次阅读 多人点赞 2021-11-13 14:50:27
    ???? 周周有福利,周周有惊喜 哪吒社区 - 风火轮计划 ???? Java学习路线配套文章:Java学习路线总结,搬砖工逆袭Java架构师(全网最强) ... Java经典面试题大全:10万字208道Java经典面试题...Java泛型是J2 SE1.5中引入

    🍅 周周有福利,周周有惊喜 哪吒社区 - 风火轮计划
    🍅 Java学习路线配套文章:Java学习路线总结,搬砖工逆袭Java架构师(全网最强)
    🍅 Java经典面试题大全:10万字208道Java经典面试题总结(附答案)
    🍅 简介:Java领域优质创作者🏆、CSDN哪吒公众号作者✌ 、Java架构师奋斗者💪
    🍅 扫描主页左侧二维码,加入群聊,一起学习、一起进步
    🍅 欢迎点赞 👍 收藏 ⭐留言 📝

    一、基本介绍

    Java泛型是J2 SE1.5中引入的一个新特性,其本质是参数化类型,也就是说所操作的数据类型被指定为一个参数(type parameter)这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

    二、泛型的优点

    1、类型安全

    泛型的主要目的是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在非常高的层次上验证类型假设。没有泛型,这些假设就只能存在于系统开发人员的头脑中。

    通过在变量声明中捕获这一附加的类型信息,泛型允许编译器实施这些附加的类型约束。类型错误就可以在编译时被捕获了,而不是在运行时当作ClassCastException展示出来。将类型检查从运行时挪到编译时有助于Java开发人员更早、更容易地找到错误,并可提高程序的可靠性。

    2、消除强制类型转换

    泛型的一个附带好处是,消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。尽管减少强制类型转换可以提高使用泛型类的代码的累赞程度,但是声明泛型变量时却会带来相应的累赞程度。在简单的程序中使用一次泛型变量不会降低代码累赞程度。但是对于多次使用泛型变量的大型程序来说,则可以累积起来降低累赞程度。所以泛型消除了强制类型转换之后,会使得代码加清晰和筒洁。

    3、更高的效率

    在非泛型编程中,将筒单类型作为Object传递时会引起Boxing(装箱)和Unboxing(拆箱)操作,这两个过程都是具有很大开销的。引入泛型后,就不必进行Boxing和Unboxing操作了,所以运行效率相对较高,特别在对集合操作非常频繁的系统中,这个特点带来的性能提升更加明显。

    4、潜在的性能收益

    泛型为较大的优化带来可能。在泛型的初始实现中,编译器将强制类型转换(没有泛型的话,Java系统开发人员会指定这些强制类型转换)插入生成的字节码中。但是更多类型信息可用于编译器这一事实,为未来版本的JVM的优化带来可能。

    四、常见泛型字母含义

    格式: 类名<字母列表>

    T Type表示类型

    K V 分辨表示键值对中的key value

    E 代表Element

    ?表示不确定的类型

    五、使用泛型时的注意事项

    1、在定义一个泛型类时,在“<>”之间定义形式类型参数,例如:“class TestGen<K,V>”,其中“K”,“V”不代表值,而是表示类型。

    2、实例化泛型对象时,一定要在类名后面指定类型参数的值(类型),一共要有两次书写。

    3、使用泛型时,泛型类型必须为引用数据类型,不能为基本数据类型,Java中的普通方法,构造方法,静态方法中都可以使用泛型,方法使用泛型之前必须先对泛型进行声明,可以使用任意字母,一般都要大写。

    4、不可以定义泛型数组。

    5、在static方法中不可以使用泛型,泛型变量也不可以用static关键字来修饰。

    6、根据同一个泛型类衍生出来的多个类之间没有任何关系,不可以互相赋值。

    7、泛型只在编译器有效

    六、泛型的使用

    泛型有三种使用方式,分别为:泛型类、泛型接口、泛型方法

    1、泛型类

    package javase.genericity;
     
    //此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
    //在实例化泛型类时,必须指定T的具体类型
    public class Generic<T> {
        //key这个成员变量的类型为T,T的类型由外部指定
        private T key;
        //泛型构造方法形参key的类型也为T,T的类型由外部指定
        public Generic(T key){
            this.key = key;
        }
        //泛型方法getKey的返回值类型为T,T的类型由外部指定
        public T getKey(){
            return key;
        }
     
        public static void main(String[] args) {
            //泛型的类型参数只能是类类型(包括自定义类),不能是简单类型
            //传入的实参类型需与泛型的类型参数类型相同,即为Integer.
            Generic<Integer> genericInteger = new Generic<Integer>(123456);
            //传入的实参类型需与泛型的类型参数类型相同,即为String.
            Generic<String> genericString = new Generic<String>("江疏影");
            System.out.println("泛型测试,key is "+genericInteger.getKey());
            System.out.println("泛型测试,key is "+genericString.getKey());
        }
    }
    

    泛型参数就是随便传的意思!

     
    Generic generic = new Generic("111111");
    Generic generic1 = new Generic(4444);
    Generic generic2 = new Generic(55.55);
    Generic generic3 = new Generic(false);
    




    更多用法详见:【Java基础知识 11】java泛型方法的定义和使用

    上一篇:Java零基础入门 12:Java中的Object类

    下一篇:Java零基础入门 14:java枚举类

    在这里插入图片描述

    添加微信,备注1024,赠送Java学习路线思维导图
    展开全文
  • Java泛型定义和使用详解

    千次阅读 2021-06-29 18:24:14
    一,为什么我们需要泛型 通过分析下面两种情况,来得出我们为什么需要泛型。 1.对两个数值类型求和的情况,如下代码,当两个数值是int类型时,需要实现一个方法对int类型的数值求和。当两个数值是Float类型时,...

    目录

    一,为什么我们需要泛型

    二,什么是泛型,泛型的定义

    三,如何定义和使用泛型

    四、限定类型变量

    五、泛型中的约束和局限性

    六、泛型类型的继承规则

    七、通配符类型

    八、虚拟机是如何实现泛型的?


    一,为什么我们需要泛型

    通过分析下面两种情况,来得出我们为什么需要泛型。

    1.对两个数值类型求和的情况,如下代码,当两个数值是int类型时,需要实现一个方法对int类型的数值求和。当两个数值是Float类型时,需要实现一个方法对Float类型的数值求和。如果两个数值是Double类型时,还需要再实现一个方法对Double类型的数值求和。

    	public int addInt(int x, int y) {
    		return x+y;
    	}
    	
    	public float addFloat(float x, float y) {
    		return x+y;
    	}

    我们发现对两个数值求和时,都是一样的操作(加法运算),但当两个数值的数据类型改变时,就需要重新实现一个新的求和方法。同样的一段代码,只是因为传入的参数不同,这里就必须要重写这个方法,这样会导致代码非常臃肿,也不灵活。

    这种情况下我们能不能写出一段代码,代码的逻辑是一样的,根据传入的参数不同,自动进行运算。这就是泛型需要的地方之一。

    适用多种数据类型,执行相同的代码,这是泛型的用处之一。

    2.声明一个List集合,如下代码,不带任何的类型说明,向List里面添加一些元素,加入String和Integer对象,这时候编译不会报错。然后我们打印出List中的元素,运行的时候抛出一个异常"java.lang.Integer cannot be cast to java.lang.String",Integer对象不能转换成一个String对象。

    因为这里声明的List没有规定它的类型,此时List默认的类型是Object,Object是所有类的父类,所以把不同类型的数据添加到List中没有问题。但是从List中取数据的时候,取到的所有数据都是Object,所以在使用这些数据的时候就需要强制类型转换。如下代码中需要打印出String,就需要强制转换成String类型,但是由于List中还添加了Integer类型的数据,这时候强制类型转换就会报异常"ClassCastException"。

    所以这里就需要使用到泛型,List集合定义了泛型之后,List集合中只能添加指定类型的数据,不然会编译不通过,在编译的时候就找到错误。而且从List集合中取数据的时候,不需要强制类型转换,可以直接用。

    这就是使用泛型的好处,在编码的过程中,可以指定数据类型,不需要进行强制类型转换。以及如果我们插入错误的数据类型,在编译期间就能够发现,不至于在运行的时候才抛类转换异常。

    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		List list = new ArrayList();
    		list.add("mark");
    		list.add("OK");
    		list.add(new Integer(100));
    		
    		for(int i = 0; i < list.size(); i++){
    			String name = (String) list.get(i);
    			System.out.println("name: " + name);
    		}
    	}

    所以泛型的好处就是:

    1,适用多种数据类型,执行相同的代码。

    2,在编码的过程中,指定数据类型,不需要进行强制类型转换。以及如果我们插入错误的数据类型,在编译期间就能够发现,不至于在运行的时候才抛类转换异常。

    二,什么是泛型,泛型的定义

    泛型的定义:参数化类型

    泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?

    顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。

    简单点说普通的方法定义,已经明确确定了需要传入的参数类型,调用方法的时候,只能改变传入的参数值,不能改变传入的参数类型,否则编译时会报错。

    使用泛型定义方法,需要传入的参数类型和参数值都是没有明确确定的,调用方法的时候,由调用者确定传入的参数类型和参数值。

    参数化类型,不同类型的参数可以由同一段代码处理。

    泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。

    三,如何定义和使用泛型

    假如我们自己要定义泛型,如何去定义泛型呢?

    泛型分为三种:泛型类、泛型接口、泛型方法。

    泛型使用时引入一个类型变量,比较常用的有T,E,K,V等等,一般来讲就这么几种,都是约定俗成的。

    泛型类

    定义泛型类,在类名后面加尖括号T(也可以是其他的字符),然后可以用T去定义变量和方法(方法返回值和参数。泛型类是允许有多个类型变量的。

    实现和测试代码去下。

    public class NormalGeneric<T> {
    	private T data;
    	
    	public NormalGeneric(){
    		
    	}
    	
    	public NormalGeneric(T data){
    		this.data = data;
    	}
    	
    	public T getData(){
    		return data;
    	}
    	
    	public void setData(T data){
    		this.data = data;
    	}
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		NormalGeneric<String> normalGeneric = new NormalGeneric<>();
    		normalGeneric.setData("hello Generic");
    		//normalGeneric.setData(12); //编译不通过报错,因为已经声明了泛型类的类型了
    		System.out.println(normalGeneric.getData());
    	}
    
    }
    public class NormalGeneric2<T, K> {
    	private T data;
    	private K result;
    }

    泛型接口

    除了泛型类,接口也可以定义泛型。泛型接口的定义和泛型类差不多。

    定义泛型接口,在接口名后面加尖括号T,然后可以用T去定义抽象方法。

    public interface Genertor<T> {
    	public T next();
    }

    我们平时用接口的时候,都是用它的实现类。那么对于泛型接口来讲,要怎么去写它的实现类,

    这里有两种方式。

    第一种实现方式,使用泛型类实现泛型接口。

    在实现泛型接口的时候,并不给泛型赋一个实际类型,这个类本身还是一个泛型类,在类名后面加尖括号T,这是一种实现泛型接口的方式。

    泛型类实现泛型接口,它在使用上和其他普通的泛型类并没有什么区别。

    public class ImplGenertor<T> implements Genertor<T> {
    
    	@Override
    	public T next() {
    		// TODO Auto-generated method stub
    		return null;
    	}
    
    }

    第二种实现方式,在实现泛型接口的时候,直接规定泛型接口的类型。在泛型接口里面,T是一个参数化类型,实现泛型接口的时候,规定了参数化类型的类型。

    public class ImplGenertor2 implements Genertor<String> {
    
    	@Override
    	public String next() {
    		// TODO Auto-generated method stub
    		return null;
    	}
    
    }

    泛型方法

    泛型方法和泛型类以及泛型接口都有所不同,泛型方法可以是完全独立的,没有要求泛型方法一定要声明在泛型类或泛型接口中,泛型方法可以声明在普通类和普通接口中。

    如下代码中声明的泛型方法。方法的返回值变成参数化类型,在修饰符和返回值之间多了一个用尖括号括起来的类型,这样声明定义的方法就是泛型方法。尖括号括起来的类型变量是声明定义泛型方法必须要的,没有这个就不是泛型方法。

    public class GenericMethod {
    
    	public <T> T genericMethod(T...a){
    		return a[a.length / 2];
    	}
    	
    	public void test(int x, int y){
    		System.out.println(x + y);
    	}
    	
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		GenericMethod genericMethod = new GenericMethod();
    		genericMethod.test(54, 864);
    		System.out.println(genericMethod.<String>genericMethod("hello", "word", "2021"));
    		System.out.println(genericMethod.genericMethod(11, 22, 33));
    	}
    
    }

    不管是泛型类还是泛型方法,都是允许定义多个泛型的。

    那么泛型方法与泛型类或泛型接口有什么区别呢?

    泛型类或泛型接口必须是在new创建对象实例的时候,告诉编译器类型变量的具体类型。而泛型方法是在调用的时候,告诉编译器当前这个泛型方法传入的具体参数类型是什么。

    泛型方法是在调用方法的时候指明泛型的具体类型,可以在任何地方和任何场景中使用,包括普通类和泛型类,注意泛型类中定义的普通方法和泛型方法是有区别的。

    下面代码讲述泛型方法的区别。

    /**
     * 这是一个普通类
     */
    public class GenericMethod2{
    	/**
    	 * 这个类是个泛型类
    	 * @param <T>
    	 */
    	public class Generic<T> {
    		private T key;
    		
    		public Generic(){
    			
    		}
    		
    		public Generic(T key){
    			this.key = key;
    		}
    		
    	    /**
    	     * 虽然在方法中使用了泛型,但是这并不是一个泛型方法。
    	     * 这只是泛型类中一个普通的成员方法,只不过他的返回值是在声明泛型类已经声明过的泛型。
    	     * 所以在这个方法中才可以继续使用 T 这个泛型。
    	     * 
    	     * @return
    	     */
    		public T getKey(){
    			return key;
    		}
    		
    	    /**
    	     * 编译报错
    	     * 这个方法显然是有问题的,在编译器会给我们提示这样的错误信息"E cannot be resolved to a type"
    	     * 因为在类的声明中并未声明泛型E,所以在使用E做形参和返回值类型时,编译器会无法识别。
    	     */
    	    public E setKey(E key){
    	        this.key = key;
    	    }
    	    
    	    /**
    	     * 这才是一个真正的泛型方法。
    	     * 首先在public与返回值之间的<T>必不可少,这表明这是一个泛型方法,并且声明了一个泛型T
    	     * 这个T可以出现在这个泛型方法的任意位置.
    	     * 泛型的数量也可以为任意多个
    	     * @param container
    	     * @return
    	     */
    		public <E,K> K showKeyName(Generic<E> container){
    			
    	    	return null;
    	    }
    	    
    	    /**
    	     * 这也不是一个泛型方法,这就是一个普通的方法,
    	     * 只是使用了NormalGeneric<Number>这个泛型类做形参而已。
    	     * @param Obj
    	     */
    	    public void show(Generic<Number> Obj){
    	    	
    	    }
    	}
    	
    	/**
    	 * 这个方法是有问题的,编译错误,编译器会为我们提示错误信息:"E cannot be resolved to a type"
    	 * 虽然我们声明了<T>,也表明了这是一个可以处理泛型类型的泛型方法。
    	 * 但是只声明了泛型类型T,并未声明泛型类型E,因此编译器并不知道该如何处理E这个类型。
    	 * @param ab
    	 * @return
    	 */
    	public <T> T show(Generic<E> ab){
    		
    	}
    	
    	/**
    	 * 这个方法是有问题的,编译错误,编译器会为我们提示错误信息:"T cannot be resolved to a type"
    	 * 对于编译器来说T这个类型并未在类或方法中声明过,因此编译也不知道该如何编译这个类。
    	 * 所以这也不是一个正确的泛型方法声明。
    	 * @param obj
    	 */
    	public void show(T obj){
    		
    	}
    }

    使用泛型的时候有几点需要注意的地方:

    1.不是声明在泛型类里面的方法,就是泛型方法。

    2.泛型方法声明在泛型类中,也要遵守泛型方法的定义规则。

    下面代码泛型方法的用法和定义:

    public class GenericMethod3 {
    
    	static class Fruit{
    		@Override
    		public String toString() {
    			return "fruit";
    		}
    	}
    	
    	static class Apple extends Fruit{
    		@Override
    		public String toString() {
    			return "apple";
    		}
    	}
    	
    	static class Person{
    		@Override
    		public String toString() {
    			return "person";
    		}
    	}
    	
    	static class GenerateTest<T>{
    		public void show_1(T t){
    			System.out.println(t.toString());
    		}
    		
    		/**
    		 * 在泛型类中声明了一个泛型方法,使用泛型E,这个泛型E可以为任意类型。
    		 * 类型可以与T相同,也可以不同。
    		 * 由于泛型方法在声明的时候会声明泛型<E>,因此即使在泛型类中并未声明该泛型,
    		 * 编译器也能够正确识别泛型方法中的泛型。
    		 * @param e
    		 */
    		public <E> void show_2(E e){
    			System.out.println(e.toString());
    		}
    		
    		/**
    		 * 在泛型类中声明了一个泛型方法,使用泛型T,
    		 * 注意这个T是一种全新的类型,可以与泛型类中声明的T不是同一种类型。
    		 * 泛型类和泛型方法中定义的泛型,它的作用域是不一样的。前者是在整个类中可以使用,后者只能在该方法中使用
    		 * @param t
    		 */
    		public <T> void show_3(T t){
    			System.out.println(t.toString());
    		}
    	}
    	
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Apple apple = new Apple();
    		Person person = new Person();
    		
    		GenerateTest<Fruit> generateTest = new GenerateTest<>();
    		
    		//不会报错,因为Apple是Fruit的子类。
    		generateTest.show_1(apple); 
    		//编译报错,因为创建GenerateTest实例时,已经确定泛型的类型是Fruit
    		generateTest.show_1(person);
    		
    		generateTest.show_2(apple);
    		generateTest.show_2(person);
    		
    		generateTest.show_3(apple);
    		generateTest.show_3(person);
    	}

    四、限定类型变量

    有时候,我们需要对类型变量加以约束,比如计算两个变量的最小或最大值。

    public static <T> T min(T a, T b){
    		if(a.compareTo(b) > 0) return a; else return b;
    	}

    如下代码,我们实现了一个泛型方法,然后调用compareTo方法比较传入的两个对象,但是编译报错"The method compareTo(T) is undefined for the type T",泛型T找不到找不到方法compareTo。

    那么确保传入的两个变量一定有compareTo方法呢?解决这个问题的方案就是将T限定为实现了接口Comparable的类。

    	public static <T extends Comparable> T min(T a, T b){
    		if(a.compareTo(b) > 0) return a; else return b;
    	}

    T extends Comparable中 extends(派生、继承)

    T表示应该绑定类型的子类型,Comparable表示绑定类型,子类型和绑定类型可以是类也可以是接口。

    同时extends左右都允许有多个,如 T,V extends Comparable & Serializable

    注意限定类型中,只允许有一个类,而且如果有类,这个类必须是限定列表的第一个。因为在java中类是单继承,接口是多实现。

    如果这个时候,我们试图传入一个没有实现接口Comparable的类的实例,将会发生编译错误。

    /**
     * 类说明:类型变量的限定-用在方法上
     *
     */
    public class ArrayAlg {
    	
    	/**
    	 * 编译报错,泛型T找不到找不到方法compareTo()方法,因为泛型T没有限定类型
    	 * @param a
    	 * @param b
    	 * @return
    	 */
    //	public static <T> T min(T a, T b){
    //		if(a.compareTo(b) > 0) return a; else return b;
    //	}
    	
    	/**
    	 * 取两个对象的最小值,类型变量限定为必须要实现了Comparable接口
    	 * @param a
    	 * @param b
    	 * @return
    	 */
    	public static <T extends Comparable> T min(T a, T b){
    		if(a.compareTo(b) > 0) return b; else return a;
    	}
    	
    	/**
    	 * 取两个对象的最大值,类型变量限定为必须要实现了Comparable接口
    	 * @param a
    	 * @param b
    	 * @return
    	 */
    	public static <T extends Comparable> T max(T a, T b){
    		if(a.compareTo(b) > 0) return a; else return b;
    	}
    	
    	static class Test{}
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println(ArrayAlg.min("hello", "world"));
    		System.out.println(ArrayAlg.min(22, 12));
    		//编译报错,因为Test类没有实现Compareble接口
    		//ArrayAlg.min(new Test(), new Test());
    		System.out.println(ArrayAlg.max(22, 12));
    	}
    
    }

    这种类型变量的限定既可以用在泛型方法上也可以用在泛型类上。使用方法都是一模一样的。下面是类型变量的限定,用在泛型类上面。

    /**
     * 类说明:类型变量的限定-用在类上
     *
     * @param <T>
     */
    public class ClassBorder<T extends Comparable> {
    
    	private T data;
    	
    	public T min(T outter){
    		if(this.data.compareTo(outter) > 0)
    			return outter;
    		else
    			return this.data;
    	}
    	
    	public T getData(){
    		return data;
    	}
    	
    	public void setData(T data){
    		this.data = data;
    	}
    	
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		ClassBorder<String> classBorder = new ClassBorder<>();
    		classBorder.setData("Java");
    		System.out.println(classBorder.min("Python"));
    	}
    
    }

    五、泛型中的约束和局限性

    /**
     * 泛型类的原始类型,不会带上泛型的信息。
     *
     * @param <T>
     */
    public class Restrict<T> {
    
    	private T data;
    	
    	/**
    	 * 编译报错:Cannot instantiate the type T
    	 * 不能实例化类型变量,不能new类型变量。
    	 */
    	public Restrict(){
    		this.data = new T();
    	}
    	
    	//静态域或者静态方法里面,不能引用类型变量 
    	//因为泛型类是在new创建对象实例的时候,告诉编译器类型变量的具体类型。
    	//而虚拟机创建对象的代码执行先后顺序是static的部分,然后才是构造函数等等。
    	private static T instance;
    	
    	//静态方法本身是泛型方法就行
    	private static <T> T getInstance(){
    		return null;
    	}
    	
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//不能用基本类型实例化类型参数,在Java中基本类型数据不是一个对象
    		Restrict<double> restrictDouble1 = new Restrict<>();
    		Restrict<Double> restrictDouble2 = new Restrict<>();
    		
    		//泛型不能用instanceof关键字判断类型
    		if(restrictDouble2 instanceof Restrict<Double>){}
    		if(restrictDouble2 instanceof Restrict<T>){}
    		
    		//运行时类型查询只适用于原始类型,不会带上泛型的类型变量
    		Restrict<String> restrictStr = new Restrict<>();
    		System.out.println(restrictDouble2.getClass() == restrictStr.getClass());
    		System.out.println(restrictDouble2.getClass().getName());
    		System.out.println(restrictStr.getClass().getName());
    		
    		//编译报错:Cannot create a generic array of Restrict<Double>
    		//可以定义泛型数组,但是不能创建泛型数组(不能创建参数化类型的数组)
    		Restrict<Double>[] restrictArray; //可以
    		Restrict<Double>[] resticts = new Restrict<Double>[10]; //不可以,编译失败
    	}

    不能在静态域或方法中引用类型变量。因为泛型是要在对象创建的时候才知道是什么类型的,而虚拟机创建对象的代码执行先后顺序是static的部分,然后才是构造函数等等。所以在对象初始化之前static的部分已经执行了,如果你在静态部分引用的泛型,那么毫无疑问虚拟机根本不知道是什么东西,因为这个时候类还没有初始化。

    /**
     * 类说明:泛型和异常
     */
    public class ExceptionRestrict {
    
    	/**
    	 * 编译报错:
    	 * The generic class ExceptionRestrict.Problem<T> may not subclass java.lang.Throwable
    	 * 泛型类不能 extends Exception/Throwable
    	 */
    	private class Problem<T> extends Exception{}
    	
    	/**
    	 * 编译报错:Cannot use the type parameter T in a catch block
    	 * 不能捕获泛型类的实例
    	 */
    	public <T extends Throwable> void doWork1(T t){
    		try{
    			
    		}catch(T e){
    			//todo
    		}
    	}
    	
    	/**
    	 * 这种方式是可以的。不能捕获泛型类的实例,但还可以抛出泛型类的实例。
    	 * 泛型类也可以写在throws后面。
    	 * @param t
    	 * @throws T
    	 */
    	public <T extends Throwable> void doWork2(T t) throws T{
    		try{
    			
    		}catch(Throwable e){
    			throw t;
    		}
    	}
    	
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    	}
    
    }

    六、泛型类型的继承规则

    如下代码展示泛型的继承原则:

    public class Employee {
        private String firstName;
        private String secondName;
    
        public String getFirstName() {
            return firstName;
        }
    
        public void setFirstName(String firstName) {
            this.firstName = firstName;
        }
    
        public String getSecondName() {
            return secondName;
        }
    
        public void setSecondName(String secondName) {
            this.secondName = secondName;
        }
    }
    public class Worker extends Employee {
    }
    public class Pair<T> {
    
    	private T one;
    	private T two;
    	
    	
    	
    	public T getOne() {
    		return one;
    	}
    
    
    
    	public void setOne(T one) {
    		this.one = one;
    	}
    
    
    
    	public T getTwo() {
    		return two;
    	}
    
    
    
    	public void setTwo(T two) {
    		this.two = two;
    	}
    
    	private static <T> void set(Pair<Employee> p){
    		
    	}
     
     	/*泛型类可以继承或者扩展其他泛型类,比如List和ArrayList*/
    	private static class ExtendsPair<T> extends Pair<T>{}
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    		//Pair<Employee>和Pair<Worker>没有任何继承关系
    		Pair<Employee> employeePair = new Pair<>();
    		Pair<Worker> workerPair = new Pair<>();
    		
    		//子类给父类赋值,是可以的
    		Employee employee = new Worker();
    		//编译报错:Type mismatch: cannot convert from Pair<Worker> to Pair<Employee>
    		//这就说明Pair<Employee>和Pair<Worker>没有任何继承关系
    		Pair<Employee> employeePair2 = new Pair<Worker>();
    		
    		//这种方式是可以的
    		Pair<Employee> pari = new ExtendsPair<>();
    		//可以
    		set(employeePair);
    		//编译报错:The method set(Pair<Employee>) in the type Pair<T> is not applicable for the arguments (Pair<Worker>)
    		//Pair<Employee>和Pair<Worker>没有任何继承关系
    		set(workerPair); 
    		//可以的
    		set(pari);
    	}
    }

    泛型

    1.泛型的类型变量之间,不考虑任务继承关系。类型之间的继承关系,不代表泛型的参数化类型之间有继承关系。

    2.泛型类可以继承或者扩展其他泛型类,比如List和ArrayList。

    七、通配符类型

    我们先定义一些有继承关系的类和一个泛型类

    public class Fruit {
    
    	private String color;
    
    	public String getColor() {
    		return color;
    	}
    
    	public void setColor(String color) {
    		this.color = color;
    	}
    }
    public class Food {
    
    }
    public class Apple extends Fruit {
    
    }
    public class Orange extends Fruit {
    
    }
    public class HongFuShi extends Apple {
    
    }
    public class GenericType<T> {
    
    	private T data;
    
    	public T getData() {
    		return data;
    	}
    
    	public void setData(T data) {
    		this.data = data;
    	}
    }

    正是因为前面所述的,GenericType<Fruit>和GenericType<Orange>没有任何继承关系,现在我们有一个方法如下:

    	public static void print(GenericType<Fruit> p){
    		System.out.println(p.getData().getColor());
    	}

    在调用这个方法的时候,会出现如下的问题:

    	public static void use(){
    		GenericType<Fruit> a = new GenericType<>();
    		print(a);
    		GenericType<Orange> b = new GenericType<>();
    		//编译报错:The method print(GenericType<Fruit>) in the type WildChar is not applicable for the arguments (GenericType<Orange>)
    		//类型之间的继承关系,不代表泛型的参数化类型之间有继承关系。
    		//GenericType<Fruit>和GenericType<Orange>没有任何继承关系。
    		print(b);
    	}

    因为GenericType<Fruit>和GenericType<Orange>没有任何继承关系,所以调用print(GenericType<Fruit> p)方法时,传入GenericType<Orange>实例对象就会编译报错。这样的程序看起来非常不灵活,Orange和Fruit是继承关系,但泛型变量可以是Fruit,不能是Orang。

    为解决这个问题,于是提出了一个通配符类型 ?

    有两种使用方式:

    ? extends X  表示类型的上界,类型参数是X的子类

    ? super X  表示类型的下界,类型参数是X的超类

    这两种 方式从名字上来看,特别是super,很有迷惑性,下面我们来仔细辨析这两种方法。

    通配符类型和限定类型变量的区别:

    1.限定类型变量是在定义泛型类和泛型方法时,限定类型变量的类型。

    2.通配符类型一般用在方法的参数上面。扩展支持的泛型类实例的类型变量。

    ? extends X

    表示传递给方法的泛型类实例的类型变量,必须是X的子类(包括X本身)

    但是对泛型类GenericType来说,如果其中提供了get和set类型参数变量的方法的话,set方法是不允许被调用的,会出现编译错误。

    get方法则没问题,会返回一个Fruit类型的值。

    	public static void print2(GenericType<? extends Fruit> p){
    		System.out.println(p.getData().getColor());
    	}
    	
    	private static void use2(){
    		GenericType<Fruit> a = new GenericType<>();
    		print2(a);
    		GenericType<Orange> b = new GenericType<>();
    		//这样是可以的
    		print2(b);
    		//编译报错:The method print2(GenericType<? extends Fruit>) in the type WildChar is not applicable for the arguments (GenericType<Food>)
    		//因为Food是Fruit的父类,而这里的泛型类型变量只能是Fruit的子类或本身。
    		print2(new GenericType<Food>());
    		//这样赋值是可以的
    		GenericType<? extends Fruit> c = b;
    		
    		Apple apple = new Apple();
    		Fruit fruit = new Fruit();
    		//这个样是可以的,因为new创建泛型类对象的时候,确定了类型变量为Fruit
    		a.setData(fruit);
    		//编译报错:The method setData(capture#2-of ? extends Fruit) in the type GenericType<capture#2-of ? extends Fruit> is not applicable for the arguments (Apple)
    		c.setData(apple);
    		c.setData(fruit);
    		//这个样是可以的
    		Fruit f = c.getData();
    		//编译报错:Type mismatch: cannot convert from capture#5-of ? extends Fruit to Orange
    		//类型转换异常,这时候编译器只知道c.getData()返回的是一个Fruit类实例。
    		Orange o = c.getData();
    	}

    那么为什么会这样呢?

    道理很简单,? extends X  表示类型的上界,类型参数是X的子类,那么可以肯定的说,get方法返回的一定是个X(不管是X或者X的子类)编译器是可以确定知道的。但是set方法只知道传入的是个X,至于具体是X的那个子类,不知道。

    总结:主要用于安全地访问数据,可以访问X及其子类型,并且不能写入非null的数据。

    ? super X

    表示传递给方法的泛型类实例的类型变量,必须是X的超类(包括X本身)

    	public static void printSuper(GenericType<? super Apple> p){
    		System.out.println(p.getData());
    	}
    	
    	public static void useSuper(){
    		GenericType<Fruit> fruitGeneticType = new GenericType<>();
    		GenericType<Apple> appleGeneticType = new GenericType<>();
    		GenericType<HongFuShi> hongfushiGeneticType = new GenericType<>();
    		GenericType<Orange> orangeGeneticType = new GenericType<>();
    		printSuper(fruitGeneticType);
    		printSuper(appleGeneticType);
    		//编译报错:The method printSuper(GenericType<? super Apple>) in the type WildChar is not applicable for the arguments (GenericType<HongFuShi>)
    		printSuper(hongfushiGeneticType);
    		//编译报错
    		printSuper(orangeGeneticType);
    		
    		//表示GenericType的类型参数的下界是Apple
    		GenericType<? super Apple> x = new GenericType<>();
    		x.setData(new Apple());
    		x.setData(new HongFuShi());
    		//这样是不行的,编译报错。
    		x.setData(new Fruit());
    		//唯一可行的赋值
    		Object data = x.getData();
    	}

    但是对泛型类GenericType来说,如果其中提供了get和set类型参数变量的方法的话,set方法可以被调用的,且能传入的参数只能是X或者X的子类。

    get方法只会返回一个Object类型的值。

    那么为什么会这样呢?

    ? super X  表示类型的下界,类型参数是X的超类(包括X本身),那么可以肯定的说,get方法返回的一定是个X的超类,那么到底是哪个超类?不知道,但是可以肯定的说,Object一定是它的超类,所以get方法返回Object。编译器是可以确定知道的。对于set方法来说,编译器不知道它需要的确切类型,但是X和X的子类可以安全的转型为X,而X的超类不能安全的转型为X。

    总结:主要用于安全地写入数据,可以写入X及其子类型。

    无限定的通配符 ?

    表示对类型没有什么限制,可以把?看成所有类型的父类,如Pair< ?>;

    比如:

    ArrayList<T> al=new ArrayList<T>(); 指定集合元素只能是T类型

    ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型,这种没有意义,一般是方法中,只是为了说明用法。

    在使用上:

    ? getFirst() : 返回值只能赋给 Object;

    void setFirst(?) : setFirst 方法不能被调用, 甚至不能用 Object 调用;

    八、虚拟机是如何实现泛型的?

    泛型思想早在C++语言的模板(Template)中就开始生根发芽,在Java语言处于还没有出现泛型的版本时,只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。由于Java语言里面所有的类型都继承于java.lang.Object,所以Object转型成任何对象都是有可能的。但是也因为有无限的可能性,就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间,编译器无法检查这个Object的强制转型是否成功,如果仅仅依赖程序员去保障这项操作的正确性,许多ClassCastException的风险就会转嫁到程序运行期之中。

    泛型技术在C#和Java之中的使用方式看似相同,但实现上却有着根本性的分歧,C#里面泛型无论在程序源码中、编译后的IL中(Intermediate Language,中间语言,这时候泛型是一个占位符),或是运行期的CLR中,都是切实存在的,List<int>与List<String>就是两个不同的类型,它们在系统运行期生成,有自己的虚方法表和类型数据,这种实现称为类型膨胀,基于这种方法实现的泛型称为真实泛型。

    Java语言中的泛型则不一样,它只在程序源码中存在,在编译后的字节码文件中,就已经替换为原来的原生类型(Raw Type,也称为裸类型)了,并且在相应的地方插入了强制转型代码,因此,对于运行期的Java语言来说,ArrayList<int>与ArrayList<String>就是同一个类,所以泛型技术实际上是Java语言的一颗语法糖,Java语言中的泛型实现方法称为类型擦除,基于这种方法实现的泛型称为伪泛型。

    将一段Java代码编译成Class文件,然后再用字节码反编译工具进行反编译后,将会发现泛型都不见了,程序又变回了Java泛型出现之前的写法,泛型类型都变回了原生类型

    	public static String method(List<String> stringList){
    		System.out.println("String List");
    		return "String";
    	}
    	
    	public static String method(List<Integer> integerList){
    		System.out.println("Integer List");
    		return Integer;
    	}

    上面这段代码是不能被编译的,因为参数List<Integer>和List<String>编译之后都被擦除了,变成了一样的原生类型List<E>,擦除动作导致这两种方法的特征签名变得一模一样。

    (方法重载时两个方法方法名和参数都相同,返回值类型不同是,jdk的编译器不会报错,但是一般IDE的编译器会报错)。

    由于Java泛型的引入,各种场景(虚拟机解析、反射等)下的方法调用都可能对原有的基础产生影响和新的需求,如在泛型类中如何获取传入的参数化类型等。因此,JCP组织对虚拟机规范做出了相应的修改,引入了诸如Signature、LocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题,Signature是其中最重要的一项属性,它的作用就是存储一个方法在字节码层面的特征签名[3],这个属性中保存的参数类型并不是原生类型,而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别49.0以上版本的Class文件的虚拟机都要能正确地识别Signature参数。

    另外,从Signature属性的出现我们还可以得出结论,擦除法所谓的擦除,仅仅是对方法的Code属性中的字节码进行擦除,实际上元数据中还是保留了泛型信息,这也是我们能通过反射手段取得参数化类型的根本依据。

    展开全文
  • 泛型定义使用

    2021-03-06 13:26:15
    定义和使用含有泛型的类 定义格式: 修饰符 class 类名<代表泛型的变量>{} 例如,API中的ArrayList集合: class ArrayList<E>{ public boolean add(E e){ } public E get(int index){ } .... } `...

    泛型的定义与使用

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

    定义和使用含有泛型的类

    定义格式:
    修饰符 class 类名<代表泛型的变量>{}

    例如,API中的ArrayList集合:

    class ArrayList<E>{ 
        public boolean add(E e){ }
        public E get(int index){ }
       	....
    }
    

    `使用泛型:即什么时候使用泛型就确定泛型的类型(重点)

    在创建对象的时候确定泛型

    例如,ArrayList<String> list = new ArrayList<String>();

    此时,变量E的值就是String类型,那么我们的类型就可以理解为:

    class ArrayList{

     
         public boolean add(String e){ }
    
         public String get(int index){  }
         ...
    }
    

    再例如,ArrayList<Integer> list = new ArrayList<Integer>();

    此时,变量E的值就是Integer类型,那么我们的类型就可以理解为:

    class ArrayList<Integer> { 
         public boolean add(Integer e) { }
    
         public Integer get(int index) {  }
         ...
    }
    

    不使用泛型的弊端:不安全,会抛出相关异常
    相关代码如下

    /**
         * 创建集合对象,不使用泛型
         * 好处:
         *     集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据
    
         * 弊端:
         *    不安全,会引发异常
         */
    
    private static void show01() {
            ArrayList list= new ArrayList();
            list.add("小明");
            list.add(1);
            list.add("sssss");
            //使用迭代器进行迭代
            Iterator iterator = list.iterator();
            while (iterator.hasNext()) {
                //存的时候是Object类型 取的时候也是Object类型
                Object obj = iterator.next();
                System.out.println(obj);
    
                //要想使用String类特有的方法,length获取字符串的长度;不能使用多态 Object obj="abc"  父类对象不能使用子类特有的方法
                //需要向下转型
                //会抛出ClassCastException 类型转换异常
                String s=(String)obj;
                System.out.println(s.length());
            }
        }
    
    }
    

    在这里插入图片描述使用泛型的好处

    /**
     * 创建集合对象。使用泛型
     * 好处:
     *     1.避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型
     *     2.把运行期异常(代码运行之后抛出的异常),提升到了编译期(写代码的时候)
     * 弊端: 泛型是什么类型,就只能存储什么类型
     */
    
          private static void show02(){
              ArrayList<String> list2 = new ArrayList<String>();
              list2.add("aaaaa");
              //list2.add(111);(会报错,因为已经定义了泛型为String)
              //使用迭代器遍历ArrayList集合
              Iterator<String> iterator2 = list2.iterator();
              while (iterator2.hasNext()) {
                  String s = iterator2.next();
                  System.out.println(s);
              }
    
          }
    

    自己定义和使用含有泛型的类
    相关代码如下

    /**
     * 定义一个含有泛型的类,模拟ArrayList集合
     * 泛型是一个未知的数据类型,当我们不确定是什么数据类型的时候,可以使用泛型
     * 泛型可以接受任意的数据类型(重点)
     * 创建对象的时候确定数据类型
     */
    

    注意 写上不用也可以此时就会变为一个普通类 不会产生什么影响 就不会默认返回Obhect类型

    在这里插入图片描述

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

    测试类

    public class Demo02Test {
    
        /**
         * 测试类
         *
         */
        public static void main(String[] args) {
            //不写泛型默认为Object类型
            GenericClass gc = new GenericClass();
            gc.setName("qqqq");
            Object name = gc.getName();
            System.out.println(name);
    
            /**
             * 创建GenericClass对象 泛型使用Integer类型
             */
            GenericClass<Integer> gc2 = new GenericClass<Integer>();
            gc2.setName(1);
            Integer name1 = gc2.getName();
            System.out.println(name1);
            /**
             * 创建GenericClass对象,泛型使用String类型
             */
            GenericClass<String> gc3 = new GenericClass<String>();
            gc3.setName("qqqqqqqq");
            String name2 = gc3.getName();
            System.out.println(name2);
        }
    }
    

    在这里插入图片描述定义个使用含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间
    定义格式:
    修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
    方法体;
    }
    含有泛型的方法,在调用方法的时候确定泛型的数据类型
    传递什么类型的参数,泛型就是什么类型

    示例:

    /**
     * 定义含有泛型的方法
     */
    public class GenericMethod {
        public <E> void method01(E e){
            System.out.println(e);
        }
    }
    

    注意
    在这里插入图片描述在这里插入图片描述定义和使用含有泛型的接口
    1.第一种方式

    /**
     * 定义含有泛型的接口
    例子
    public interface Iterator<E> {
            E next();
        }
        Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默认就是String
        public final class Scanner implements Iterator<String>{
            public String next() {}
    
     */
    
    
    public interface GenericInterface<I> {
        public abstract void method(I i);
    
    }
    /**
     * 含有泛型的接口的第一种使用方式:定义接口的实现类,指定接口的泛型
     *
     */
    public class GenericInterfaceImpl implements GenericInterface<String>{
        @Override
        public void method(String s) {
            System.out.println(s);
        }
    }
    /**
     * 测试含有泛型的接口
     */
    public class Demo04 {
        public static void main(String[] args) {
            GenericInterfaceImpl gg1 = new GenericInterfaceImpl();
            gg1.method("wwww");
        }
    }
    
    

    第二种创建方式

    /**
     * 含有泛型的接口第二种创建方式  接口使用什么泛型 实现类就使用什么泛型 让类跟着接口走
     * 就相当于定义了一个含有泛型的类, 常见对象的时候就已经确定了泛型的类型
    
    例子
    public interface List<E>{
            boolean add(E e);
            E get(int index);
        }
        public class ArrayList<E> implements List<E>{
            public boolean add(E e) {}
            public E get(int index) {}
        }
    
     */
    public class Impl2<I> implements GenericInterface<I>{
    
        @Override
        public void method(I i) {
            System.out.println(i);
        }
    }
    

    在这里插入图片描述另需特别注意
    在这里插入图片描述
    泛型的通配符

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

    通配符基本使用

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

    此时只能接受数据,不能往该集合中存储数据。(不能创建对象使用)
    相关代码如下

    /**
     * 泛型的通配符:
     *  ?:代表任意的数据类型
     * 使用方式:
     *   不能创建对象使用
     *   只能作为方法的参数使用
     */
    public class Demo05 {
        public static void main(String[] args) {
            ArrayList<String> list01 = new ArrayList<String>();
            list01.add("aaaa");
            list01.add("bbbb");
            ArrayList<Integer> list02 = new ArrayList<Integer>();
            list02.add(111);
            list02.add(222);
    
            printArray(list02);//此时就可以传任意类型泛型的集合(注意)
            printArray(list01);
    
        }
            /*
            定义一个方法,遍历所有类型的ArrayList集合
            这时候我们不知道ArrayList集合使用什么数据类型,可以使用泛型的通配符?来接受数据类型
            特别注意:
                    泛型没有继承概念
             */
             public static void printArray(ArrayList<?> list){
                 //使用迭代器遍历集合
                 Iterator<?> it = list.iterator();
                 while (it.hasNext()) {
            //it.next()方法,取出的元素是Object类型 只有Object类型可以接受任意的数据类型
                     Object next = it.next();
                     System.out.println(next);
                 }
             }
    
        }
    

    泛型通配符的高级使用(要求看源码时看懂即可)

    是一种限定

    /**
     *   泛型的上限限定: ? extends E  代表使用的泛型只能是E类型的子类/本身
     *   泛型的下限限定: ? suoer E  代表使用的泛型只能是E类型的父类/本身
     */
    public class Demo06 {
        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);//报错 lists既不是number的子类也不是本身
            getElement1(list3);
            getElement1(list4);//报错
            getElement2(list1);//报错
            getElement2(list2);//报错
            getElement2(list3);
            getElement2(list4);
        }
    
    		  类与类之间的继承关系  
    		  Integer entends Number extends Object
    		  String extends Obhect
    
    
    
        // 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
        public static void getElement1(Collection<? extends Number> coll){
    
        }
        // 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
        public static void getElement2(Collection<? super Number> coll){}
        }
    
    }
    
    
    展开全文
  • 含有泛型的方法泛型定义方法的修饰符返回值类型之间 格式如下: 修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){ 方法体; } 含有泛型的方法,在调用方法的时候确定泛型的数据类型,...
  • 泛型定义和使用

    千次阅读 2020-05-01 21:21:45
    顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。 泛型的本质是为了参数化类型(在不创建...
  • 泛型方法定义使用

    千次阅读 2020-10-24 09:49:45
    泛型方法定义使用 1.格式:修饰符 <泛型> 返回值类型 方法名(){} 示例: 泛型方法定义: public class Demo01GenericMethod { public static void main(String[] args) { GenericMethod gm = new ...
  • 泛型是一种未知的数据类型,当不知道使用什么数据类型的时候,可以使用泛型 泛型可以接受任意类型的类型,可以使用Integer,String,Student... E :未知的数据类型 例:public class ArrayList<E>{ public...
  • 泛型定义,可以按照如下格式: package com.sj; public class Person<T> { private T value; public Person() { } public Person(T value) { this.value = value; } public void setValue(T ...
  • 主要介绍了Java泛型类与泛型方法定义,结合实例形式详细分析了java泛型类与泛型方法定义、用法及相关操作注意事项,需要的朋友可以参考下
  • 泛型定义使用

    千次阅读 2020-01-25 15:10:23
    泛型是程序语言设计的一种特性,jdk1.5定义泛型,即参数化类型,就是把类型当做参数一样传递,类似于方法中的变量参数,然后在使用时传入具体的类型。 二、泛型类的实现与使用 public class<T>{}//自定义...
  • C#泛型定义和泛型方法定义

    千次阅读 2018-11-24 01:45:00
    泛型定义 定义一个泛型类就是指的是,定义一个类,这个类中某些字段的类型是不确定的,这些类型可以在类构造的时候确定下来,举例: class ClassA&amp;lt;T&amp;gt;{ private T a; private T b; public ...
  • C#泛型方法定义使用

    千次阅读 2019-10-17 11:58:43
    在C#语言中泛型方法是指通过泛型来约束方法中的参数类型,也可以理解为对...定义泛型方法需要在方法参数列表之间加上<>,并在其中使用T来代表参数类型。 当然,也可以使用其他的标识符来代替参数类型, 但...
  • Java泛型方法定义

    万次阅读 多人点赞 2019-06-22 19:30:14
    泛型方法主要用于容器类,Java中任何方法,包括静态的(注意,泛型类不允许在静态环境中使用非静态的,均可以用泛型定义,而且所在类是否是泛型没有关系。 下面是泛型方法定义 [public] [static] <T&...
  • 继承泛型结构类的几种方式和泛型中通配符的使用
  • java中定义泛型方法

    千次阅读 2020-10-14 10:24:22
    泛型形参声明放在方法修饰符和方法返回值类型之间,定义格式如下: 修饰符 <T , S> 返回值类型 方法名(形参列表) { //方法体... } 如下面泛型方法定义的示例,,其中T在 // 声明一个泛型方法,其中&...
  • 泛型方法使用

    2022-03-12 16:44:19
    泛型方法使用 泛型方法定义格式: 格式:修饰符 <类型> 返回值类型 方法名(类型 变量名){} 范例:public void show(T t){}
  • 主要介绍了Java定义泛型接口类的方法,结合实例形式分析了泛型相关概念、原理及泛型接口与类的定义实现方法,需要的朋友可以参考下
  • 泛型定义方法的修饰符返回值类型之间 格式: 修饰符<> 返回值类型 方法名(参数列表(使用泛型)){ 方法体; } 含有泛型的方法,在调用方法的时候确定泛型的数据类型 传递什么类型的参数,泛型...
  • 主要介绍了Java定义泛型方法,结合实例形式分析了java定义泛型的相关操作技巧与注意事项,需要的朋友可以参考下
  • Java中泛型方法定义

    2021-02-12 17:15:26
    2. 泛型方法定义格式[访问权限] 返回值类型 方法名([泛型标识 参数名称]){方法体;}3. 泛型方法实例public void printArray(T2[] arr){for (int i = 0; i < arr.length; i++) {System.out.prin...
  • java中的泛型,java定义泛型方法本文将详细介绍java泛型的用法以及泛型的原理java泛型泛型是在J2 SE1.5中引入的一个特性 可以将类型抽象为一个参数 从而简化代码实现类型安全如何使用泛型泛型可以用于方法...
  • JAVA泛型-泛型类的定义和使用

    千次阅读 2021-10-18 22:03:37
    1. 泛型类的声明语法 class 类名 <...2.1 定义一个泛型类 /** * author : northcastle * createTime:2021/10/18 * 自定义泛型类 */ public class MyGenerics<T> { //1.有一个普通的属性 priva
  • 问题遇到的现象发生背景 为什么静态变量静态方法中无法使用泛型,但却可以通过定义泛型方法使用 问题相关代码,请勿粘贴截图 public class GenericTest1 { // 静态方法与静态成员变量无法使用泛型 static E ...
  • 主要介绍了Java泛型定义与用法,结合实例形式较为详细的分析了Java中泛型的概念、原理、定义、使用方法及相关操作注意事项,需要的朋友可以参考下
  • 定义含有泛型的方法泛型定义方法的修饰符返回值类型之间 格式: 修饰符 <泛型> 返回值类型 方法民 (参数列表(使用泛型)){ 方法体; } 含有泛型的方法,在调用方法的时候确定泛型的数据类型 传递什么...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 224,778
精华内容 89,911
关键字:

泛型方法的定义和使用