目录
摘要和关键字
1.介绍
2.定义简单的泛型
3.泛型和子类继承
4.通配符(Wildcards)
4.1.有限制的通配符(Bounded Wildcards)
5.泛型方法
6.与旧代码交互
6.1.在泛型代码中使用老代码
6.2.擦除和翻译(Erasure and Translation)
6.3.在老代码中使用泛型代码
7.要点(The Fine Print)
7.1.一个泛型类被其所有调用共享
7.2.转型和instanceof
7.3.数组Arrays
8.Class Literals as Run-time Type Tokens
9.More fun with *
9.1.通配符匹配(wildcard capture)
10.泛型化老代码
11.致谢
generics、type safe、type parameter(variable)、formal type parameter、actua l type parameter、wildcards(?)、unknown type、? extends T、? super T、erasure、transl ation、cast、instanceof、arrays、Class Literals as Run-time Type Tokens、wildcard captur e、multiple bounds(T extends T1& T2 ... & Tn)、covariant returns
1.介绍
JDK1.5中引入了对java语言的多种扩展,泛型(generics)即其中之一。
这个教程的目标是向您介绍java的泛型(generic)。你可能熟悉其他语言的泛型,最著名的是C++的模板(templates)。如果这样,你很快就会看到两者的相似之处和重要差异。如果你不熟悉相似的语法结构,那么更好,你可以从头开始而不需要忘记误解。
Generics允许对类型进行抽象(abstract over types)。最常见的例子是集合类型(Contain er types),Collection的类树中任意一个即是。
下面是那种典型用法:
List myIntList = new LinkedList();// 1
myIntList.add(new Integer(0));// 2
Integer x = (Integer) myIntList.iterator().next();// 3
第3行的类型转换有些烦人。通常情况下,程序员知道一个特定的list里边放的是什么类型的数据。但是,这个类型转换是必须的(essential)。编译器只能保证iterator返回的是Object类型。
为了保证对Integer类型变量赋值的类型安全,必须进行类型转换。
当然,这个类型转换不仅仅带来了混乱,它还可能产生一个运行时错误(run time error),因为程序员可能会犯错。
程序员如何才能明确表示他们的意图,把一个list中的内容限制为一个特定的数据类型呢?这是generics背后的核心思想。这是上面程序片断的一个泛型版本:
List
myIntList.add(new Integer(0)); // 2
Integer x = myIntList.iterator().next(); // 3
注意变量myIntList的类型声明。它指定这不是一个任意的List,而是一个Integer的List,写作:List
另一个需要注意的是第3行没了类型转换。
现在,你可能认为我们已经成功地去掉了程序里的混乱。我们用第1行的类型参数取代了第3行的类型转换。然而,这里还有个很大的不同。编译器现在能够在编译时检查程序的正确性。当我们说myIntList被声明为List
实际结果是,这可以增加可读性和稳定性(robustness),尤其在大型的程序中。
下面是从java.util包中的List接口和Iterator接口的定义中摘录的片断:
public interface List
void add(E x);
Iterator
}
public interface Iterator
E next();
boolean hasNext();
}
这些都应该是很熟悉的,除了尖括号中的部分,那是接口List和Iterator中的形式类型参数的声明(the declarations of the formal type parameters of the interfaces List and It erator)。
类型参数在整个类的声明中可用,几乎是所有可是使用其他普通类型的地方(但是有些重要的限制,请参考第7部分)。
(原文:Type param eters can be used throughout the generic declaration, pret ty much where you would use ordinary types (though there are some important r estrictions; see section 7))
在介绍那一节我们看到了对泛型类型声明List(the generic type declaration List)的调用,如List
你可能想象,List
public interface IntegerList {
void add(Integer x)
Iterator
}
这种直觉可能有帮助,但是也可能导致误解。
它有帮助,因为List
它可能导致误解,因为泛型声明绝不会实际的被这样替换。没有代码的多个拷贝,源码中没有、二进制代码中也没有;磁盘中没有,内存中也没有。如果你是一个C++程序员,你会理解这是和C ++模板的很大的区别。
一个泛型类型的声明只被编译一次,并且得到一个class文件,就像普通的class或者interf ace的声明一样。
类型参数就跟在方法或构造函数中普通的参数一样。就像一个方法有形式参数(formal value parameters)来描述它操作的参数的种类一样,一个泛型声明也有形式类型参数(formal type p aram eters)。当一个方法被调用,实参(actual arguments)替换形参,方法体被执行。当一个泛型声明被调用,实际类型参数(actual type arguments)取代形式类型参数。
一个命名的习惯:我们推荐你用简练的名字作为形式类型参数的名字(如果可能,单个字符)。最好避免小写字母,这使它和其他的普通的形式参数很容易被区分开来。许多容器类型使用E作为其中元素的类型,就像上面举的例子。在后面的例子中还会有一些其他的命名习惯。
让我们测试一下我们对泛型的理解。下面的代码片断合法么?
List
List
第1行当然合法,但是这个问题的狡猾之处在于第2行。
这产生一个问题:
一个String的List是一个Object的List么?大多数人的直觉是回答:“当然!”。
好,在看下面的几行:
lo.add(new Object()); // 3
String s = ls.get(0); // 4: 试图把Object赋值给String
这里,我们使用lo指向ls。我们通过lo来访问ls,一个String的list。我们可以插入任意对象进去。结果是ls中保存的不再是String。当我们试图从中取出元素的时候,会得到意外的结果。
java编译器当然会阻止这种情况的发生。第2行会导致一个编译错误。
总之,如果Foo是Bar的一个子类型(子类或者子接口),而G是某种泛型声明,那么G
这可能是你学习泛型中最难理解的部分,因为它和你的直觉相反。
这种直觉的问题在于它假定这个集合不改变。我们的直觉认为这些东西都不可改变。
举例来说,如果一个交通部(DMV)提供一个驾驶员里表给人口普查局,这似乎很合理。我们想,一个List
为了处理这种情况,考虑一些更灵活的泛型类型很有用。到现在为止我们看到的规则限制比较大。
考虑写一个例程来打印一个集合(Collection)中的所有元素。下面是在老的语言中你可能写的代码:
void printCollection(Collection c) {
Iterator i =c.iterator();
for(int k =0; k System.out.println(i.next()); } } 下面是一个使用泛型的幼稚的尝试(使用了新的循环语法): void printCollection(Collection for(Object e : c) { System.out.println(e); } } 问题是新版本的用处比老版本小多了。老版本的代码可以使用任何类型的collection作为参数,而新版本则只能使用Collection 那么什么是各种collections的父类呢?它写作:Collection>(发音为:"collection of u nknown"),就是,一个集合,它的元素类型可以匹配任何类型。显然,它被称为通配符。我们可以写: void printCollection(Collection> c) { for(Object e : c) { System.out.println(e); } } 现在,我们可以使用任何类型的collection来调用它。注意,我们仍然可以读取c中的元素,其类型是Object。这永远是安全的,因为不管collection的真实类型是什么,它包含的都是obje cts。但是将任意元素加入到其中不是类型安全的: Collection> c = new ArrayList c.add(new Object()); // 编译时错误 因为我们不知道c的元素类型,我们不能向其中添加对象。 add方法有类型参数E作为集合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。因为我们不知道那是什么类型,所以我们无法传任何东西进去。唯一的例外是null,它是所有类型的成员。 另一方面,我们可以调用get()方法并使用其返回值。返回值是一个未知的类型,但是我们知道,它总是一个Object,因此把get的返回值赋值给一个Object类型的对象或者放在任何希望是Object类型的地方是安全的。 4.1.有限制的通配符(Bounded Wildcards) 考虑一个简单的画图程序,它可以用来画各种形状,比如矩形和圆形。 为了在程序中表示这些形状,你可以定义下面的类继承结构: public abstract class Shape { public abstract void draw(Canvas c); } public class Circle extends Shape { private int x, y, radius; public void draw(Canvas c) { // ... } } public class Rectangle extends Shape { private int x, y, width, height; public void draw(Canvas c) { // ... } } 这些类可以在一个画布(Canvas)上被画出来: public class Canvas { public void draw(Shape s) { s.draw(this); } } 所有的图形通常都有很多个形状。假定它们用一个list来表示,Canvas里有一个方法来画出所有的形状会比较方便: public void drawAll(List for (Shape s : shapes) { s.draw(this); } } 现在,类型规则导致drawAll()只能使用Shape的list来调用。它不能,比如说对List public void drawAll(List extends Shape> shapes) { //..} 这里有一处很小但是很重要的不同:我们把类型 List List extends Shape>是有限制通配符的一个例子。这里?代表一个未知的类型,就像我们前面看到的通配符一样。但是,在这里,我们知道这个未知的类型实际上是Shape的一个子类(它可以是Shape本身或者Shape的子类而不必是extends自Sha pe)。我们说Shape是这个通配符的上限(upper bound)。 像平常一样,要得到使用通配符的灵活性有些代价。这个代价是,现在像shapes中写入是非法的。比如下面的代码是不允许的: public void addRectangle(List extends Shape> shapes) { shapes.add(0, new Rectangle()); // compile-time error! } 你应该能够指出为什么上面的代码是不允许的。因为shapes.add的第二个参数类型是? extends Shape ——一个Shape未知的子类。因此我们不知道这个类型是什么,我们不知道它是不是Rectangle的父类;它可能是也可能不是一个父类,所以这里传递一个Rectangle不安全。 有限制的通配符正是我们解决DMV给人口普查局传送名单的例子所需要的。我们的例子假定数据用一个姓名(String)到people(用Person或其子类来表示,比如Driver)。Map 再一次,注意形式类型参数的命名习惯——K代表keys,V代表vlaues。 public class Census { public static void addRegistry(Map }... Map Census.addRegistry(allDrivers); 考虑写一个方法,它用一个Object的数组和一个collection作为参数,完成把数组中所有object放入collection中的功能。 下面是第一次尝试: static void fromArrayToCollection(Object[] a, Collection> c) { for (Object o : a) { c.add(o); // 编译期错误 } } 现在,你应该能够学会避免初学者试图使用Collection 解决这个问题的办法是使用generic methods。就像类型声明,方法的声明也可以被泛型化——就是说,带有一个或者多个类型参数。 static for (T o : a) { c.add(o); // correct } } 我们可以使用任意集合来调用这个方法,只要其元素的类型是数组的元素类型的父类。 Object[] oa =new Object[100]; Collection from ArrayToCollection(oa, co);// T 指Object String[] sa =new String[100]; Collection from ArrayToCollection(sa, cs);// T inferred to be String from ArrayToCollection(sa, co);// T inferred to be Object Integer[] ia =new Integer[100]; Float[] fa =new Float[100]; Number[] na =new Number[100]; Collection from ArrayToCollection(ia, cn);// T inferred to be Number from ArrayToCollection(fa, cn);// T inferred to be Number from ArrayToCollection(na, cn);// T inferred to be Number from ArrayToCollection(na, co);// T inferred to be Objec t from ArrayToCollection(na, cs);// compile-tim e error 注意,我们并没有传送真实类型参数(actual type argum ent)给一个泛型方法。编译器根据实参为我们推断类型参数的值。它通常推断出能使调用类型正确的最明确的类型参数(原文是:It will generally infer the most specific type argument that will make the call type-correct.)。 现在有一个问题:我们应该什么时候使用泛型方法,又什么时候使用通配符类型呢? 为了理解答案,让我们先看看Collection库中的几个方法。 public interface Collection boolean containsAll(Collection> c); boolean addAll(Collection extends E> c); } 我们也可以使用泛型方法来代替: public interface Collection // hey, type variables can have bounds too! } 但是,在containsAll 和addAll中,类型参数T 都只使用一次。返回值的类型既不依赖于类型参数(type parameter)也不依赖于方法的其他参数(这里,只有简单的一 个参数)。这告诉我们类型参数(type argument)被用作多态(polymorphism),它唯一的效果是允许在不同的调用点,可以使用多种实参类型(actual argument)。如果是这种情况,应该使用通配符。通配符就是被设计用来支持灵活的子类化的,这是我们在这里要强调的。 泛型函数允许类型参数被用来表示方法的一个或多个参数之间的依赖关系,或者参数与其返回值的依赖关系。如果没有这样的依赖关系,不应该使用泛型方法。 (原文:Generic m ethods allow type param eters to be used to express dependencies am ong the types of one or m ore arguments to a m ethod a nd/or its return type. If there isn’t such a dependency, a generic m ethod should not be used.) 一前一后的同时使用泛型方法和通配符也是可能的。下面是方法 Collections.copy (): class Collections { public static } 注意两个参数的类型的依赖关系。任何被从源list从拷贝出来的对象必须能够将其指定为目标list(dest) 的元素的类型——T类型。因此源类型的元素类型可以是T的任意子类型,我们不关心具体的类型。 copy方法的签名使用一个类型参数表示了类型依赖,但是使用了一个通配符作为第二个参数的元素类型。我们也可以用其他方式写这个函数的签名而根本不使用通配符: class Collections { public static } 这也可以,但是第一个类型参数在dst的类型和第二个参数的类型参数S的上限这两个地方都有使用,而S本身只使用一次,在src的类型中——没有其他的依赖于它。这意味着我们可以用通配符来代替S。使用通配符比声明显式的类型参数更加清晰和准确,所以在可能的情况下使用通配符更好。 通配符还有一个优势式他们可以在方法签名之外被使用,比如field的类型,局部变量和数组。这就有一个例子。 回到我们的画图问题,假定我们想要保持画图请求的历史记录。我们可以把历史记录保存在Shape类的一个静态成员变量里,在drawAll() 被调用的时候把传进来的参数保存进历史记录: static List public void drawAll(List extends Shape> shapes) { history.addLast(shapes); for (Shape s: shapes) { s.draw(this); } } 最终,再说一下类型参数的命名习惯。 我们使用T 代表类型,无论何时都没有比这更具体的类型来区分它。这经常见于泛型方法。如果有多个类型参数,我们可能使用字母表中T的临近的字母,比如S。如果一个泛型函数在一个泛型类里边出现,最好避免在方法的类型参数和类的类型参数中使用同样的名字来避免混淆。对内部类也是同样。 6.与旧代码交互 直到现在,我们的例子中都假定了一个理想的世界,那里所有人使用的都是最新版本的java 编程语言,它支持泛型。 唉,现实并非如此。百万行代码都是在早先版本的语言下写作的,他们不可能一晚上就转换过来。 后面,在第10部分,我们会解决把老代码转换为使用泛型的代码的问题。在这里,我们把注意力放在一个更简单的问题:老代码怎么和泛型代码交互?这个问题包括两部分:在泛型中使用老代码和在老代码中使用泛型代码。 6.1.在泛型代码中使用老代码 怎样才能使用老代码的同时在自己的代码中享受泛型带来的好处? 作为一个例子,假定你像使用包com.Fooblibar.widgets。https://www.doczj.com/doc/8410840030.html,(完全虚构出来的公司)的人们出售一种进行库存管理的系统,下面是主要代码: package com.Fooblibar.widgets; public interface Part { ...} public class Inventory { /** * 添加一个新配件到库存数据库 * 配件有名字name, 并由零件(Part)的集合组成。 * 零件由parts 指定. collection parts 中的元素必须实现Part接口。 **/ public static void addAssembly(String name, Collection parts) {...} public static Assembly getAssem bly(String nam e) {...} } public interface Assembly { Collection getParts(); // Returns a collection of Parts } 现在,你想使用上述API写新代码。如果能保证调用addAssembly()时总是使用正确的参数会很棒——就是说,你传进去的确实时一个Part的Collection。当然,泛型可以实现这个目的: package com.mycom pany.inventory; import com.Fooblibar.widgets.*; public class Blade implements Part { ... } public class Guillotine implements Part { } public class Main { public static void main(String[] args) { Collection c.add(new Guillotine()) ; c.add(new Blade()); Inventory.addAssembly(”thingee”, c); Collection } } 当我们调用addAssembly,它希望第二个参数是Collection类型。而实际参数是C ollection 在严格的泛型代码里,Collection应该总是带着类型参数。当一个泛型类型,比如C ollection被使用而没有类型参数时,它被称作一个raw type(自然类型??)。 大多数人的第一直觉时Collection实际上意味着Collection 但是等一下,那也不正确。考虑getParts()这个调用,它返回一个Collection。然后它被赋值给k,而k是Collection 事实上,这个赋值是合法的,但是它产生一个未检查警告(unchecked warning)。这个警告是必要的,因为事实是编译器无法保证其正确性。我们没有办法检查getAssem bl y()中的旧代码来保证返回的确实是一个Collection 那么,这应该是一个错误么?理论上讲,Yes,但是实际上讲,如果泛型代码要调用旧代码,那么这必须被允许。这取决于你,程序员,在这种情况下来满足你自己。这个赋值是合法的因为getAssem bly()的调用约定中说它返回一个Part的集合,即使这个类型声明中没有显示出这一点。 因此,自然类型和通配符类型很像,但是他们的类型检查不是同样严格。允许泛型与已经存在的老代码相交互是一个深思熟虑的决定。 从泛型代码中调用老代码具有先天的危险性,一旦你把泛型编程和非泛型编程混合起来,泛型系统所提供的所有安全保证都失效。然而,你还是比你根本不用泛型要好。至少你知道你这一端的代码是稳定的。 在非泛型代码远比泛型代码多的时候,不可避免会出现两者必须混合的情况。 如果你发现你不得不混合旧代码和泛型代码,仔细注意未检查警告(unchecked warn ings),仔细考虑你怎样才能证明出现警告的部分代码是正确的。 如果你仍然犯了错,而导致警告的代码确实不是类型安全的,那么会发生什么?让我们看一下这种情形。在这个过程中,我们将了解一些编译器工作的内幕。 6.2.擦除和翻译(Erasure and Translation) public String loophole(Integer x) { List List xs = ys; xs.add(x); // compile-time unchecked warning return ys.iterator().next(); } 这里,我们用一个老的普通的list的引用来指向一个String的list。我们插入一个Integer 到这个list中,并且试图得到一个String。这是明显的错误。如果我们忽略这个警告并且试图运行以上代码,它将在我们试图使用错误的类型的地方失败。在运行的时候,上面的代码与下面的代码的行为一样: public String loophole(Integer x) { List ys = new LinkedList(); List xs = ys; xs.add(x); return (String) ys.iterator().next(); // run time error } 当我们从list中获取一个元素的时候,并且试图通过转换为String而把它当作一个string,我们得到一个 ClassCastException。完全一样的事情发生在使用泛型的代码上。 这样的原因是,泛型是通过java编译器的称为擦除(erasure)的前端处理来实现的。你可以(基本上就是)把它认为是一个从源码到源码的转换,它把泛型版本的loophole()转换成非泛型版本。 结果是,java虚拟机的类型安全和稳定性决不能冒险,即使在又unchecked warning的情况下。 (原文:As a result, the type safety and integrity of the Java virtual machine are never at risk, even in the presence of unchecked warnings.) 基本上,擦除去掉了所有的泛型类型信息。所有在尖括号之间的类型信息都被扔掉了,因此,比如说一个List 擦除的全部的细节超出了本文的范围,但是我们给出的简单描述与事实很接近。知道一点这个有好处,特别是如果你要作一些复杂的事,比如把现有API转换成使用泛型的代码(第10部分)或者仅仅是想理解为什么会这样。 6.3.在老代码中使用泛型代码 现在让我们来考虑相反的情形。假定https://www.doczj.com/doc/8410840030.html,公司的人决定把他们的代码转换为使用泛型来实现,但是他们的一些客户没有转换。现在代码就像下面: package com.Fooblibar.widgets; public interface Part { ...} public class Inventory { /** * Adds a new Assembly to the inventory database. * The assembly is given the name name, and consists of a set * parts specified by parts. All elements of the collection parts * must support the Part interface. **/ public static void addAssembly(String name, Collection public static Assembly getAssembly(String name) {...} } public interface Assembly { Collection } 客户端代码如下: package com.mycompany.inventory; import com.Fooblibar.widgets.*; public class Blade implements Part { ... } public class Guillotine implements Part { } public class Main { public static void main(String[] args) { Collection c = new ArrayList(); c.add(new Guillotine()) ; c.add(new Blade()); Inventory.addAssembly(”thingee”, c); // 1: unchecked warning Collection k = Inventory.getAssembly(”thingee”).getParts(); } } 客户端代码是在泛型被引入之前完成的,但是它使用了包com.Fooblibar.widgets 和集合库,它们都使用了泛型。客户端代码中的泛型类的声明都是使用了自然类型(raw types)。第1行产生一个unchecked warning,因为一个自然的Collection被传递到一个需要Collection 你还有另一种选择,你可以使用source 1.4 标志来编译客户端代码,以保证不会产生警告。但是这种情况下你无法使用jdk1.5 中的任何新特性。 7.要点(The Fine Print) 7.1.一个泛型类被其所有调用共享 下面的代码打印的结果是什么? List List System.out.println(l1.getClass() == l2.getClass()); 或许你会说false,但是那你就错了。它打印出true。因为所有的泛型类型在运行时有同样的类(class),而不管他们的实际类型参数。 事实上,泛型之所以为泛型就是因为它对所有其可能的类型参数,它有同样的行为;同样的类可以被当作许多不同的类型。 作为一个结果,类的静态变量和方法也在所有的实例间共享。这就是为什么在静态方法或静态初始化代码中或者在静态变量的声明和初始化时使用类型参数申明是不合法的原因。 (原文:As consequence, the static variables and methods of a class are also share d among all th e instances. That is why it is illegal to refer to the type parameters o f a type declaration in a static method or initializer, or in the declaration or initi alizer of a static variable.) 7.2.转型和instanceof 泛型类被所有其实例(instances)共享的另一个暗示是检查一个实例是不是一个特定类型的泛型类是没有意义的。 Collection cs = new ArrayList if (cs instanceof Collection 类似的,如下的类型转换 Collection 得到一个unchecked warning,因为运行时环境不会为你作这样的检查。 对类型变量也是一样: return (T) o; // unchecked warning } 类型参数在运行时并不存在。这意味着它们不会添加任何的时间或者空间上的负担,这很好。不幸的是,这也意味着你不能依靠他们进行类型转换。 7.3.数组Arrays 数组对象的组成类型不能是一个类型变量或者类型参数,除非它是无上限的通配符类型。你可以声明元素类型是一个类型参数或者参数化类型的数组类型,但不是数组对象(译注:得不到对象,只能声明)。 (原文:The component type of an array object may not be a type variable or a para meterized type, unless it is an (unbounded) wildcard type.You can declare array types whose element type is a type variable or a parameterized type, but not array objects.) 这很烦人,但是确实时这样。为了避免下面的情况,必须有这样的限制: List Object o = lsa; Object[] oa = (Object[]) o; List li.add(new Integer(3)); oa[1] = li; // unsound, but passes run time store check String s = lsa[1].get(0); // run-time error - ClassCastException 如果参数化类型可以是数组,那么意味着上面的例子可以没有任何unchecked warnings的通过编译,但是在运行时失败。我们把类型安全(type-safety)作为泛型首要的设计目标。特别的,j ava语言被设计为保证:如果你的整个程序没有unchecked warnings的使用javac –source1.5通过编译,那么它是类型安全的(原文: if your entire application has been compiled without unchecked warnings using javac -source 1.5, it is type safe)。 然和,你仍然可以使用通配符数组。上面的代码有两种变化。第一种改变放弃使用数组对象和元素类型参数化的数组类型。结果是,我们不得不显式的进行类型转换来从数组中获得一个String。 List>[] lsa = new List>[10]; // ok, array of unbounded wildcard type Object o = lsa; Object[] oa = (Object[]) o; List li.add(new Integer(3)); oa[1] = li; // correct String s = (String) lsa[1].get(0); // run time error, but cast is explicit 在下面的变体中,我们避免了产生一个元素类型是参数化的数组对象,但是使用了元素类型参数化的类型。(译注:意思如下面的第一行代码所示,声明一个泛型化的数组,但是new的时候使用的是raw type,原文中是 new ArrayList>(10),那是错的,已经修正为new ArrayList(10);)这是合法的,但是产生一个unchecked warning。实际上,这个代码是不安全的,最后产生一个错误。 List Object o = lsa; Object[] oa = (Object[]) o; List li.add(new Integer(3)); oa[1] = li; // correct String s = lsa[1].get(0); // run time error, but we were warned 类似的,创建一个元素类型是一个类型变量的数组对象导致一个编译时错误: return new T[100]; // error } 因为类型变量在运行时并不存在,所以没有办法决定实际类型是什么。 解决这些限制的办法是使用字面的类作为运行时类型标志(原文:use class literals as ru n time type tokens),见第8部分。 8.Class Literals as Run-time Type Tokens JDK1.5中一个变化是类 https://www.doczj.com/doc/8410840030.html,ng.Class是泛型化的。这是把泛型作为容器类之外的一个很有意思的例子(using genericity for something other than a container class)。 现在,Class有一个类型参数T, 你很可能会问,T 代表什么? 它代表Class对象代表的类型。比如说,String.class类型代表 Class 特别的,因为 Class的 newInstance() 方法现在返回一个T, 你可以在使用反射创建对象时得到更精确的类型。 比如说,假定你要写一个工具方法来进行一个数据库查询,给定一个SQL语句,并返回一个数据库中符合查询条件的对象集合(collection)。 一个方法时显式的传递一个工厂对象,像下面的代码: interface Factory public T[] make(); } 《集合框架及泛型》作业 一、根据课上讲解内容,完成演示示例和课堂练习 1、ArrayList获取并打印新闻标题 需求说明:按照以下实现的步骤,使用ArrayList获取和打印新闻标题,显示效果如下图所示: (1)创建多个各类新闻标题对象,包含ID、名称和创建者三个属性; (2)创建存储各类新闻标题的集合对象; (3)按照顺序依次添加各类新闻标题,使用add()方法; (4)获取新闻标题的总数,使用size()方法; (5)根据位置获取相应新闻标题、逐条打印每条新闻标题的名称,使用for 循环遍历。 2、ArrayList存储狗狗信息 需求说明:按照以下实现的步骤,使用ArrayList存储狗狗信息,使用ArrayList的方法对狗狗信息进行删除、读取和判断,显示效果如下图所示:(1)存储多条狗信息,获取狗总数,逐条打印出各条狗信息; (2)删除指定位置的狗,使用remove()方法; (3)判断集合中是否包含指定狗,使用contains()方法; 3、LinkedList添加和删除新闻标题 需求说明:在作业1的基础上,换用LinkedList存储新闻数据,并且使用LinkedList的getFirst()和getLast()方法获取第一条和最后一条数据,以及removeFirst()和removeLast()方法删除第一条和最后一条数据,输出效果如下图所示。 4、集合头尾位置删除和条件狗信息 需求说明:按照作业3的实现方式和所用到LinkedList的方法,实现狗狗信 息的更新并输出,输出效果如图所示。 5、使用Iterator和增强型for循环遍历Set 需求说明:按照以下实现的步骤,使用Iterator和增强型for循环遍历Set,输出效果如下图所示: (1)创建多个各类新闻标题对象,包含ID、名称和创建者三个属性; (2)创建存储各类新闻标题的集合对象; (3)按照顺序依次添加各类新闻标题; (4)获取新闻标题的总数; (5)使用iterator()获取Iterator对象; (6)使用Iterator遍历集合,使用hasNext()方法作为循环条件,判断是否存在另一个可访问的元素; (7)使用增强型for遍历集合; java泛型详解 泛型(Generic type 或者generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样。 可以在集合框架(Collection framework)中看到泛型的动机。例如,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值。这可以让您消除代码中的强制类型转换,同时获得一个附加的类型检查层,该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。 泛型的好处 Java 语言中引入泛型是一个较大的功能增强。不仅语言、类型系统和编译器有了较大的变化,以支持泛型,而且类库也进行了大翻修,所以许多重要的类,比如集合框架,都已经成为泛型化的了。这带来了很多好处: · 类型安全。泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在一个高得多的程度上验证类型假设。没有泛型,这些假设就只存在于程序员的头脑中(或者如果幸运的话,还存在于代码注释中)。 Java 程序中的一种流行技术是定义这样的集合,即它的元素或键是公共类型的,比如“Str ing列表”或者“String到String的映射”。通过在变量声明中捕获这一附加的类型信息,泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了,而不是在运行时当作 ClassCastException展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误,并可提高程序的可靠性。 实验十泛型与集合框架 1.实验目的 1、掌握LinkedList Java 语言程序设计 C 实验报告 集合框架及泛型机制 学生姓名 专业、班级 指导教师 成绩 计算机与信息工程学院 年月日 一、实验目的 学习课程相关章节知识,通过上机练习,掌握以下知识: 1.掌握 List 接口下 ArrayList 及 LinkedList 的使用方法。 2.掌握 Map 接口下 HashMap 及 HashTable的使用方法 3.掌握集合中泛型的使用 二、实验内容 利用集合完成象数据库那样存储数据,并且可以简单查询,利用 map 存储学生信息,字段如下: id ,name,age,实现步骤: (1)创建类,类图如下: (2)在 main 方法编写逻辑代码 (3)运行程序并测试结果 package https://www.doczj.com/doc/8410840030.html,; public class Student { private String name ; private int age ; private String id ; public String getName() { return name ; } public void setName(String name ) { this . name =name ; } public int getAge() { return age ; } public void setAge(int age ) { this. age=age ; } public String getId() { return id; } public void setId(String id) { this. id=id; } public Student(String name ,int age , String id ) { super(); this. name =name ; this. age=age ; this. id=id; } public void sayHi() { System.out.println("name=" +this.getName()+"age=" + this .getAge()+" " + "id=" + this.getId()); } } Java语言程序设计C 实验报告 集合框架及泛型机制 学生姓名 专业、班级 指导教师 成绩 计算机与信息工程学院 年月日 一、实验目的 学习课程相关章节知识,通过上机练习,掌握以下知识: 1.掌握List接口下ArrayList及LinkedList的使用方法。 2.掌握Map接口下HashMap 及HashTable的使用方法 3.掌握集合中泛型的使用 二、实验内容 利用集合完成象数据库那样存储数据,并且可以简单查询,利用map存储学生信息,字段如下: id ,name,age,实现步骤: (1)创建类,类图如下: (2)在main方法编写逻辑代码 (3)运行程序并测试结果 package com、cn; public class Student { private String name; private int age; private String id; public String getName() { return name; } public void setName(String name) { this、name = name; } public int getAge() { return age; } public void setAge(int age) { this、age = age; } public String getId() { return id; } public void setId(String id) { this、id = id; } public Student(String name, int age, String id) { super(); this、name = name; this、age = age; this、id = id; } public void sayHi() { System、out、println("name="+this、getName()+"age="+this、getAge()+" "+"id="+this、getId()); } } //Databace类 package com、cn; import java、util、Collection; import java、util、HashMap; import java、util、Iterator; public class Databace { private Student a; public Databace() { super(); map=new HashMap Java 泛型 1 什么是泛型 (2) 2 泛型类跟接口及泛型方法 (3) 2.1 泛型类跟接口及继承 (3) 2.1.1泛型类 (3) 2.1.2继承 (3) 2.1.3接口 (3) 2.2 泛型方法 (3) 2.2.1 方法 (3) 2.2.2 类型推断 (4) 3 泛型实现原理 (5) 4 泛型数组 (6) 5边界 (7) 6通配符 (8) 7 泛型的问题及建议 (9) 7.1问题 (9) 7.2 建议 (9) 1 什么是泛型 从jdk1.5开始,Java中开始支持泛型了。泛型是一个很有用的编程工具,给我们带来了极大的灵活性。在看了《java核心编程》之后,我小有收获,写出来与大家分享。 所谓泛型,我的感觉就是,不用考虑对象的具体类型,就可以对对象进行一定的操作,对任何对象都能进行同样的操作。这就是灵活性之所在。但是,正是因为没有考虑对象的具体类型,因此一般情况下不可以使用对象自带的接口函数,因为不同的对象所携带的接口函数不一样,你使用了对象A的接口函数,万一别人将一个对象B传给泛型,那么程序就会出现错误,这就是泛型的局限性。所以说,泛型的最佳用途,就是用于实现容器类,实现一个通用的容器。该容器可以存储对象,也可以取出对象,而不用考虑对象的具体类型。因此,在学习泛型的时候,一定要了解这一点,你不能指望泛型是万能的,要充分考虑到泛型的局限性。下面我们来探讨一下泛型的原理以及高级应用。首先给出一个泛型类: public class Pair 任务一:用LinkedList存放对象 1.利用面向对象的思想,创建以下类: ●Person类,包含Person的姓名和身份证号码,覆盖Object类的toString() 方法,显示“姓名:XXX 身份证号:XXX”。 ●Student类,继承Person类,包含学生的语文、数学、英文课的成绩,并覆盖 父类的toString()方法,显示“姓名:XXX 身份证号:XXX 语文:XXX 数学:XXX 英文:XXX”。 ●Teacher类,继承Person类,包含教师的工资。并覆盖父类的toString()方 法,显示“姓名:XXX 身份证号:XXX 工资:XXX”。 ●public class Person implements Comparable{ ●String name; ●String ID; ●Person(String s,String i){ ●name=s; ●ID=i; } ●public String toString() { ●String str="姓名:"+name+" 身份证号码:"+ID; ●return str; } ●public int compareTo(Object arg0) { ●Person p=(Person)arg0; ●return https://www.doczj.com/doc/8410840030.html,pareTo(p.ID); } } ●class Student extends Person { ●int Chinese; ●int Math; ●int English; ●Student(String n,String i,int c,int m,int e){ ●super(n,i); ●Chinese=c; ●Math=m; ●English=e; } ●public String toString() { ●String str; ●str=" 语文成绩:"+Chinese+" 数学成绩:"+Math+" 英语成绩: "+English; ●return super.toString()+str; ●} ●} ●class Teacher extends Person{ ●int salary; ●Teacher(String n,String i,int s){ ●super(n,i); ●salary=s; ●} Java 泛型详解 泛型是Java中一个非常重要的知识点,在Java集合类框架中泛型被广泛应用。本文我们将从零开始来看一下Java 泛型的设计,将会涉及到通配符处理,以及让人苦恼的类型擦除。 泛型基础 泛型类 我们首先定义一个简单的Box类: public class Box { private String object; public void set(String object) { this.object = object; } public String get() { return object; }}这是最常见的做法,这样做的一个坏处是Box里面现在只能装入String类型的元素,今后如果我们需要装入Integer等其他类型的元素,还必须要另外重写一个Box,代码得不到复用,使用泛型可以很好的解决这个问题。 public class Box { // T stands for 'Type' private T t; public void set(T t) { this.t = t; } public T get() { return t; }} 这样我们的Box类便可以得到复用,我们可以将T替换成任何我们想要的类型: Box integerBox = new Box();Box doubleBox = new Box();Box stringBox = new Box(); 泛型方法 看完了泛型类,接下来我们来了解一下泛型方法。声明一个泛型方法很简单,只要在返回类型前面加上一个类似的形式就行了: public class Util { public static boolean compare(Pair p1, Pair p2) { return p1.getKey().equals(p2.getKey()) && p1.getValue().equals(p2.getValue()); }}public class Pair { private K key; private V value; public Pair(K key, V value) { this.key = key; this.value = value; } public void setKey(K key) { this.key = key; } public void setValue(V value) { this.value = value; } public K getKey() { return key; } public V getValue() { return value; }} 我们可以像下面这样去调用泛型方法: Pair p1 = new Pair(1, 'apple');Pair p2 = new Pair(2, 'pear');boolean same = https://www.doczj.com/doc/8410840030.html,pare(p1, p2); 或者在Java1.7/1.8利用type inference,让Java自动推导出相应的类型参数: Pair p1 = new Pair(1, 'apple');Pair p2 = new Pair(2, 'pear');boolean same = https://www.doczj.com/doc/8410840030.html,pare(p1, p2); 浙江大学城市学院实验报告 课程名称面向对象程序设计 实验项目名称集合框架与泛型 学生姓名专业班级学号 一. 实验目的和要求 1. 了解Java集合框架的接口和实现类 2. 理解泛型类、泛型接口、泛型方法的特点 3. 掌握List 泛型与集合框架 1.实验目的 1、掌握LinkedList java 集合框架(习题) 集合框架 Key Point * Collection 接口、Set 接口、List 接口基本操作 * List 接口及其实现类 * Set 接口及其实现类 * 迭代遍历 * Hash 算法与hashCode 方法 * Comparable 接口 * Map 接口及其实现类 * 遍历Map * 泛型 练习 1. 填空 Collection 接口的特点是元素是对象; List 接口的特点是元素有(有|无)顺序,可以(可以|不可以)重复; Set 接口的特点是元素无(有|无)顺序,不可以(可以|不可以)重复;Map 接口的特点是元素是键值对,其中值可以重复,键不可以重复。 2. (List)有如下代码 import java.util.*; public class TestList{ public static void main(String args[]){ List list = new ArrayList(); list.add(“Hello”); list.add(“World”); list.add(1, “Learn”); list.add(1, “Java”); printList(list); } public static void printList(List list){ for(Object obj:list){ String str=(String)obj; System.out.println(obj); } } } 要求: 1) 把//1 处的代码补充完整,要求输出list 中所有元素的内容 2) 写出程序执行的结果Hello java Learn World 3) 如果要把实现类由ArrayList 换为LinkedList,应该改哪里?ArrayList 和LinkedList 使用上有什么区别?实现上有什么区别? 实验13 集合框架与泛型 一、实验目的和要求 1. 了解Java集合框架的接口和实现类 2. 理解泛型类、泛型接口、泛型方法的特点 3. 掌握List src) {...}> history = new ArrayList
> ();
《集合框架及泛型》上机实践内容
java泛型详解
实验十 泛型与集合框架
JAVA实验报告-集合框架与泛型机制
JAVA实验报告-集合框架及泛型机制
Java泛型详解
实验6 泛型与集合框架_附答案
java泛型详解
学号姓名--集合框架与泛型实验报告
泛型与集合框架
java集合框架(习题与答案)资料
实验13集合框架与泛型实验报告