Java泛型详解

1. 引言

一般的类和方法,只能使用具体的类型(基本类型或者自定义的类)。这种情况下要编写可以应用多种类型的代码就有很大的束缚。多态也算是一种泛化机制,将方法的形参设为某个父类,那么继承该父类的任意子类都可以作为参数传入该方法。如果方法的形参是一个接口,任何实现该接口的类都可以满足该方法。有时候即是使用接口对程序的约束性还是太强了,我们需要编写更加通用的代码,使代码能应用于“某种不具体的类型”。

2. 为什么需要泛型?

Java在没有泛型之前,泛型程序设计是通过继承来实现的。ArrayList类只维护一个Object引用的数组:

public class ArrayList { //没有泛型之前
	private Object[] elementData;
	public Object get(int i) {......};
	public Object add(Object obj){......};
}

public class GenericTest {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Generic");
        list.add("Wolffy");
        list.add(new Person());
        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 1
            System.out.println("name:" + name);
        }
    }
}

在这里插入图片描述

  • 定义了一个List类型的集合,先向其中加入了两个字符串类型的值,随后加入一个Person类型的对象。这是完全允许的,因为此时list默认的类型为Object类型。但是以上代码存在两个问题:
    • 获取一个值时必须进行强制类型转换:将一个对象放入集合中,集合不会记住此对象的类型,当再次从集合中取出此对象时,该对象的编译类型变成了Object类型,但其运行时类型任然为其本身类型。
    • 没有错误检查:由于不小心加入了其他类型的值或其他编码原因,使用强制类型装换很容易出现类似于//1中的错误。因为编译阶段正常,而运行时会出现“java.lang.ClassCastException”异常。因此,导致此类错误编码过程中不易发现。
  • 为了解决以上存在的问题(在编译阶段就可以解决),泛型应运而生,它提供一种更好的解决方案:类型参数

3. 什么是泛型?

  • 泛型的意思是:“适用于许多的类型”,它实现了“参数化类型”的概念。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。
  • 泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。
List<String> list = new ArrayList<String>();
list.add("Wolffy");
list.add(new Person());//1、在编译阶段,编译器就会报错
for (int i = 0; i < list.size(); i++) {
	String name = list.get(i); // 2、不需要强制类型转换
    System.out.println("name:" + name);

在这里插入图片描述

  • 我们可以看到,使用泛型之后,在//1处加入一个其他类型的对象时会出现编译错误,通过List<String>直接限定了list集合中只能含有String类型的元素,从而在//2处无须进行强制类型转换,因为此时集合能够记住元素的类型信息,编译器已经能够确认它是String类型了。

注意:泛型只在编译阶段有效。泛型类型在逻辑上可以看成是多个不同的类型,实际上都是相同的基本类型

4. 泛型的使用

  • 泛型有三种使用方式,分别为:泛型类、泛型接口、泛型方法
  • 泛型的类型参数必须是类,不能是基本数据类型。需要用到基本数据类型的位置,拿包装类替换。如果实例化时,没指明泛型的类型,默认类型为Object类型。

4.1 泛型类

  • 泛型类型用于类的定义中,即有一个或者多个类型变量的类,被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类,如:List、Set、Map。

一个简单的泛型类:

//T为变量类型,在实例化泛型类时,必须指定T的具体类型
public class Pair<T>{   
    private T first;
    private T second;
    
    public Pair(){//构造器
    };
    public Pair(T first, T second) {
		this.fist = fist;
		this.second = second;
	}
	
    public T getFisrt(){
        return first;
    }
    ......
    public T getSecond(T newValue) {
		first = newValue;
	}
}
  • Java中使用T来表示任意类型,E来表示集合中的元素,K和V分别表示键和值的类型。
  • 泛型类可以有多个类型参数

注意:①泛型的类型参数只能是类类型,不能是基本属性类型;②不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的,编译时会出错。if(ex_num instanceof Generic<Number>){ }

4.2 泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生成器(专门负责创建对象的类)中,一个生成器一般只定义一个next方法,用于产生新的对象。可以看一个例子:

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

当实现泛型接口的类,未传入泛型实参时:

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

当实现泛型接口的类,传入泛型实参时:

/**
 * 传入泛型实参时:
 * 定义一个生成器实现这个接口,虽然只创建了一个泛型接口Generator<T>
 * 但是可以为T传入无数个实参,形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时,如已将泛型类型传入实参类型,则所有使用泛型的地方都要替换成传入的实参类型
 * 即:Generator<T>,public T next();中的的T都要替换成传入 的String类型。
 */
public class Generator implements Generator<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

4.3 泛型方法

上面介绍了泛型类,还可以定义带有参数类型的方法,即泛型方法。定义泛型方法,只需要将泛型参数列表置于方法返回值之前,就像下面:

/**
 *    1)泛型参数<T> 可以理解为声明此方法为泛型方法
 *    2)只有声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
 * 	  3)泛型的数量也可以为任意多个
 */
public class GenericMethods { 
	public <T> void f(T x) {
		System.out.println(x.getClass.getName());
	}
	
	public static void main(sring[] args) {
		GenericMethods gm = new GenericMethods();
		gm.f("");//java.lang.String
		gm.f(1);//java.lang.Integer
		gm.f(1.0);//java.lang.Double
		gm.f('a');//java.lang.Character
		gm.f(gm);//GenericMethods
	}
}
  • 使用泛型类时必须在创建对象时指定类型参数的值,而使用泛型方法时通常不必指明类型参数 。因为编译器会我们找出具体的类型,可以向调用普通方法一样调用泛型方法。
  • 泛型方法使得方法能独立于类而产生变化,无论何时,如果你能做到,你就该尽量使用泛型方法。也就是说,如果使用泛型方法可以取代将整个类泛型化,那么就应该使用泛型方法.

4.3.1 泛型方法与可变参数

泛型方法与可变参数列表能够很好的共存:

public class GenericTest {
	//使用可变参数的泛型方法
    public static <T> void printMsg(T... args) {
        for (T t :args) {
            System.out.print(t + " ");
        }
    }

    public static void main(String[] args) {
        GenericTest.printMsg("111", 222, 'A', 100.000);
    }
}

4.3.2 静态方法与泛型

静态方法有一种情况需要注意一下,那就是在类中的静态方法使用泛型:静态方法不能使用泛型类的类型参数;如果静态方法要使用泛型的话,必须将静态方法也定义成泛型方法 。

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

    }
}

4.3.3 泛型方法总结

  • 泛型方法可以在普通类中定义,也可以在泛型类中定义
  • 无论何时,如果你能做到,你就该尽量使用泛型方法。也就是说,如果使用泛型方法可以取代将整个类泛型化,那么就应该使用泛型方法.
  • static修饰的方法无法访问泛型类的类型参数。所以如果static方法需要使用泛型能力,就必须使其成为泛型方法。
  • 在泛型方法中出现了泛型的结构,泛型参数与类的泛型参数没任何关系。即泛型方法所属的类是不是泛型类都没关系。

4.4 泛型注意点

在这里插入图片描述

4.5 类型通配符

  • 泛型在继承方面的体现:类A是类B的父类,但是G <A>G<B>二者不具备子父类关系,二者是并列关系【补充:类A是类B的父类,A<G>B<G> 的父类】。因此需要一个在逻辑上可以用来表示同时是G <A>G<B>的父类的一个引用类型,由此,类型通配符应运而生。
  • 类型通配符一般是使用 ? 代替具体的类型实参G <A>G<B>二者的共同父类是G<?>
@Test
    public void test(){
    	List<Object> list1 = null;
      	List<String> list2 = null;
      	List<?> list = null;
	
     	list = list1;
     	list = list2;
      	//编译通过
		// print(list1);
		// print(list2);
      
      List<String> list3 = new ArrayList<>();
      list3.add("AA");
      list3.add("BB");
      list3.add("CC");
      list = list3;
      //添加(写入):对于List<?>就不能向其内部添加数据。(除了添加null之外)
	// list.add("DD");错误
	// list.add('?');错误
      list.add(null);

      //获取(读取):允许读取数据,读取的数据类型为Object。
      Object o = list.get(0);
      System.out.println(o);
    }

    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
  • 涉及通配符的集合的数据的写入和读取:
    • 添加(写入):对于List<?>不能向其内部添加数据。(除了添加null之外)
    • 获取(读取):允许读取数据,读取的数据类型为Object。

有限制的通配符

  • 类型通配符下限 :? extends A
    • G<? extends A> 可以作为G<A>G<B>的父类,其中B是A的子类
  • 类型通配符上限:? super A
    • G<? super A> 可以作为G<A>G<B>的父类,其中B是A的父类

类比数学中的区间:
?相当于(-∞,+∞);? extends A——(-∞,A];? super A——[A,+∞)

 */
    @Test
    public void test2(){
        List<? extends Person> list1 = null;
        List<? super Person> list2 = null;

        List<Student> list3 = new ArrayList<>();
        List<Person> list4 = new ArrayList<>();
        List<Object> list5 = new ArrayList<>();

        list1 = list3;
        list1 = list4;
//      list1 = list5;编译错误

//      list2 = list3;编译错误
        list2 = list4;
        list2 = list5;

        //读取数据:
        list1 = list3;
        Person p = list1.get(0);
        //Student s = list1.get(0);//编译不通过

        list2 = list4;
        Object obj = list2.get(0);
		//Person obj = list2.get(0);//编译不通过

        //写入数据:
		//list1.add(new Student()); //编译不通过
        //编译通过
        list2.add(new Person());
        list2.add(new Student());
    }	 
  • 3
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值