泛型的基本概念
泛型: 参数化类型
参数:
- 定义方法时无形参
- 调用办法时传递实参
参数化类型: 将类型由原来的具体的类型参数化,相似办法中的变量参数
- 类型定义成参数模式, 能够称为类型形参
- 在应用或者调用时传入具体的类型,能够称为类型实参
泛型的实质是为了参数化类型
- 在不创立新的类型的状况下,通过泛型指定的不同类型来管制形参具体限度的类型
在泛型应用过程中,操作的数据类型被指定为一个参数,这种参数类型能够用在:
- 类 - 泛型类
- 接口 - 泛型接口
- 办法 - 泛型办法
泛型示例:
List arrayList = new ArrayList();arrayList.add("aaaa");arrayList.add(100); arrayList.forEach(i -> { String item = (String) arrayList.get(i); Log.d("泛型", "item = " + item);});这样的写法会导致程序出现异常解体完结:
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String- 这里的ArrayList能够寄存任意类型,增加了一个String类型,增加了一个Integer类型,再应用时都以String的形式应用,因而程序解体
- 泛型就是解决这样的问题
再探讨另一种状况,如果将第一行申明初始的代码批改一下,那么在编译阶段就能发现问题:
List arrayList = new ArrayList<String>();arrayList.add("aaaa");arrayList.add(100); // 这一步在编译阶段,编译器就会报错 arrayList.forEach(i -> { String item = (String) arrayList.get(i); Log.d("泛型", "item = " + item); });
泛型只在编译阶段无效:
List<String> stringArrayList = new ArrayList<String>();List<Integer> integerArrayList = new ArrayList<Integer>();Class classStringArrayList = stringArrayList.getClass();Class classIntegerArrayList = integerArrayList.getClass();if (classStringArrayList.equals(classIntegerArrayList)) { Log.d("泛型", "类型雷同");}能够发现,在编译过后,程序会采取去泛型化措施.也就是说,Java中的泛型,只在编译阶段无效.在编译过程中,正确测验泛型后果后,会将泛型的相干信息擦除,并且在对象进入和来到办法的边界处增加类型检查和类型转换办法
泛型类型在逻辑上能够看成多个不同的类型,实际上都是雷同的根本类型
泛型的应用
泛型有三种应用形式:
- 泛型类
- 泛型接口
泛型办法
泛型类
泛型类: 泛型类型用于类定义中
- 通过泛型类能够实现对一组类的操作对外开发雷同的接口
最典型的就是各种容器类:
- List
- Set
- Map
泛型类的最根本写法:
class 类名称 <泛型标识: 标识号,标识指定的泛型的类型> { private 泛型标识 成员变量类型 成员变量名;}示例:
/* * 这里的T能够为任意标识,通常应用T,E,K,V等模式的参数示意泛型 * 在实例化泛型时,必须指定T的具体类型 */ public class Generic<T> { // key这个成员变量的类型为T,T的类型由内部指定 private T key; // 泛型构造方法形参key的类型也为T,T的类型由内部指定 public Generic(T key) { this.key = key; } // 泛型构造方法getKey的返回值类型为T,T的类型由内部指定 public T getKey() { } }/* * 泛型的类型参数只能够是类类型,包含自定义类. 不能是简略类型 */ // 传入的实参类型须要与泛型类型的参数类型雷同,即Integer Generic<Integer> genericInteger = new Generic<Integer>(123456); // 传入的实参类型须要与泛型类型的参数类型雷同,即String Generic<String> genericString = new Generic<String>("key_value"); Log.d("泛型测试", "key is" + genericInteger.getKey()); Log.d("泛型测试", "key is" + genericString.getKey());泛型测试: key is 123456泛型测试: key is key_value泛型类中不肯定要传入泛型类型的实参:
- 如果传入泛型实参,会依据传入的泛型实参做相应的限度,此时泛型才会起到本应起到的限度作用
如果不传如泛型类型的实参,在泛型类中应用泛型的办法或者成员变量的定义能够为任何类型
Generic genericString = new Generic("1111");Generic genericInteger = new Generic(5555);Generic genericBigDecimal = new Generic(66.66);Generic genericBoolean = new Generic(true);Log.d("泛型测试", "key is" + genericString.getKey());Log.d("泛型测试", "key is" + genericInteger.getKey());Log.d("泛型测试", "key is" + genericBigDecimal.getKey());Log.d("泛型测试", "key is" + genericBoolean.getKey());D/泛型测试: key is 1111D/泛型测试: key is 5555D/泛型测试: key is 66.66D/泛型测试: key is true
- 泛型的类型参数只能是类类型,不能是简略类型
不能对确切的泛型类型应用instanceof操作,编译时会出错
泛型接口
- 泛型接口与泛型类的定义及应用基本相同
- 泛型接口经常被用在各种类的生产器中
示例:
// 定义一个泛型接口public interface Generator<T> { public T next();}当实现泛型接口的类,未传入泛型实参时:
/** * 未传入泛型实参时,与泛型类的定义雷同,在申明类的时候,需将泛型的申明也一起加到类中: * 即 class FruitGenerator<T> implements Generator<T> {} * 如果不申明泛型,比方: class FruitGenerator implements Generator<T>. 此时编译器会报错 - Unknown class */ class FruitGenerator<T> implements Generator<T> { @Override public T next() { return null; } }当实现泛型接口的类,传入泛型实参时:
/** * 传入泛型实参时: * 定义一个生产器实现这个接口 * 只管只创立了一个泛型接口Generator<T>,然而能够为T传入无数个实参,造成无数种类型的Generator接口 * 在实现类实现泛型接口时,如果曾经将泛型类型传入实参类型,则所有应用泛型的中央波动替换成传入的实参类型 * 即: Generator<T>, public T next(); 这里的T都要替换成传入的String类型 */ public class FruitGenerator implements Generator<String> { private String[] fruits = new String[]{"Apple", "Banana", "Pear"}; @Override public String next() { Random rand = new Random(); return fruits[rand.nextInt(3)]; } }泛型通配符
- Integer是number的一个子类 ,Generic< Integer > 与Generic< number > 实际上是雷同的一种类型
由此,产生如下问题:
- 在应用Generic< number > 作为形参的办法中,是否应用Generic< Integer > 的实例传入?
- 在逻辑上相似于Generic< number >和Generic< Integer >是否能够看成是具备父子关系的泛型类型呢?
Generic< T >泛型类示例:
public void showKeyValue1(Generic<Number> obj) { Log.d("泛型测试", "key value is" + obj.getKey());}Generic<Integer> gInteger = new Generic<Integer>(123);Generic<Number> gNumber = new Generic<Number>(456);showKeyValue(gNumber);showKeyValue这个办法编译器会报错: Generic<java.lang.Integer> cannot be applied to Generic<java.lang.Number> showKeyValue(gInteger);由此能够看到Generic< Integer >不能看作是Generic< Number >的子类.
由此可见:
- 同一种泛型能够对应多个版本,因为参数类型是不确定的
- 不同版本的泛型类型实例是不兼容的
- 为了解决这样的问题,又不能为了定义一个新的办法来解决Generic< Integer >,这与Java中多态的理念违反.因而,须要一个在逻辑上能够示意同时是Generic< Integer >和Generic< Number >父类的援用类型.这样的类型就是类型通配符:
应用通配符示意泛型:
public void showKeyValueWildcard(Generic<?> obj) { Log.d("泛型测试", "key value is" + obj.getKey());}类型通配符个别应用 ? 代替具体的类型实参:
- 此处的 ? 是类型实参, 而不是类型形参.
- 和Number,String,Integer一样,都是一种理论的类型
- 能够把 ? 看作是所有类型的父类,是一种实在的类型
类型通配符的应用场景:
- 当具体类型不确定的时候,这个通配符就是 ?
当操作类型时,不须要应用类型的具体性能,只应用Object类中的性能,那么能够应用 ? 通配符来示意未知的类型
泛型办法
- 泛型类: 在实例化类的时候指明泛型的具体类型
泛型办法: 在调用办法的时候指明泛型的具体类型
/** * 泛型办法: * 1. public 和 返回值两头的 <T> 十分重要,能够了解为申明此办法为泛型办法 * 2. 只有申明了 <T> 的办法才是泛型办法,泛型类中的应用了泛型的成员办法并不是泛型办法 * 3. <T> 示意该办法将应用泛型类型T,此时才能够在办法中应用泛型类型T * 4. 与泛型类的定义一样,此处的T能够为任意标识,常见的比方: T, E, K, V等模式的参数罕用于示意泛型 * * @param tClass 传入的泛型实参 * @return T 返回值为T类型 */ public <T> T genericMethod(Class<T> tClass) throws InstanttiationException, IllegalAccessException { T instance = tClass.newInstance(); return instance; }Object obj = genericMethod(Class.forName("com.oxford.test"));泛型办法的根本用法
泛型办法应用示例:
public class GenericTest { /* * 上面这个类是一个泛型类 */ public class Generic<T> { private T key; public Generic(T key) { this.key = key; } /* * 这个办法尽管在办法应用了泛型,然而这不是一个泛型办法 * 这只是类中一个一般的成员办法,只不过返回值是在申明泛型类曾经申明过的泛型 * 所以在这个办法中才能够持续应用T这个泛型 */ public T getKey() { return key; } /* * 上面的这个办法显然是有问题的,在编译器中就会提醒谬误"cannot resolve symbol E" * 因为在类的申明中并未申明泛型E,所以在应用E做形参和返回值类型时,编译器会无奈辨认 * * public E setKey(E key) { * this.key = key * } */ } /* * 上面这个办法是一个泛型办法: * 首先在public与返回值之间的<T>必不可少,这个表明这是一个泛型办法,并且申明了一个泛型T * 这个T能够呈现在这个泛型办法的任意地位 * 泛型的数量也能够为任意多个 */ public <T> T showKeyName(Generic<T> container) { System.out.println("container key:" + container.getKey()); T test = container.getKey(); return test; } /* * 上面这个办法也不是一个泛型办法 * 这就是一个一般的办法,只是应用了Generic<Number>这个泛型类做形参 */ public void showKeyValue1(Generic<Number> obj) { Log.d("泛型测试", "key value is " + obj.getKey()); } /* * 上面这个办法也不是一个泛型办法 * 这也是一个一般办法,只是应用了泛型通配符 ? * 从这里能够验证: 泛型通配符 ? 是一种类型实参,能够看作是所有类的父类 */ public void showKeyValue2(Generic<?> obj) { Log.d("泛型测试", "key value is" + obj.getKey()); } /* * 上面这个办法是有问题的,在编译器中就会提醒错误信息:"Unknown class 'E'" * 尽管申明了 <T>, 也表明这是一个能够解决泛型类型的泛型办法 * 然而只申明了泛型类型T,并未申明泛型类型E,因而编译器不晓得如何解决E这个类型 * * public <T> T showKeyName(Generic<E> container) { * ... * } */ /* * 上面这个办法也是有问题的,在编译器中就会提醒错误信息:"Unknown class 'T'" * 对于编译器来说 T 这个类型并未在我的项目中申明过,因而编译器也不晓得该如何编译这个类 * 所以这也不是一个正确的泛型办法申明 * * public void showKey(T genericObj) { * ... * } */ public void main(String[] args) { } }类中的泛型办法
- 泛型办法能够呈现在任何中央任何场景中进行应用
然而,当泛型办法呈现在泛型类中时,状况比拟非凡:
public class GenericFruit { class Fruit { @Override public String toString() { return "fruit"; } } class Apple extends Fruit { @Override public String toString() { retrun "apple"; } } class Person { @Override public String toString() { return "Person"; } } class GenerateTest<T> { public void show_1(T t) { System.out.println(t.toString()); } /* * 在泛型类中申明一个泛型办法,应用泛型T * 留神这个T是一种全新的类型,能够与泛型类中申明的T不是同一个类型 */ public <T> void show_2(T t) { System.out.println(t.toString()); } /* * 在泛型类中申明一个泛型办法,应用泛型E. 这种泛型E能够为任意类型,能够与类型T雷同 * 因为泛型办法在申明的时候会申明泛型 <E>,因而即便在泛型类中并未申明泛型,编译器也可能正确辨认泛型办法中辨认的泛型 */ public <E> void show_3(E t) { System.out.println(t.toString()); } } public void main(String[] args) { Apple apple = new Apple(); Person person = new Person(); GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>(); // apple是Fruit的子类,所以这里能够 generateTest.show_1(apple); /* * 编译器会报错,因为泛型类型实参指定的是Fruit,而传入的实参类是Person * * generateTest.show_1(person); */ /* * 应用两个参数都能胜利 */ generateTest.show_2(apple); generateTest.show_2(person); /* * 应用两个参数也都能胜利 */ generateTest.show_3(apple); generateTest.show_3(person); }}泛型办法与可变参数
泛型办法与可变参数:
public <T> void printMsg(T... args) { for (T t : args) { Log.d("泛型测试", "t is" + t); }}静态方法与泛型
留神在类中的静态方法应用泛型:
- 静态方法无法访问类上定义的泛型
- 如果静态方法操作的援用数据类型不确定的时候,必须要将泛型定义在办法上
如果静态方法要应用泛型的话,必须将静态方法定义成泛型办法:
public class StaticGenerator<T> { ... ... /* * 如果在类中定义应用泛型的静态方法,须要增加额定的泛型申明 - 将这个办法定义成泛型办法 * 否则会报错: StaticGenerator cannot be refrenced from static context */ public static <T> void show(T t) { }}泛型办法总结
泛型办法能使办法独立于类而产生变动,应用准则:
- 无论何时,如果能做到,就尽量应用泛型办法
- 如果应用泛型办法将整个类泛型话,就应该应用泛型办法
对于一个static办法,无法访问泛型类型的参数.如果static办法要应用泛型,就必须使之成为泛型办法
泛型的高低边界
在应用泛型的时候,能够为传入的泛型类型实参进行高低边界的限度:
- 比方: 类型的实参只准传入某种类型的父类或者某种类型的子类
为泛型办法增加上边界,即传入的类型实参必须是指定类型的子类型:
public void showKeyValue1(Generic<? extends Number> obj) { Log.d("泛型测试", "key value is" + obj.getKey());}Generic<String> generic1 = new Generic<String>("11111");Generic<Integer> generic2 = new Generic<Integer>(2222);Generic<Float> generic3 = new Generic<Float>(2.4f);Generic<Double> generic4 = new Generic<Double>(2.56);/* * 这一行在编译的时候就会报错,因为String类型并不是Number类型的子类 * * showKeyValue1(generic1); */ showKeyValue2(generic2); showKeyValue3(generic3); showKeyValue4(generic4);为泛型类增加上边界,即类中泛型必须是指定类型的子类型:
public class Generic<T extends Number> { private T key; public Generic(T key) { this.key = key; } public T getKey() { return key; }}/* * 这一行代码在编译的时候会报错,因为String的类型不是Number的子类 */ Generic<String> generic1 = new Generic<String>("1111");在泛型办法中增加高低边界限度时,必须在权限申明与返回值之间的< T >上增加高低边界:
/* * 如果应用: * public <T> showKeyName(Generic<T extends Number> container); * 编译器会报错. */ public <T extends Number> T showKeyName(Generic<T> container) { System.out.println("container key:" + container.getKey()); T test = container.getKey(); return test; }从下面能够看出 : 泛型的高低边界增加,必须与泛型的申明在一起
泛型数组
在Java中,不能创立一个确切的泛型类型的数组
/* * 这个数组创立的形式是不容许的 * List<String>[] ls = new ArrayList<String>[10]; */ // 应用通配符创立泛型数组是能够的 List<?>[] ls = new ArrayList<?>[10]; // 上面的这个办法也是能够的 List<String> ls = new ArrayList[10];示例:
List<String>[] lsa = new List<String>[10]; //不容许这样定义Object o = lsa;Object[] oa = (Object) o;List<Integer> li = new ArrayList<Integer>();li.add(new Integer(3)); oa[1] = li; // 不倡议这样应用,然而能够通过运行时查看String s = lsa[1].get(0); // 运行时报错,类型转换异样因为JVM的擦除机制,在运行时JVM是不晓得泛型信息的:
- 所有能够给oa[1] 赋值一个ArrayList却不会出现异常
- 然而在取出数据的时候要做一次类型转换,就会呈现ClassCastException
- 如果能够进行泛型数组的申明,那么下面的这种状况在编译期将不会呈现任何正告和谬误,只有在运行时才会报错
- 通过对泛型数组的申明进行限度,对于这样的状况,能够在编译期提醒代码有类型平安问题
数组的类型不能够是类型变量,除非是采纳通配符的形式: 因为对于通配符的形式,最初取出数据是要做显式的类型转换的
List<?>[] lsa= new List<?>[10]; // 能够这样定义为泛型数组Object o = lsa;Object[] oa = (Object[]) o;List<Integer> li = new ArrayList<Integer>();li.add(new Integer(3));oa[1] = li; // 能够这样赋值Integer i = (Integer) lsa[1].get(0); // 能够这样取出数据