前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >【java筑基】吃透泛型(一万字长文,建议收藏)

【java筑基】吃透泛型(一万字长文,建议收藏)

作者头像
用户10127530
发布2022-10-26 18:41:28
3840
发布2022-10-26 18:41:28
举报
文章被收录于专栏:半旧的技术栈半旧的技术栈

前 言 🍉 作者简介:半旧518,长跑型选手,立志坚持写10年博客,专注于java后端 ☕专栏简介:深入、全面、系统的介绍java的基础知识 🌰 文章简介:本文将深入全面介绍泛型知识,建议收藏备用,创作不易,敬请三连哦 🍎大厂真题:大厂面试真题大全

文章目录

一、泛型介绍

1 泛型入门

集合元素过去默认为Object类型,无法指定元素类型,编译时不检查类型,而且每次取出对象都要进行强制类型转换,泛型出现避免了这种臃肿的代码。下列代码会看到编译时不检查元素类型导致的异常。

代码语言:javascript
复制
    public class ListErr {
    	public static void main(String[] args) {
    		List strList = new ArrayList();
    		strList.add("人有悲欢离合");
    		strList.add("月有阴晴圆缺");
    		strList.add(23333);
    		//ClassCastException
    		strList.forEach(str -> System.out.println(((String) str).length()));
    	}
    }

泛型用于指定集合存储数据的类型。

代码语言:javascript
复制
    List<String> books=new ArrayList<String>();

上述代码定义集合时使用泛型,创建对象时构造器也给出泛型类型,这样显然是多余的。java7做了改进。

代码语言:javascript
复制
List<String> books=new ArrayList<>();

2 深入泛型

2.1定义泛型接口、类

我们可以在定义一个类时允许它使用泛型,通过阅读java提供的集合接口源码可以知道如何定义泛型接口。

代码语言:javascript
复制
    //定义接口时指定了一个类型形参E
    public interface List<E> extends Collection<E> {
        //在接口中将形参E作为类型使用
           boolean add(E e);
       	   Iterator<E> itorator;
       // ...
    }

在实际使用时,只需要在声明对象时传入E的实参即可 。

2.2 从泛型类派生子类

从泛型类派生子类时,我们可以为泛型指定实参,也可以不使用,注意不要再使用形参T。

代码语言:javascript
复制
    public class Apple<T> {
    	private T info;
    	public T getInfo(){
    		return this.info;
    	}
    }
代码语言:javascript
复制
    public class SmallApple extends Apple<String> {
    	private String info;
    	public String getInfo() {
    		return this.info;
    	}
    }

2.3 并不存在泛型类

实际上,泛型只是设计来用于方便编程,并不会由于指定类型不同而生成不同的class文件。

代码语言:javascript
复制
    public class GenericTest {
    	public static void main(String[] args) {
    		List<String> strList = new ArrayList<>();
    		List<Integer> intList = new ArrayList<>();
    		// true
    		System.out.println(strList.getClass() == intList.getClass());
    	}
    }

也就是说,不管传入实参是不是一个类型,它们仍然被当成一个类型的数据,不允许在静态成员中使用泛型形参。

二、通配符

如果在使用时泛型类时不传入泛型实参会出现警告,但是如果我们并不能确定其类型如何处理?第一种想法是传入Object类型的实参,但是实际上这种办法是行不通的。

代码语言:javascript
复制
    public class Test {
    	public void listTest(List<Object> c){
    		for(int i=0;i<c.size();i++){
    			System.out.println(c.get(i));
    		}
    	}
    	public static void main(String[] args) {
    		List<String> strList=new ArrayList<>();
    		//编译不能通过,The method testList(List<String>) is undefined for the type Test
    		//testList(strList);
    	}
    }

这是因为Java中List并不是List的子类,指定类型为Object传入参数类型只能是Object。

为了解决这个需求,可以使用类型通配符。

代码语言:javascript
复制
    public void listTest(List<?> c){
    	for(int i=0;i<c.size();i++){
    		System.out.println(c.get(i));
    	}
    }

List<?>表明他是任何泛型List的父类,现在任何的List类型都可以调用listTest()方法。上面的代码解决了不指定类型抛出警告的问题,在有的时候却会使代码臃肿:使用了泛型还要进行强制类型转换。我们也可以设定通配符上限,只代表某一类泛型的父类。

代码语言:javascript
复制
    public abstract class shape {
    	public abstract void draw(Canvas c);
    }
代码语言:javascript
复制
    public class Circle extends Shape {
        @Override
    	public void draw(Canvas c) {
    		System.out.println("在画布" + c + "上画个圈圈");
    	}
    }
代码语言:javascript
复制
    public class Retangle extends Shape {
    	@Override
    	public void draw(Canvas c) {
    		System.out.println("在画布" + c + "上画个块块");
    
    	}
    }
代码语言:javascript
复制
    public class Canvas {
    	public void drawAll(List<? extends Shape> shapes) {
    		for (Shape s : shapes) {
    			s.draw(this);
    		}
    	}
    }

在并不知道受限制的通配符的具体类型时,不可以将Shape及其子类对象加入这个泛型集合中。

代码语言:javascript
复制
    public void addRetangle(List<? extends Shape> shapes){
    //		shapes.add(0, new Retangle());
    }

三、泛型类与泛型方法

1.泛型类

不仅使用通配符时可以设置形参上限,定义类型形参时也可以设置类型上限。

代码语言:javascript
复制
    public class Apple<T extends Number> {
    	private T info;
    	public static void main(String[] args) {
    		Apple<Integer> intApple=new Apple<>();
    		//编译不通过,Bound mismatch
    		//Apple<String> strApple=new Apple<>();
    	}
    }

而且Java可以在定义形参时设置一个父类上限,多个接口上限。下列代码要求T类型必须是Number类的子类,而且必须实现了java.io.Seriazable接口。

代码语言:javascript
复制
    public class Apple<T extends Number & java.io.Serializable> {...}

2.泛型方法

可以单独为方法指定泛型形参。在该方法内部可以把指定的泛型形参当成正常类型使用。

代码语言:javascript
复制
    public class GenericMethodTest {
    	static <T> void fromArrayToCollections(T[] a,Collection<T> c){
    		for(T o: a){
    			c.add(o);
    		}
    	}
代码语言:javascript
复制
 	public static void main(String[] args) {
 		Object [] oa=new Object[100];
 		Collection<Object> co=new ArrayList<>();
 		//下列T代表Object类型
 		fromArrayToCollections(oa, co);
 		
 		String [] sa=new String[100];
 		Collection<String> cs=new ArrayList<>();
 		//下列T代表String类型
 		fromArrayToCollections(sa, cs);
 		//下列T代表Object类型
 		fromArrayToCollections(sa, co);
 		
 		Number [] na=new Number[100];
 		//The method fromArrayToCollections(T[], Collection<T>) 
 		//in the type GenericMethodTest is not applicable for 
 		//the arguments (Number[], Collection<String>)
 		//fromArrayToCollections(na, cs);
 	}
 }

四、泛型方法的自动类型推断

编译器会根据泛型方法传入的实参自动推断形参的值,通常会推断出最直接的类型参数。 ​ 为了让编译器可以推断出泛型类型,不要让编译器迷惑,否则就会出错。 ​

代码语言:javascript
复制
public class ErrorTest {
    static <T> void test(Collection<T> from,Collection<T> to) {
        for (T ele : from){
            to.add(ele);
        }
    }
    
    public static void main(String[] args) {
        List<String> as = new ArrayList<>();
        List<Object> ao = new ArrayList<>();
        //The method test(Collection<T>, Collection<T>) 
        //in the type ErrorTest is not applicable for 
        //the arguments (List<Object>, List<String>)
        //test(as, ao);
    }
}

​ 可以进行如下修改,避免编译失败。 ​

代码语言:javascript
复制
public class ErrorTest {
    static <T> void test(Collection<? extends T> from,Collection<T> to) {
        for (T ele : from){
            to.add(ele);
        }
    }
    
    public static void main(String[] args) {
        List<String> ao = new ArrayList<>();
        List<Object> as = new ArrayList<>();
        test(ao, as);
    }
}

五、泛型通配符与泛型方法区别

什么时候使用泛型方法,什么时候使用类型通配符呢?一般能够使用通配符,都可以改写为泛型方法。

代码语言:javascript
复制
    public interface Collection<E> extends Iterable<E> {
    	boolean containsAll(Collection<?> c);
    	boolean addAll(Collection<? extends E> c);
    }

    public interface Collection<E> extends Iterable<E> {
    	<T> boolean containsAll(Collection<T> c);
    	<T extends E> boolean addAll(Collection<T> c);
    }

这两个方法的类型形参T其实都只使用了一次,唯一效果就是在调用时传入实际类型参数,因此Collection接口设计时采用的时上示第一种:类型通配符,类型通配符就是被设计来支持灵活子类化的。

泛型方法用来表示方法一个或者多个参数之间的依赖关系,或者参数与返回值的关系,如果没有这种依赖关系,就不要使用泛型方法。

有时候会同时使用泛型通配符和泛型方法。比如Collctions.copy()方法。dest和src的参数之间存在依赖关系:src的集合元素必须是dest类型或其子类,故用泛型方法表示dest的类型,而该方法无需向src中添加修改元素,也没有其它参数src的类型,因此使用通配符更合适。

代码语言:javascript
复制
     public static <T> void copy(List<? super T> dest, List<? extends T> src) {...}

六、泛型构造器、设置通配符下限

1.泛型构造器

java中也支持泛型构造器。在泛型类中允许使用菱形语法,但不允许在显示声明构造器泛型类型的情况下使用菱形语法。

代码语言:javascript
复制
    class Foo <E>{
    	public <T> Foo(T t) {
    		System.out.println(t);
    	}
    }
    
    public class GeneratorConstructor {
    	public static void main(String[] args) {
    		new Foo("人不轻狂枉少年");
    		new <Integer> Foo(20);
    		//使用菱形语法,E传入实参为String类型,E泛型构造器中T参数传入实参为Integer
    		Foo <String> foo=new Foo<>(5);
    		//E传入实参为String类型,显示声明构造器中的方法T传入实参为Integer
    		Foo <String> foo2=new <Integer> Foo <String>(5); 
    		//编译错误
    		//Explicit type arguments cannot be used with '<>' in an allocation expression
    		//Foo <String> foo3=new <Integer> Foo <>(5);
    	}
    }

2.设置通配符下限

考虑场景:在copy方法中吧集合src中的元素复制到dest集合中,同时要求返回最后一个添加的元素。如果我们采用设置通配符上限的方法,那么返回最后一个添加的元素时,将返回一个丢失实际类型的参数。

代码语言:javascript
复制
    public class MyUtils_1 {
    	public static <T> T copy(Collection<T> dest,
    			Collection<? extends T> src){
    		T last = null;
    		for(T ele : src){
    			last = ele;
    			dest.add(ele);
    		}
    		//返回的类型为T,但last元素实际上可能是T的子类
    		return last;
    	}
    }

Java中设计了类型通配符下限解决这一需求。

代码语言:javascript
复制
    public class MyUtils {
    	//下面dest集合元素的类型必须与src元素的类型相同,或是其父类
    	public static <T> T copy(Collection<? super T> dest,
    			Collection<T> src){
    		T last = null;
    		for(T ele : src){
    			last = ele;
    			dest.add(ele);
    		}
    		return last;
    	}
    }

七、java8改进的泛型参数推断机制

java8增强了泛型方法的类型推断能力:允许通过调用方法的上下文推断类型参数的目标类型,允许在方法调用链中将推断到的泛型参数传递至最后一个方法。

代码语言:javascript
复制
    class MyUtil<E>{
    	public static <Z> MyUtil<Z> nil(){
    		return null;
    	}
    	public static <Z> MyUtil<Z> cons(Z head,MyUtil<Z> tail){
    		return null;
    	}
    	E head(){
    		return null;
    	}
    } 
    public class InferenceTest {
    	public static void main(String[] args) {
    		//通过方法赋值的目标参数来推断类型参数为String
    		MyUtil<String> ls=MyUtil.nil();
    		//通过cons()方法所以需要的参数类型来推断类型参数的类型为Integer
    		MyUtil.cons(42, MyUtil.nil());
    	}
    }

八 泛型擦除与转换

当把一个带有泛型信息的变量赋值给一个不带泛型信息的变量时,泛型信息将被擦除,对元素的类型参数检查将变成类型的上限。

代码语言:javascript
复制
    class Apple<T extends Number>{
    	T size;
    	public Apple(){
    		
    	}
    	public T getSize() {
    		return size;
    	}
    	public void setSize(T size) {
    		this.size = size;
    	}
    	
    }
    public class ErasureTest {
    	public static void main(String[] args) {
    		Apple<Integer> ap=new Apple<>();
    		Integer apSize=ap.getSize();
    		Apple ap2=ap;
    		//Type mismatch: cannot convert from Number to Integer
    		//Integer apSize2=ap2.getSize();
    	}
    }

理论上,List是List的子类,把List对象直接赋给List应该出现编译错误,但实际上不会。

代码语言:javascript
复制
    public class ErasureTest2 {
    	public static void main(String[] args) {
    		List<Integer> li = new ArrayList<>();
    		li.add(1);
    		// 泛型擦除
    		List list = li;
    		System.out.println(li.get(0));
    		// 警告:The expression of type List needs unchecked conversion to conform
    		// to
    		List<String> ls = list;
    		// Exception :java.lang.Integer cannot be cast to java.lang.String
    		System.out.println(ls.get(0));
    	}
    }

这篇文章就介绍到这里了。

“工欲善其事,必先利其器”。要想成为工作上的高手,面试时的题霸,独步江湖,就必须拿到一份"武林秘籍"。

在这里插入图片描述
在这里插入图片描述

我个人强推牛客网:找工作神器|大厂java面经汇总|超全笔试题库

推荐理由: 1.刷题题库,题目特别全面,刷爆笔试再也不担心

在这里插入图片描述
在这里插入图片描述

链接: 找工作神器|大厂java面经汇总|超全笔试题库 2.超全面试题、成体系、高质量,还有AI模拟面试黑科技

在这里插入图片描述
在这里插入图片描述

链接: 工作神器|大厂java面经汇总|超全笔试题库 3.超多面经,大厂面经很多

在这里插入图片描述
在这里插入图片描述

4.内推机会,大厂招聘特别多

在这里插入图片描述
在这里插入图片描述

链接: 找工作神器|大厂java面经汇总|超全笔试题库 5.大厂真题,直接拿到大厂真实题库,而且和许多大厂都有直接合作,题目通过率高有机会获得大厂内推资格。

在这里插入图片描述
在这里插入图片描述

链接: 找工作神器|大厂java面经汇总|超全笔试题库

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2022-07-15,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 文章目录
  • 一、泛型介绍
    • 1 泛型入门
      • 2 深入泛型
        • 2.1定义泛型接口、类
        • 2.2 从泛型类派生子类
        • 2.3 并不存在泛型类
    • 二、通配符
    • 三、泛型类与泛型方法
      • 1.泛型类
        • 2.泛型方法
        • 四、泛型方法的自动类型推断
        • 五、泛型通配符与泛型方法区别
        • 六、泛型构造器、设置通配符下限
          • 1.泛型构造器
            • 2.设置通配符下限
            • 七、java8改进的泛型参数推断机制
            • 八 泛型擦除与转换
            领券
            问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档