一文入门Java之【泛型】

一、什么是泛型

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时。
例如：继承或实现这个接口，用这个类型声明变量、创建对象时确定（即传入实际的类型参数，也称为类型实参）。
Collection< E >，List< E >，ArrayList< E > 这个< E >就是类型参数，即泛型。

二、为什么要使用泛型

使用ArrayList保存数据，由于可以存入Object类型的数据，若存入多种类型的数据会，取出数据时容易出现ClassCastException。

ArrayList不指定泛型

@Test
    public void test1(){
        ArrayList list = new ArrayList();
        // 存数据
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        //意外存入其他类型数据,取出数据会出现ClassCastException
//        list.add("aaa");
        // 取数据,需要进行强制类型转换,有几率出现ClassCastException
        for (Object o : list){
            int num = (Integer)o;
            System.out.println(num);
        }
    }

存入多种类型的数据运行结果

三、怎样使用泛型

先解决上述问题
为了解决可以存入Object，使用泛型可以规定存入数据的类型，有效的规避了由于存入各式各样的数据类型导致取出数据时需要的强制类型转换，容易出现ClassCastException的问题。

1. 集合使用泛型

ArrayList使用泛型

若指定泛型，则不能存入非泛型指定类型的数据。

    @Test
    public void test2(){
        ArrayList<Integer> list = new ArrayList<Integer>();
        // 存数据
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        //意外存入其他类型数据,则编译报错
//        list.add("aaa");
        // 取数据无需要进行强制类型转换
        for (int o : list){
            System.out.println(o);
        }
    }

Map使用泛型

@Test
    public void test3() {
        //jdk7新特性：类型推断
        Map<String, Integer> map = new HashMap<>();
        //存入数据
        map.put("a", 97);
        map.put("b", 98);
        map.put("c", 99);

        //泛型可嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        //取出数据
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> next = iterator.next();
            String key = next.getKey();
            Integer value = next.getValue();
            System.out.println(key + " = " + value);
        }
    }

2. 自定义泛型类、泛型接口、泛型方法

使用泛型可以有效的实际模板

例如SSM框架中的dao层与service层

dao层模板 - 泛型接口

BaseDao<T>

package com.aaa.generic.dao;

import java.util.List;

public interface BaseDao<T>
{
	void add(T entity);
	void upd(T entity);
	void del(T entity);
	T findOne(T entity);
	List<T> find();
	//泛型方法
	<E> E getValue();
}

service层模板 - 泛型类

BaseService<T>

package com.aaa.generic.service;

import com.aaa.generic.dao.BaseDao;

import java.util.List;

/**
 * 模板模式
 * @param <T>
 */
public abstract class BaseService<T>
{
	public abstract BaseDao<T> getDao();
	public void add(T entity)
	{
		getDao().add(entity);
	}
	public void upd(T entity)
	{
		getDao().upd(entity);
	}
	public void del(T entity)
	{
		getDao().del(entity);
	}
	public T findOne(T entity)
	{
		return getDao().findOne(entity);
	}
	public List<T> find()
	{
		return getDao().find();
	}
	public <E> E getValue(){
		return getDao().getValue();
	}
}

dao层实现

ClazzDao

package com.aaa.generic.dao;

import com.aaa.generic.entity.Clazz;
import java.util.List;

public class ClazzDao implements BaseDao<Clazz>
{
	@Override
	public void add(Clazz entity)
	{
		// TODO Auto-generated method stub
	}

	@Override
	public void upd(Clazz entity)
	{
		// TODO Auto-generated method stub
	}

	@Override
	public void del(Clazz entity)
	{
		// TODO Auto-generated method stub
	}

	@Override public Clazz findOne(Clazz entity) {
		return null;
	}

	@Override
	public List<Clazz> find()
	{
		// TODO Auto-generated method stub
		return null;
	}
	@Override public <E> E getValue() {
        return null;
    }
}

service层实现

ClazzService

package com.aaa.generic.service;

import com.aaa.generic.dao.BaseDao;
import com.aaa.generic.dao.ClazzDao;
import com.aaa.generic.entity.Clazz;

public class ClazzService extends BaseService<Clazz>
{
//	@Autowired
	ClazzDao cdao;
	@Override
	public BaseDao<Clazz> getDao()
	{
		return cdao;
	}
}

注意

1. 如果定义了泛型类，实例化没指明类的泛型，则认为此泛型类型为Object类型。
2. 若定义的类是带泛型的，建议在实例化时要指明类的泛型。
3. 子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
4. 泛型类可能有多个参数，多个参数应一起放在<>中，例：<String,Integer>。
5. 泛型类的构造器：public GenericClass(){} ， 无需指定泛型。
6. jdk1.7 泛型可简写：ArrayList<String> list = new ArrayList<>();。
7. 泛型中不能使用基本数据类型(八大数据类型)，使用包装类进行替换。
8. 静态方法中不能使用类的泛型。
9. 异常类不能是泛型。
10. 不能使用new E[] 。可以E[] ele = (E[]) new Object[capacity];
11. 父类有泛型时，子类可指定或保留父类的泛型，也可以增加自己的泛型。

四、通配符：?

1.集合使用通配符的基本使用

注意

1. 对于List<?>就不能向其内部添加数据。可添加null;
2. 读取的数据类型为Object

@Test public void test1() {
        List<Object> list1 = null;
        List<String> list2 = null;
        List<?> list = null;

        list = list1;
        list = list2;

        //编译失败
//        list1 = list;
//        list2 = list;

        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list3.add("CC");
        list = list3;

        //添加(写入)：对于List<?>就不能向其内部添加数据。可添加null;
//        list.add("aaa"); 编译错误
        list.add(null);

        //读取 读取的数据类型为Object
        Object o = list.get(0);
        System.out.println(o);

        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }

2.有限制条件的通配符的使用

? extends A: G<? extends A> 可以作为G< A >和G< B >的父类，其中B是A的子类
? super A:G<? super A> 可以作为G< A >和G< B >的父类，其中B是A的父类

List<? extends Number> list1 = null;
List<? super Number> list2 = null;