泛型的定义与使用
泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。 将数据类型作为参数进行传递。
定义和使用含有泛型的类
定义格式:
修饰符 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){}
}
}