Inheritance, Generics and Binary Methods in Java
Herencia, Geneacute;ricosy Meacute;todos Binarios en Java
Mariacute;a Luciacute;a Barroacute;n-Estrada (1) and Ryan Stansifer (2)
- Departamento de Sistemas y Computacioacute;n
Instituto Tecnoloacute;gico de
Culiacaacute;n Culiacaacute;n, Sin. CP 80220 Meacute;xico
- Computer Science Department Florida Institute of Technology University Blvd.. Melbourne, FL 32901
mbarron@fit.edu, ryan@cs.fit.ed
Abstract
Java has adopted a mechanism to support parameterized types that will be available in the next major release. A draft specification to add generics to the JavaTM Programming Language was published two years ago [1] and a new version of it in June 23, 2003 [2]. An extension of the type system based on F-bounded quantification is proposed. A binary method is a method that has one or more parameters of the same type as the object that receives the message. F-Bounded polymorphism and binary methods canrsquo;t be combined smoothly in object-oriented languages with nominal subtyping and single dispatch [3].
In this paper, we address some problems that can arise when binary methods are needed in parameterized classes and interfaces in the implementation of a Java program.
Keywords: Binary methods, Inheritance, Java, Parameterized types.
Resumen
El lenguaje de programacioacute;n Java ha adoptado un mecanismo para definir tipos parametrizados, el cual estaraacute; disponible para los usuarios en la proacute;xima versioacute;n de su compilador. La primera especificacioacute;n formal para incluir geneacute;ricos en Java fue publicada hace dos antilde;os y una nueva versioacute;n el pasado mes de Junio del 2003. En esta especificacioacute;n, se propone extender el sistema de tipos basandose en el sistema de cuantificacioacute;n restringida F (F-Bounded quantification) con el fin de soportar directamente polimorfismo parameacute;trico en Java. Un meacute;todo binario en aquel que contiene uno o maacute;s paraacute;metros del mismo tipo del objeto que recibe el mensaje. El polimorfismo basado en el sistema de restriccioacute;n F y los meacute;todos binarios no pueden ser combinados en forma sencilla en aquellos lenguajes de programacioacute;n orientados a objectos que contienen un sistema de tipos nominal y basan la seleccioacute;n del metodo a ejecutar solo en el tipo del objeto que recibe el mensaje.
En este articulo, se presentan algunos problemas que aparecen en la implementacioacute;n de programas en Java cuando es necesario definir clases e interfaces parametrizadas.
Palabras clave : meacute;todos binarios, herencia, Java, tipos parametrizados, geneacute;ricos.
- Introduction
The addition of parametric polymorphism to the Java Programming Language has been under consideration for several years. Many proposals were presented and finally a draft specification to add generics to the Java programming language [1] was released in April 2001. This specification is an evolution of an early proposal called Generic Java (GJ), which is described in [4]. A prototype implementation of the Java compiler that supports generics, as described in the draft specification, is available for developers who want to start writing generic code.
Java is being updated to incorporate some new elements in the language like parameterized types and type variables to support the creation of generic code (classes, interfaces, and methods). The requirements specify that no changes to the JVM should be done to support these new features.
The technique used to translate generic code into Java bytecode is called type erasure. In this technique, all the type parameters defined in the parameterized type are replaced by type Object in order to make them compatible with existing class libraries. When a client uses a parameterized type to define instances of it, in the translation process, the compiler will insert some bridge methods and coercions, which are guaranteed not to fail at execution time.
In Java when the generic idiom is used to implement generic code some coercion operations are required in client code to ensure type safety. These operations increase the execution time and the class file size. The translation approach used in Generic Java to translate parameterized types improves neither performance nor class file size. When a parameterized type is translated the class file obtained is exactly the same as the one implementing the generic idiom. Client code does not explicitly require coercions but they are automatically inserted in the translation process increasing execution time and class file size. If performance efficiency is important, we could get rid of cast operations in client code using a hand specialized code1 for each particular type. Another fact of this approach is that primitive types cannot be used to create instances of parameterized types because they are not derived from type Object. The translation of parameterized types erases type parameters, which makes the types not available at run-time.
Generic code can be unconstrained or constrained. There are several mechanisms to constraint polymorphism in objectoriented languages. The one proposed by Cardelli and Wegner [5] allows expressing the idea that a function can be applied to all types that are a subtype of another. This mechanism is not powerful enough to express all kind of constraints like the ones needed for recursive type definition. It is possible to define type parameters with recursive constraints using F-bounded quantification [6].
The implementation of generics in Java as described in the draft specification document is based on the F-bounded mechanism. When a type is defined to be constrained recursively, it is not possible to reuse code through inheritance because subclasses can not redefine recursive bounds to themselves and so they can not
剩余内容已隐藏，支付完成后下载完整资料
Java中的继承、泛型和二进制方法
Mariacute;a Luciacute;a Barroacute;n-Estrada (1) and Ryan Stansifer (2)
- Departamento de Sistemas y Computacioacute;n
Instituto Tecnoloacute;gico de
Culiacaacute;n Culiacaacute;n, Sin. CP 80220 Meacute;xico
- Computer Science Department Florida Institute of Technology University Blvd.. Melbourne, FL 32901
mbarron@fit.edu, ryan@cs.fit.ed
文摘
下一个版本中Java已经采用了一种新的机制来支持参数化类型。在两年前发表的草案中将规范泛型添加到java编程语言中[1]，它的新版本也将在2003年6月23日发布[2]，其中提出了基于F-bounded量化的一个扩展类型系统。一个二进制方法是有一个或多个参数且对象类型相同的接收消息的方法。F-Bounded多态性和二进制方法不能在面向对象语言中与标称子类型和单一分派顺利结合[3]。
在本文中,我们解决一些在Java程序的实现过程中，参数化的类和接口需要用到二进制方法时可能出现的一些问题。
关键词:二进制方法、继承、Java参数化类型。
摘要
Java编程语言可以通过parametrizados机制来定义类型,这将成为下一个版本中用户的编译器。第一次正式的规范,是在两年前发表通用Java和2003年6月发布一个新版本的时候。在此规范之中，,建议延长基于定量F-Bounded F(quantification)的basandose类型系统，从而直接支持Java的参数多态性。这种二进制中,包含一个或多个类型相同的参数对象,方便接收消息。在那些简单的面向对象编程语言中，由于系统的多态性方法限制和无法综合二进制形式，只含有一个系统或者基于标称类型的选择方法实施对象的类型中只接收到的信息。
这篇文章里,面对实施方案中出现的一些问题,必要时会用到Java类和parametrizadas接口定义。
关键词:Java二进制方法、继承、类型、parametrizados接口定义、仿制。
1.简介
已经考虑了好几年在Java编程语言中添加参数多态性，广泛学者提出了很多的建议,最终在2001年4月，草案添加规范泛型Java编程语言[1]，在进化的早期这个规范被称为泛型Java(GJ)[4]。如规范草案所述,在Java编译器的原型
实现中支持泛型,可供开发人员开始编写想要的通用代码。
现在也在更新Java语言中的一些新元素包括参数化类型和类型变量，使其支持创建泛型代码(类、接口和方法)，如果指定需求没有变化，JVM应该支持这些新特性。
类型擦除是一种用于将通用代码转化为Java字节码的技术。在这个技术中,参数化类型中定义的所有类型参数、类型对象被取代,以使它们与现有的类库兼容。当客户端使用参数化类型来定义实例时,在翻译过程中,编译器会插入一些桥方法和强制转换,这保证不会在执行程序时失败。
在Java中,当通用语言是用来实现通用的代码时，需要强制操作客户端代码以确保类型安全，但这些操作增加了执行时间和类文件的大小，而泛型Java中使用的翻译方法将改善参数化类型的翻译性能和类文件的大小。当一个参数化类型转换后获得的类文件和实现通用语言的代码完全一样时，客户机代码明确不需要强制操作，但它们会自动插入到翻译过程中来增加执行时间和类文件的大小。如果注重程序的性能和效率,我们可以摆脱操作客户端代码而为每个特定类型代码专门使用一只手。这种方法的另一个事实是,原始类型不能用于创建参数化类型的实例,因为它们不是来自类型对象。参数化类型在翻译的时候会擦除那些在运行时不可用的类型参数。
通用代码可以无约束或限制，但是有几种机制来约束面向对象语言中的多态性。Cardelli和韦格纳提出了一个可以适用于所有类型的子类型的表达函数[5]，但是这种机制用来表达各种约束所需的递归类型定义还不够强大，递归类型定义参数约束可以使用F-bounded量化[6]。
草案的规范文档中实现泛型Java的相关描述都是基于F-bounded机制。当一个递归类型的定义受到限制时,不可以通过继承重用代码,因为子类不能重新定义递归的边界,所以他们不能用于创建参数化类型的实例，但是他们可以继承父类中定义的约束。举一个经典的例子,当一个递归类型参数需要二进制方法来实现的时候，需要判断约束的类型对象中是否使用二进制方法,程序员有责任编写代码来验证该对象的类型。
代码重用是面向对象语言的主要特色之一。在Java中使用F-bounded多态性，一个类的定义不允许使用继承来生成子类的实例,可以使用参数化的类型。必须使用另一种方法是为了能够使创建的子类定义自己的界限并且允许他们重用超类中定义的一些代码和使用子类创建参数化类型的实例。
本文的目的是展示一些例子,探索使用泛型约束的二进制方法。我们列举了一些情况，如当一个程序员需要创建一个有F-bound约束的子类时,想使用这个子类来创建参数化类型的一个实例；我们也显示了一些可能出现的执行时间的问题。
2.术语
二进制的方法：一个二进制方法是包含一个或多个参数相同类型的接收消息的对象。
有界的多态性：有界的抽象类型，它允许一个类定义一个函数,其结果类型取决于该类且适用于所有类型的子类型的约束,。
抗变性：抗变性是一种关系,抓住了子类型化的关系，它意味着某一特定类型的变化是相反的类型层次结构。
泛型约束：用作类型参数的类型受到一些其他类型的限制。
协方差：协方差是一个代码专业化的关系特征，这种特殊类型层次结构的变化是平行的。
F-Bounded多态性：用递归扩展类型来概括系统。
包容多态性：一个对象可以被视为属于多个类。
继承：继承是从现有类派生新类或接口的一种机制。
接口：一个接口中声明的包含常量和抽象方法所支持的类,用来实现该接口。
多重方法：多重方法也称为通用函数，方法可以不止属于一个类，它们可以派生出基于类型的所有参数。
多分派：多个执行调度方法的选择取决于所有消息的类型参数，不仅是接收器。
参数多态性：统一的工作类型，一个多态函数有能力接收的类型参数决定于这个函数的应用程序的类型参数。
单一调度：单一调度方法的选择只取决于接收消息的对象的类型。
子类型化：子类型化允许在任何地方使用子类型值预计其超类型的值。
无约束泛型：可以使用任何类型的类型参数的实例化，没有限制
Java是一种单一调度的强制类型的面向对象语言。它提供了包容多态性,并很快将提供参数多态性。很快将在元素集合的创建中允许类代表一个参数化类型和类型参数T。
3.问题描述
我们的目标是实现一个可用于创建有序列表的元素集合的OrderedList类,,了解分别代表等于、小于等于和大于等于的eq、le和ge消息,,。列表的元素必须公开，所以方法成员都可以使用我们正在寻找的元素列表中方法相同的消息，当在一个有序列表中插入一个新元素时需要用到le消息。
我们检验实现泛型类的操纵元素的有序列表的三种方式,。在实现的过程中，我们必须遵守Java编程语言的规则[7]及将规范泛型添加到语言中即泛型Java[2]的规则。
o无约束genericity：通用语言是用来实现这个解决方案。4.1节解释了为什么这个解决方案不合适用来解决这个问题。
o Genericity简单数据绑定：该方法限制了参数化类型的实例中使用的参数的类型。另一种类型的参数类型必须是有界的,以确保它实现所需的一些方法。在4.2节中提出了使用简单数据绑定的解决方案。
o Genericity递归绑定：使用递归的绑定类型参数确保所需的相同类型的参数接收消息的对象。4.3节给出了一个使用递归的解决方案。
- 实现
4.1 无约束Genericity
有时它可以使用对象编写通用代码来实现它，这个实现是使用通用语言。例如我们可以实现一个通用的堆栈类操纵对象或一个通用的列表链接对象。这些泛型类不需要有一个特定的方法，他们是不受限制的。在我们的示例中,为了定义OrderedList类,我们需要对有比较元素的(le,ge,eq)方法进行约束。
对象包含等于方法的定义，这种方法允许对象之间的进行值比较。
boolean equals (Object elem);
所有的类重写方法必须遵守所有的语言规则,它实现了一个等价关系:它是反射性的,对称的,传递和一致的[7]。
使用对象,我们可以比较两个对象发送的消息是否平等，但小于等于和大于等于两个比较比较需要在我们的例子中实现,并不存在于对象不能被添加到的情况。
4.2 Genericity简单数据绑定
在我们的例子中定义了一个名为Orderable的接口,用来声明方法，定义这个接口的典型代码如下所示
interface Orderable {
boolean eq (Orderable other);
boolean le (Orderable other);
hellip;
}
我们声明了一个OrderedList类的类型参数T，T与类Orderable绑定。这意味着，用于创建有序列表中参数化类型的实例的类必须实现Orderable接口。
class OrderedList lt;T implements orderrablegt;{
T listElem;
hellip;
void insert( T elem) { hellip; if (listElem.le(elem)) hellip; }
boolean member (T elem) {
hellip; if (listElem.eq(elem)) hellip; }
}
4.2.1 定义一个客户端类
我们现在定义一个Point类，我们将使用类Point创建OrderedList参数化的类的一个实例。我们的类Point必须实现Orderable这个接口，且符合OrderedList的类型参数中定义的约束。
class Point implements Orderable {
int x,y;
boolean eq (Orderable other) {
// we need to cast other to Point before using it
// if other is an instance of Point compare x and y
// what to do if other is a subtype of Point?
// what to do if other is not an instance of Point?
}
}
在类Point的实现方法中eq方法必须具有相同的签名。在Orderable接口的声明中，定义的参数不能变化,因为Java的类型系统为了保存类型安全不允许专门化。在这种情况下,程序员有责任确保接收到的参数的类型是预计的或引发了一个异常。
4.2.2 派生类
我们定义另一个来自Point类的ColorPoint类，这个新类扩展定义Point类并覆盖了所有的方法,用来操纵ColorPoint对象。这些方法的签名不能修改，ColorPoint类为Point类的子类型。
class ColorPoint extends Point{
String c;
hellip;
boolean eq (Orderable other) {
// we need to cast other to ColorPoint before using it
// compare x, y and c variables
// what to do if other is not an instance of ColorPoint?
}
}
不容易正确实现Orderable接口中的所有方法。在Orderable中定义的类型参数的方法是在Orderable中的。实现Orderable的每个类必须注意接收的对象类型，避免出现在编译时没有检测到可能发生的问题。举一个例子说明，假设有一个rectangle对象从一个类中创建,这不是来自Point,并实现了接口Orderable，还有一个Point对象创建的point，它可能使用对象rectangle和point,因为他们都有平等的方法接收一个公开类型作为Orderable参数。
4.2.3 使用参数化类型
我们可以创建使用Point和OrderedList ColorPoint类的实例。
OrderedListlt;Point
剩余内容已隐藏，支付完成后下载完整资料
资料编号：[153870]，资料为PDF文档或Word文档，PDF文档可免费转换为Word
以上是毕业论文外文翻译，课题毕业论文、任务书、文献综述、开题报告、程序设计、图纸设计等资料可联系客服协助查找。
