参考文章:
http://blog.csdn.net/s10461/article/details/53941091
定义:
泛型(Generic type 或者generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样。
解决的问题:
例如,Map类允许您向一个Map添加任意类的对象,即使最常见的情况是在给定映射(map)中保存某个特定类型(比如String)的对象。
因为Map.get()被定义为返回Object,所以一般必须将Map.get()的结果强制类型转换为期望的类型,如下面的代码所示:
Map m = new HashMap(); m.put("key", "blarg"); String s = (String) m.get("key");
要让程序通过编译,必须将get()的结果强制类型转换为String,并且希望结果真的是一个String。但是有可能某人已经在该映射中保存了不是String的东西,这样的话,上面的代码将会抛出ClassCastException
理想情况下,您可能会得出这样一个观点,即m是一个Map,它将String键映射到String值。这可以让您消除代码中的强制类型转换,同时获得一个附加的类型检查层,该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。 即Map<string,string> m=new HashMap<string,string>();
优点:
- 类型安全
泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在一个高得多的程度上验证类型假设。没有泛型,这些假设就只存在于程序员的头脑中(或者如果幸运的话,还存在于代码注释中)。
Java 程序中的一种流行技术是定义这样的集合,即它的元素或键是公共类型的,比如“String列表”或者“String到String的映射”。通过在变量声明中捕获这一附加的类型信息,泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了,而不是在运行时当作ClassCastException展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误,并可提高程序的可靠性。
- 消除强制类型转换
泛型的一个附带好处是,消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。
尽管减少强制类型转换可以降低使用泛型类的代码的罗嗦程度,但是声明泛型变量会带来相应的罗嗦。
该代码不使用泛型:
List li = new ArrayList(); li.put(new Integer(3)); Integer i = (Integer) li.get(0);
该代码使用泛型:
List<Integer> li = new ArrayList<Integer>(); li.put(new Integer(3)); Integer i = li.get(0);
泛型的使用:
命名类型参数
推荐的命名约定是使用大写的单个字母名称作为类型参数。对于常见的泛型模式,推荐的名称是:
- K —— 键,比如映射的键
- V —— 值,比如 List 和 Set 的内容,或者 Map 中的值
- E —— 元素,主要由Java集合(Collections)框架使用
- T —— 类型,主要用于表示第一类通用型参数
泛型类:
泛型类型用于类的定义中,被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类,如:List、Set、Map。
定义一个泛型类
public class Generic<T>{ //key这个成员变量的类型为T,T的类型由外部指定 private T key; public Generic(T key) { //泛型构造方法形参key的类型也为T,T的类型由外部指定 this.key = key; } public T getKey(){ //泛型方法getKey的返回值类型为T,T的类型由外部指定 return key; } }
//泛型的类型参数只能是类类型(包括自定义类),不能是简单类型 //传入的实参类型需与泛型的类型参数类型相同,即为Integer. Generic<Integer> genericInteger = new Generic<Integer>(123456); //传入的实参类型需与泛型的类型参数类型相同,即为String. Generic<String> genericString = new Generic<String>("key_vlaue"); //也可以不传入实参,可以是任何类型 Generic generic2 = new Generic(55.55); Generic generic3 = new Generic(false);
泛型接口:
定义一个泛型接口
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)]; } }
泛型方法:
泛型类,是在实例化类的时候指明泛型的具体类型
泛型方法,是在调用方法的时候指明泛型的具体类型
1)public 与 返回值中间<T>非常重要,可以理解为声明此方法为泛型方法。
2)只有声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
3)<T>表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
4)与泛型类的定义一样,此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型。
定义一个泛型方法
public <T> T genericMethod(Class<T> tClass)throws InstantiationException , IllegalAccessException{ T instance = tClass.newInstance(); return instance; }
参考(1)
/** * 这个方法显然是有问题的,在编译器会给我们提示这样的错误信息"cannot reslove symbol E" * 因为在类的声明中并未声明泛型E,所以在使用E做形参和返回值类型时,编译器会无法识别。 public E setKey(E key){ this.key = keu } */ }
参考(2)
//这只是类中一个普通的成员方法,只不过他的返回值是在声明泛型类已经声明过的泛型。 //所以在这个方法中才可以继续使用 T 这个泛型。 public T getKey(){ return key; }
参考(3)
/** * 这个方法是有问题的,编译器会为我们提示错误信息:"UnKnown class 'E' " * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。 * 但是只声明了泛型类型T,并未声明泛型类型E,因此编译器并不知道该如何处理E这个类型。 public <T> T showKeyName(Generic<E> container){ ... } */
泛型方法&可变参数
public <T> void printMsg( T... args){ for(T t : args){ Log.d("t is " + t); } }
泛型方法&静态方法
静态方法无法访问类上定义的泛型;如果静态方法操作的引用数据类型不确定的时候,必须要将泛型定义在方法上。
public class StaticGenerator<T> { public static <T> void show(T t){ } }
受限泛型:
- ? 是通配符 指代 任意类型
- 泛型的限定上限: <? extends E> 接受 E 或者 E 的子类型
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>("11111");
- 泛型的限定下限: <? super E> 接收 E 或者 E 的父类。
public static void test(List<? super String> list){ for (Object object : list) { System.out.println(object); } }
//这一行会报错,因为Integer不是String的父类 test(new ArrayList<Integer>());
泛型&数组
”不能创建一个确切的泛型类型的数组”
而使用通配符创建泛型数组是可以的,如下面这个例子:
这样也是可以的:
为什么?请参考 http://blog.csdn.net/s10461/article/details/53941091
泛型不是协变的
关于泛型的混淆,一个常见的来源就是假设它们像数组一样是协变的。其实它们不是协变的。List<Object>不是List<String>的父类型。
Integer[] intArray = new Integer[10]; Number[] numberArray = intArray;
上面的代码是有效的,因为一个Integer是一个Number,因而一个Integer数组是一个Number数组。
但是对于泛型来说则不然。下面的代码是无效的,违反泛型消除。
List<Integer> intList = new ArrayList<Integer>(); List<Number> numberList = intList; // invalid numberList.add(new Float(3.1415));
转载于:https://www.cnblogs.com/amei0/p/4497026.html
最后
以上就是温暖背包最近收集整理的关于java基础之 泛型的全部内容,更多相关java基础之内容请搜索靠谱客的其他文章。
发表评论 取消回复