精华内容
下载资源
问答
  • java泛型类和泛型方法
    千次阅读
    2020-05-22 16:52:10

    一、泛型

    泛型是Java 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。 Java泛型被引入的好处是安全简单。在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。

    简单来说就是引入泛型,可以在编译阶段就发现类型转换错误,从而实现安全。

    注: Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数,会在编译器在编译的时候去掉。这个过程就称为类型擦除。
    如在代码中定义的List<Integer>和List<String>等类型,在编译后都会编程List。JVM看到的只是List,而由泛型附加的类型信息对JVM来说是不可见的。

    二、泛型类

    通过一个demo来了解泛型类的用途
    从下面的demo中,我们可以分析出以下几点:
    1.泛型类的类型和类中的方法的返回值,参数类型无关
    2.泛型类大多用于在实例化时指定类为类型,从而指定方法中参数该用什么类型,在编译阶段就找出类型错误
    3.用于灵活地指定不同类的数据操作
    可参考ArrayList,LinkedList等容器类进行深入理解

    public class Genericity<E> {
    
    	public String get(Integer id){
    		return null;
    	}
    	
    	public Integer get2(String id){
    		return null;
    	}
    	
    	public void get3(E id){
    		System.out.println("get3 ....");
    	}
    	
    	public static void main(String[] args) {
    		Genericity<String> g = new Genericity<String>();
    		String a="5";
    		g.get3(5);//编译出错,5不为String类型
    		g.get3(a);//不报错,因为参数的类型和泛型类相同
    		Genericity<Integer> gg = new Genericity<Integer>();
    		gg.get3(5);//不报错,因为参数的类型和泛型类相同
    		gg.get3(a);//编译出错,a不为Integer类型
    	}
    }
    

    三、泛型方法

    泛型方法相对于泛型类要稍微复杂一点,首先我们必须清楚怎么用才是泛型方法。

    public class Genericity<E> {
    
    	 private E key;
    	
    	 public Genericity() {
             this.key = key;
         }
    	 
    	 public Genericity(E key) {
             this.key = key;
         }
    	 
         //这只是类中一个普通的成员方法,只不过他的返回值是在声明泛型类已经声明过的泛型。
         //所以在这个方法中才可以继续使用 E 这个泛型。
         public E getKey(){
             return key;
         }
    
         /**
          * 这个方法显然是有问题的,在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
          * 因为在类的声明中并未声明泛型E,所以在使用E做形参和返回值类型时,编译器会无法识别。
          */
         public T setKey(T key){
              this.key = key;
         }
         
    
     /** 
      * 这才是一个真正的泛型方法。
      * 首先在public与返回值之间的<T>必不可少,这表明这是一个泛型方法,并且声明了一个泛型T
      * 这个T可以出现在这个泛型方法的任意位置.
      * 泛型的数量也可以为任意多个 
      *    如:public <T,K> K showKeyName(Generic<T> container){
      *        ...
      *        }
      */
         
     public <E> E showKeyName(Genericity<E> container){
         System.out.println("container key :" + container.getKey());
         E test = container.getKey();
         return test;
     }
    
     //这也不是一个泛型方法,这就是一个普通的方法,只是使用了Genericity<Number>这个泛型类做形参而已。
     public void showKeyValue1(Genericity<Number> obj){
         
     }
    
     //这也不是一个泛型方法,这也是一个普通的方法,只不过使用了泛型通配符?
     //同时这也印证了泛型通配符章节所描述的,?是一种类型实参,可以看做为Number等所有类的父类
     public void showKeyValue2(Genericity<?> obj){
        
     }
    
    
     /**
      * 这个方法也是有问题的,编译器会为我们提示错误信息:"UnKnown class 'T' "
      * 对于编译器来说T这个类型并未项目中声明过,因此编译也不知道该如何编译这个类。
      * 所以这也不是一个正确的泛型方法声明。
      */
     public void showkey(E genericObj){
    
     }
    	
    

    一个真正的泛型方法。

    • 首先在public与返回值之间的必不可少,这表明这是一个泛型方法,并且声明了一个泛型T
    • 这个T可以出现在这个泛型方法的任意位置.
    • 泛型的数量也可以为任意多个
      泛型方法的使用:
    public <E> E getObject(Class<E> c) throws InstantiationException, IllegalAccessException{
     		E e = c.newInstance();
     		return e;
     	}
    
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
    		Genericity g = new Genericity();
    		Object obj=g.getObject(Class.forName("Genercity"));	
    	}
    

    这样我们就可以通过传入不同的类型来通过泛型方法获取不同类型的Object,而不用去每次都将该类型new出来。

    关于泛型的上下界问题----super 和 extends,欢迎参考下列博客
    泛型的上下界问题-------super和extends

    觉得不错的话点赞加关注,再看不迷路,觉得不好的话评论加回复,一起来进步!!!

    更多相关内容
  • 下面小编就为大家带来一篇浅谈java中定义泛型类和定义泛型方法的写法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 目录标题泛型引入1. 泛型类特点2. 最简单泛型类3. 泛型方法4. 泛型接口5. 泛型类可是同时设置多个类型参数6. 泛型的类型参数可以是泛型类7...这样就解决了多个相似的方法、接口 )创建的问题,一个泛型类即可代替所

    泛型引入

    如果我们需要产生多个对象,每个对象的逻辑完全一样,只是对象内的成员变量的类型不同,那我们如何去做?
    此时,我们就引入了泛型。

    泛型:让数据类型变得参数化。定义泛型时,对应的数据类型是不确定的。泛型方法被调用时,才指定具体类型
    这样就解决了多个相似的类(方法、接口 )创建的问题,一个泛型类即可代替所有相关类(方法、接口),提高代码的重用性

    1. 泛型类特点

    • 泛型的类型参数可以是泛型类
    • 泛型类可是同时设置多个类型参数
    • 泛型类可以继承泛型类
    • 泛型类可以实现泛型接口

    2. 最简单泛型类

    泛型类:
    在这里插入图片描述
    调用泛型类时才指定具体类型:
    在这里插入图片描述

    3. 泛型方法

    3.1 定义泛型方法

    • 定义格式:
    访问修饰符 <泛型列表> 返回类型 方法名(参数列表) {
    		实现代码;
    }
    
    • 在泛型列表中声明的泛型,可用于该方法的返回类型声明、参数类型声明和方法代码中的局部变量的类型声明
    • 类中的其他方法不能使用当前方法声明的泛型

    注意: 是否拥有泛型方法,与其所在的类是否是泛型没有关系,要定义泛型方法,只需将泛型参数列表置于返回值前

    示例:

    package com.demo;
    
    class Parent {
    	//泛型方法
    	public <T> void printInfo(T a) {
    		System.out.println(a);
    	}
    	//重载泛型方法
    	public <T, T2> T2 printInfo(T a, T2 b) {
    		System.out.println(a);
    		System.out.println(b);
    		return b;
    	}
    }
    
    public class Test {
    	public static void main(String[] args) {
    		Parent one = new Parent();
    		one.printInfo("hello");
    		one.printInfo("hello", 10);
    	}
    }
    

    结果:
    在这里插入图片描述

    3.2 使用extends关键字限制泛型类型

    格式:

    访问修饰符 <泛型 extends A> 返回类型 方法名(参数列表) {
    		实现代码;
    }
    

    此时泛型的类型就只能是 A 类或者 A 的子类

    示例:

    package com.demo;
    
    class Parent {
    	void print() {
    		System.out.println("上限为父类");
    	};
    }
    
    class Child extends Parent {
    	//重写方法
    	void print() {
    		System.out.println("下限为子类");
    	}
    }
    
    class User{
    	//泛型方法
    	public <T extends Parent> void printInfo(T t) {
    		t.print();
    	}
    }
    
    public class Test {
    	public static void main(String[] args) {
    		User one = new User();
    		one.printInfo(new Child());
    		one.printInfo(new Parent());
    	}
    }	
    

    结果:
    在这里插入图片描述

    3.3 静态泛型方法

    使用static进行修饰

    示例:

    package com.demo;
    
    class Parent {
    	void print() {
    		System.out.println("上限为父类");
    	};
    }
    
    class Child extends Parent {
    	//重写方法
    	void print() {
    		System.out.println("下限为子类");
    	}
    }
    
    class User{
    	//静态泛型方法
    	public static <T extends Parent> void printInfo(T t) {
    		t.print();
    	}
    }
    
    public class Test {
    	public static void main(String[] args) {
    		User one = new User();
    		//静态泛型方法通过实例化对象去动态调用会出现警告
    		one.printInfo(new Child());	
    		one.printInfo(new Parent());
    		//静态调用则不会出现警告
    		User.printInfo(new Child());
    	}
    }
    

    结果:在这里插入图片描述

    4. 泛型接口

    在这里插入图片描述

    5. 泛型类可是同时设置多个类型参数

    在这里插入图片描述

    6. 泛型的类型参数可以是泛型类

    在这里插入图片描述
    注意:第一个getMessage() 获取的是泛型类,第一个获取的是 getMessage() 获取的才是整数a的值

    7. 泛型类可以继承泛型类

    在这里插入图片描述

    8. 泛型类可以实现泛型接口

    在这里插入图片描述

    展开全文
  • 主要介绍了Java泛型类与泛型方法的定义,结合实例形式详细分析了java泛型类与泛型方法定义、用法及相关操作注意事项,需要的朋友可以参考下
  • Java系列之:泛型类泛型方法泛型接口一、泛型二、泛型类三、泛型方法四、泛型接口五、类型通配符 一、泛型 泛型:本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。将类型由原来的具体的类型参数...

    Java系列之:泛型类、泛型方法、泛型接口

    一、泛型

    • 泛型:本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型。这种参数可以用在类、方法和接口中,分别被称为泛型类、泛型方法、泛型接口。

    泛型定义格式:

    • <类型>:指定一种类型的格式。这里的类型可以看成是形参。
    • <类型1,类型2…>:指定多种类型的格式,多种类型用逗号隔开,这里的类型可以看成是形参。
    • 将来具体调用时候给定的类型可以看成是实参,并且实参的类型只能是引用数据类型。

    泛型的好处:

    • 把运行时期的问题提前到了编译期间
    • 避免了强制类型转换

    二、泛型类

    泛型类的定义格式:

    • 格式:修饰符 class 类名<类型>{}
    • 泛例:public class Generic<T> {}
    • T可以是任意标识
    public class Generic<T>{
        private T t;
    
        public T get(){
            return t;
        }
    
        public void set(T t){
            this.t = t;
        }
    }
    
    
    public class CollectionDemo {
    
        public static void main(String[] args) {
            Generic<String> stu = new Generic<String>();
            stu.set("鸣人");
            System.out.println(stu.get());
    
            Generic<Integer> stu1 = new Generic<Integer>();
            stu1.set(10);
            System.out.println(stu1.get());
        }
    }
    
    

    三、泛型方法

    泛型方法的定义格式:

    • 格式:修饰符 <类型> 返回值类型方法名(类型变量名){}
    • 范例:public <T> void show(T t){}
        public <T> T show(T t){
            return t;
        }
    
        public <T> void show1(T t){
            System.out.println(t);
        }
    

    四、泛型接口

    泛型接口的定义格式:

    • 格式:修饰符 interface 接口名<类型>{}
    • 范例:public interface Generic <T>{}
    
    public interface GenInterface<T> {
        void show(T t);
    }
    
    public class GenImpl<T> implements GenInterface<T>{
        @Override
        public void show(T t) {
            System.out.println(t);
        }
    }
    
    public class CollectionDemo{
    
        public static void main(String[] args) {
            GenImpl<String> str = new GenImpl<String>();
            str.show("加油");
    
            GenImpl<Integer> i = new GenImpl<>();
            i.show(30);
        }
    }
    

    五、类型通配符

    为了表示各种泛型List的父类,可以使用类型通配符:

    • 类型通配符:<?>
    • List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
    • 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中

    如果不希望List<?>是任何泛型的父类,只希望代表某一类泛型List的父类,可以使用类型通配符的上限。

    • 类型通配符上限:<?extends类型>
    • List<? extends Number>:表示的类型是Number或者其子类型

    除了可以指定类型通配符的上限,也可以指定类型通配符的下限:

    • 类型通配符下限:<?super类型>
    • List<?super Number>:表示的类型是Number或者其父类型
    import java.util.ArrayList;
    import java.util.List;
    
    public class CollectionDemo{
    
        public static void main(String[] args) {
            List<?> numbersList = new ArrayList<Number>();
    
            //类型通配符上限
            List<? extends Number> list1 = new ArrayList<Number>();
            List<? extends Number> list2 = new ArrayList<Integer>();
    
            //类型通配符下限
            List<? super Number> list3 = new ArrayList<Number>();
    
        }
    }
    
    展开全文
  • 主要介绍了Java泛型和Class用法,结合实例形式分析了java使用泛型限制class避免强制类型转换相关操作技巧,需要的朋友可以参考下
  • Java 1.5 之前没有泛型,通常需要使用强制类型转换的方式将一种数据类型转换为另一种数据类型,这种...泛型可以在编译的时候检查类型安全,并且所有的强制转换都是自动隐式的,提高了代码的重用率。本节将详...

    Java 1.5 之前没有泛型,通常需要使用强制类型转换的方式将一种数据类型转换为另一种数据类型,这种转换要求开发者对实际参数的类型具有可预知性。对于强制类型转换错误的情况,编译器可能不会提示错误,但是在运行时会出现异常,这是一个安全隐患。

    为了解决这一隐患,从 Java 1.5 开始提供了泛型。泛型可以在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高了代码的重用率。本节将详细介绍 Java 中泛型的使用。

    泛型集合

    泛型本质上是提供类型的“类型参数”,也就是参数化类型。我们可以为类、接口或方法指定一个类型参数,通过这个参数限制操作的数据类型,从而保证类型转换的绝对安全。

    例 1

    下面将结合泛型与集合编写一个案例实现图书信息输出。

    (1) 首先需要创建一个表示图书的实体类 Book,其中包括的图书信息有图书编号、图书名称和价格。Book 类的具体代码如下:

     
    1. public class Book
    2. {
    3. private int Id; //图书编号
    4. private String Name; //图书名称
    5. private int Price; //图书价格
    6. public Book(int id,String name,int price)
    7. { //构造方法
    8. this.Id=id;
    9. this.Name=name;
    10. this.Price=price;
    11. }
    12. public String toString()
    13. { //重写 toString()方法
    14. return this.Id+", "+this.Name+","+this.Price;
    15. }
    16. }


    (2) 使用 Book 作为类型创建 Map 和 List 两个泛型集合,然后向集合中添加图书元素,最后输出集合中的内容。具体代码如下:

     
    1. import java.util.ArrayList;
    2. import java.util.HashMap;
    3. import java.util.List;
    4. import java.util.Map;
    5. public class Test14
    6. {
    7. public static void main(String[] args)
    8. {
    9. //创建3个Book对象
    10. Book book1=new Book(1,"唐诗三百首",8);
    11. Book book2=new Book(2,"小星星",12);
    12. Book book3=new Book(3,"成语大全",22);
    13. Map<Integer,Book> books=new HashMap<Integer,Book>(); //定义泛型 Map 集合
    14. books.put(1001,book1); //将第一个 Book 对象存储到 Map 中
    15. books.put(1002,book2); //将第二个 Book 对象存储到 Map 中
    16. books.put(1003,book3); //将第三个 Book 对象存储到 Map 中
    17. System.out.println("泛型Map存储的图书信息如下:");
    18. for(Integer id:books.keySet())
    19. {
    20. //遍历键
    21. System.out.print(id+"——");
    22. System.out.println(books.get(id)); //不需要类型转换
    23. }
    24. List<Book> bookList=new ArrayList<Book>(); //定义泛型的 List 集合
    25. bookList.add(book1);
    26. bookList.add(book2);
    27. bookList.add(book3);
    28. System.out.println("泛型List存储的图书信息如下:");
    29. for(int i=0;i<bookList.size();i++)
    30. {
    31. System.out.println(bookList.get(i)); //这里不需要类型转换
    32. }
    33. }
    34. }


    在该示例中,代码“Map<Integer,Book> books=new HashMap<Integer,Book>();”创建了一个键类型为 Integer、值类型为 Book 的泛型集合,即指明了该 Map 集合中存放的键必须是 Integer 类型、值必须为 Book 类型,否则编译出错。在获取 Map 集合中的元素时,不需要将"books.get(id);"获取的值强制转换为 Book 类型,程序会隐式转换。在创建 List 集合时,同样使用了泛型,因此在获取集合中的元素时也不需要将“bookList.get(i)”代码强制转换为 Book 类型,程序会隐式转换。

    执行结果如下:

    泛型Map存储的图书信息如下:
    1001——1, 唐诗三百首,8
    1003——3, 成语大全,22
    1002——2, 小星星,12
    泛型List存储的图书信息如下:
    1, 唐诗三百首,8
    2, 小星星,12
    3, 成语大全,22

    泛型类

    除了可以定义泛型集合之外,还可以直接限定泛型类的类型参数。语法格式如下:

    public class class_name<data_type1,data_type2,…>{}

    其中,class_name 表示类的名称,data_ type1 等表示类型参数。Java 泛型支持声明一个以上的类型参数,只需要将类型用逗号隔开即可。

    泛型类一般用于类中的属性类型不确定的情况下。在声明属性时,使用下面的语句:

     
    1. private data_type1 property_name1;
    2. private data_type2 property_name2;

    该语句中的 data_type1 与类声明中的 datajype1 表示的是同一种数据类型。

    例 2

    在实例化泛型类时,需要指明泛型类中的类型参数,并赋予泛型类属性相应类型的值。例如,下面的示例代码创建了一个表示学生的泛型类,该类中包括 3 个属性,分别是姓名、年龄和性别。

     
    1. public class Stu<N,A,S>
    2. {
    3. private N name; //姓名
    4. private A age; //年龄
    5. private S sex; //性别
    6. //创建类的构造函数
    7. public Stu(N name,A age,S sex)
    8. {
    9. this.name=name;
    10. this.age=age;
    11. this.sex=sex;
    12. }
    13. //下面是上面3个属性的setter/getter方法
    14. public N getName()
    15. {
    16. return name;
    17. }
    18. public void setName(N name)
    19. {
    20. this.name=name;
    21. }
    22. public A getAge()
    23. {
    24. return age;
    25. }
    26. public void setAge(A age)
    27. {
    28. this.age = age;
    29. }
    30. public S getSex()
    31. {
    32. return sex;
    33. }
    34. public void setSex(S sex)
    35. {
    36. this.sex=sex;
    37. }
    38. }


    接着创建测试类。在测试类中调用 Stu 类的构造方法实例化 Stu 对象,并给该类中的 3 个属性赋予初始值,最终需要输出学生信息。测试类的代码实现如下:

     
    1. public class Test14
    2. {
    3. public static void main(String[] args)
    4. {
    5. Stu<String,Integer,Character> stu=new Stu<String,Integer,Character>("张晓玲",28,'女');
    6. String name=stu.getName();
    7. Integer age=stu.getAge();
    8. Character sex=stu.getSex();
    9. System.out.println("学生信息如下:");
    10. System.out.println("学生姓名:"+name+",年龄:"+age+",性别:"+sex);
    11. }
    12. }


    该程序的运行结果如下:

    学生信息如下:
    学生姓名:张晓玲,年龄:28,性别:女


    在该程序的 Stu 类中,定义了 3 个类型参数,分别使用 N、A 和 S 来代替,同时实现了这 3 个属性的 setter/getter 方法。在主类中,调用 Stu 类的构造函数创建了 Stu 类的对象,同时指定 3 个类型参数,分别为 String、Integer 和 Character。在获取学生姓名、年龄和性别时,不需要类型转换,程序隐式地将 Object 类型的数据转换为相应的数据类型。

    泛型方法

    到目前为止,我们所使用的泛型都是应用于整个类上。泛型同样可以在类中包含参数化的方法,而方法所在的类可以是泛型类,也可以不是泛型类。也就是说,是否拥有泛型方法,与其所在的类是不是泛型没有关系。

    泛型方法使得该方法能够独立于类而产生变化。如果使用泛型方法可以取代类泛型化,那么就应该只使用泛型方法。另外,对一个 static 的方法而言,无法访问泛型类的类型参数。因此,如果 static 方法需要使用泛型能力,就必须使其成为泛型方法。

    定义泛型方法的语法格式如下:

    [访问权限修饰符][static][final]<类型参数列表>返回值类型方法名([形式参数列表])

    例如:

     
    1. public static List<T> find(Class<T>class,int userId){}


    一般来说编写 Java 泛型方法,其返回值类型至少有一个参数类型应该是泛型,而且类型应该是一致的,如果只有返回值类型或参数类型之一使用了泛型,那么这个泛型方法的使用就被限制了。下面就来定义一个泛型方法,具体介绍泛型方法的创建和使用。

    例 3

    使用泛型方法打印图书信息。定义泛型方法,参数类型使用“T”来代替。在方法的主体中打印出图书信息。代码的实现如下:

     
    1. public class Test16
    2. {
    3. public static<T> void List(T book)
    4. { //定义泛型方法
    5. if(book!=null)
    6. {
    7. System.out.println(book);
    8. }
    9. }
    10. public static void main(String[] args)
    11. {
    12. Book stu=new Book(1,"细学 Java 编程",28);
    13. List(stu); //调用泛型方法
    14. }
    15. }


    该程序中的 Book 类为前面示例中使用到的 Book 类。在该程序中定义了一个名称为 List 的方法,该方法的返回值类型为 void,类型参数使用“T”来代替。在调用该泛型方法时,将一个 Book 对象作为参数传递到该方法中,相当于指明了该泛型方法的参数类型为 Book。

    该程序的运行结果如下:

    1, 细学 Java 编程,28

    泛型的高级用法

    泛型的用法非常灵活,除在集合、类和方法中使用外,本节将从三个方面介绍泛型的高级用法,包括限制泛型可用类型、使用类型通配符、继承泛型类和实现泛型接口。

    1. 限制泛型可用类型

    在 Java 中默认可以使用任何类型来实例化一个泛型类对象。当然也可以对泛型类实例的类型进行限制,语法格式如下:

    class 类名称<T extends anyClass>


    其中,anyClass 指某个接口或类。使用泛型限制后,泛型类的类型必须实现或继承 anyClass 这个接口或类。无论 anyClass 是接口还是类,在进行泛型限制时都必须使用 extends 关键字。

    例如,在下面的示例代码中创建了一个 ListClass 类,并对该类的类型限制为只能是实现 List 接口的类。

     
    1. //限制ListClass的泛型类型必须实现List接口
    2. public class ListClass<T extends List>
    3. {
    4. public static void main(String[] args)
    5. {
    6. //实例化使用ArrayList的泛型类ListClass,正确
    7. ListClass<ArrayList> lc1=new ListClass<ArrayList>();
    8. //实例化使用LinkedList的泛型类LlstClass,正确
    9. ListClass<LinkedList> lc2=new ListClass<LinkedList>();
    10. //实例化使用HashMap的泛型类ListClass,错误,因为HasMap没有实现List接口
    11. //ListClass<HashMap> lc3=new ListClass<HashMap>();
    12. }
    13. }


    在上述代码中,定义 ListClass 类时设置泛型类型必须实现 List 接口。例如,ArrayList 和 LinkedList 都实现了 List 接口,所以可以实例化 ListClass 类。而 HashMap 没有实现 List 接口,所以在实例化 ListClass 类时会报错。

    当没有使用 extends 关键字限制泛型类型时,其实是默认使用 Object 类作为泛型类型。因此,Object 类下的所有子类都可以实例化泛型类对象,如图 1 所示的这两种情况。
     


    图1 两个等价的泛型类

    2. 使用类型通配符

    Java 中的泛型还支持使用类型通配符,它的作用是在创建一个泛型类对象时限制这个泛型类的类型必须实现或继承某个接口或类。

    使用泛型类型通配符的语法格式如下:

    泛型类名称<? extends List>a=null;

    其中,“<? extends List>”作为一个整体表示类型未知,当需要使用泛型对象时,可以单独实例化。

    例如,下面的示例代码演示了类型通配符的使用。

     
    1. A<? extends List>a=null;
    2. a=new A<ArrayList> (); //正确
    3. b=new A<LinkedList> (); //正确
    4. c=new A<HashMap> (); //错误

    在上述代码中,同样由于 HashMap 类没有实现 List 接口,所以在编译时会报错。

    3. 继承泛型类和实现泛型接口

    定义为泛型的类和接口也可以被继承和实现。例如下面的示例代码演示了如何继承泛型类。

     
    1. public class FatherClass<T1>{}
    2. public class SonClass<T1,T2,T3> extents FatherClass<T1>{}


    如果要在 SonClass 类继承 FatherClass 类时保留父类的泛型类型,需要在继承时指定,否则直接使用 extends FatherClass 语句进行继承操作,此时 T1、T2 和 T3 都会自动变为 Object,所以一般情况下都将父类的泛型类型保留。

    下面的示例代码演示了如何在泛型中实现接口。

     
    1. interface interface1<T1>{}
    2. interface SubClass<T1,T2,T3> implements
    3. Interface1<T2>{}
    展开全文
  • Java 泛型 一、概述 Java 泛型(generics)是 JDK 1.5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许开发者在编译时检测到非法的类型。 1.1 什么是泛型泛型,即参数化类型。 一提到参数,...
  • 1泛型的类型参数只能是类型包括自定义不能是简单类型 2同一种泛型可以对应多个版本因为参数类型是不确定的不同版本的泛型类实例是不兼容的 3泛型的类型参数可以有多个 4泛型的参数类型可以使用extends语句例如...
  • Java泛型 与 C++ 模板 : Java 中的泛型 , 是仿照 C++ 中的模板开发的 , 目的是让开发者可以写出通用,灵活的代码 。 伪泛型 : Java中的泛型 , 是伪泛型 , Java 泛型开发好之后 , 在编译阶段就将泛型相关的信息消除了 ...
  • JAVA容器之泛型类泛型方法
  • 如果被方法是用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同的方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。泛型类class Demo{public void show...
  • 下面小编就为大家带来一篇详谈Java泛型中T问号(通配符)的区别。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 一、泛型类用法、 二、泛型方法用法、 三、泛型通配符 、 四、泛型安全检查、
  • 主要介绍了Java泛型的继承实现操作,结合实例形式分析了java泛型类的继承以及泛型接口的实现相关操作技巧,需要的朋友可以参考下
  • 原文链接:https://blog.csdn.net/qq_27093465/article/details/73229016
  • Java泛型的定义使用详解

    千次阅读 2021-06-29 18:24:14
    一,为什么我们需要泛型 通过分析下面两种情况,来得出我们为什么需要泛型。 1.对两个数值类型求和的情况,如下代码,当两个数值是int类型时,需要实现一个方法对int类型的数值求和。当两个数值是Float类型时,...
  • 下面小编就为大家带来一篇浅谈Java泛型让声明方法返回子类型的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 一、泛型类 一个泛型类(generic class)就是具有一个或者多个类型变量的,类型变量用尖括号(<>)括起来,并放在类名的后面。泛型类可以有多个类型变量。类型变量使用大写形式,而且比较短。在Java类库中...
  • 主要介绍了Java泛型实例化的方法,文中示例代码非常详细,帮助大家更好的理解学习,感兴趣的朋友可以了解下
  • JAVA泛型 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。 泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数 你定义了一个泛型(、接口),那么Java规定,你不...
  • 主要介绍了Java泛型<T> T与T的使用方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java定义泛型接口和类方法,结合实例形式分析了泛型相关概念、原理及泛型接口与的定义实现方法,需要的朋友可以参考下
  • 主要介绍了Java泛型的用法及T.class的获取过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了不同Java泛型构造函数的详解,因为对象是应用类型,对象赋值是指向同一个对象,所以如果需要保存对象某个时刻的状态,就需要构造函数来new一个新的对象。下面我们来详细了解一下吧
  • JAVA泛型是jdk1.5引入的一个新特性,本质是参数化类型,把类型作为参数传递 常见的有:泛型、泛型接口、泛型方法 语法:<T,...>T表示类型占位符,表示一种应用类型 好处1、提高代码重用。2、防止类型转换...
  • java泛型总结

    2019-04-09 17:19:51
    深入理解java泛型,包括类名泛型的定义,方法泛型定义,泛型的返回
  • 1. 概述 泛型,即参数化类型。一提到参数,最熟悉的就是定义方法是...也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在、接口和方法中,分别被称为泛型类泛型接口、泛型方法。 2.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 302,551
精华内容 121,020
关键字:

java泛型类和泛型方法