Object-Oriented Programming in Oberon-2 Hanspeter Mossenbock Object-Oriented Programming in Oberon-2 Foreword by Niklaus Wirth Translation by Robert Bach Springer-Verlag Berlin Heidelberg New York London Paris Tokyo Hong Kong Barcelona Budapest Prof. Dr. Hanspeter M6ssenb6ck Institut fur Computersysteme ETH-Zentrum, CH-8092 Zurich With 104 Figures Title of the Original German Edition: Objektorientierte Programmierung in Oberon-2 © Springer-Verlag Berlin Heidelberg 1993 ISBN-13: 978-3-540-56411-9 e-ISBN-13: 978-3-642-97479-3 001: 10.1007/978-3-642-97479-3 This work is subject to copyright. All rights are reserved, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other way, and storage in data banks. Duplication of this publication or parts thereof is permitted only under the provisions of the German Copyright Law of September 9,1965, in its current version, and permission for use must always be obtained from Springer-Verlag. Violations are liable for prosecution under the German Copyright Law. Library of Congress Cataloging-in-Publication Data Mossenbock, Hanspeter, 1959- (Objektorientierte Programmierung in Oberon-2. English) Object-oriented programming in Oberon-2 1 Hanspeter Mossenbock; foreword by Niklaus Wirth; translation by Robert Bach. p. cm. Translation of: Objektorientierte Programmierung in Oberon-2. Includes bibliographical references and index. 1. Object-oriented programming. 2. Operating systems (Computers) 3. Oberon. I. Title. QA76.64.M67 1993 005.13' 3-dc20-93-10033 CIP © Springer-Verlag Berlin Heidelberg 1993 Cover Design: Konzept & Design, I1vesheim Typesetting: Camera-ready by author Itranslator Exposed by Text & Grafik B.ES., Heidelberg 33/543210-Printed on acid-free paper Foreword Without a doubt the idea of object-oriented programming has brought some motion into the field of programming methodology and enlarged the set of programming languages. Object-oriented programming is nothing new-it first arose in the sixties. The motivation came from the simulation of discrete event systems. The concept first manifested itself in the language Simula 67. It took nearly two decades for the method to gain impetus, and today object-oriented programming is an important concept and a powerful technique. Meanwhile, we can even speak of an over reaction, for the concept has become a buzzword. But buzzwords always appear where there is the hope of exploiting ill-informed clients because they see the new approach as the solution to all their problems. Thus object-oriented programming is often hailed as a panacea. And so the question is justified: What is really behind it? To let the cat out of the bag: There is more to object-oriented programming than merely putting data as objects in the fore ground, instead of algorithms to which the data are subject. It is more than purely an alternative view of programmed systems. To identify the essence of object-oriented programming, is the subject of this book. This is a textbook that shows in a didactically skillful way which concepts and constructs are new, where they can be employed reasonably, and what advantages they offer. For, not all programs are automatically improved by merely recasting them in an object-oriented style. On the contrary, the new method can only be applied sensibly where complex data structures are present. It would be unwise to prematurely discard the conventional view. It is to the author's credit that he introduces the concepts of object-oriented programming in a constructive way, demonstrates them in an evolutionary manner, and uses suitable examples to show how these concepts can be employed judiciously. The pro- vi Foreword gramming language Oberon-2 provides an excellent foundation because it adds only the few typically object-oriented concepts to those of conventional procedural programming but no more. The reader should always be aware that not the language but the methodology and discipline constitute the essential concern of the book. The language only serves the purpose of formulation in a clear and concise manner. We speak of a language supporting a method; Oberon-2 supports object-oriented programming. The object-oriented paradigm holds so much promise especi ally for complex systems, because the technique of object-oriented programming makes it possible to create modular systems that are truly extensible. By extensible we mean that not only new opera tions can be added that build on old ones, but that the same is true for data types and their instances. These comments indicate that object orientation comes to full fruition only when combined with modularity and strict typing of data. This book is a well-organized introduction to this new field. It is obvious that the author draws on a wealth of experience gained in years of intensive work in the area and in successful teaching. The book is an enrichment for anyone interested in modern pro gramming techniques. Niklaus Wirth, Zurich, 1993 Preface Object-oriented programming (OOP) has become a buzzword that is prominently displayed in numerous journals and advertise ments. What is OOP all about? Is it merely a marketing fad, or does it really denote something new and useful, perhaps even a new panacea? To be short, OOP is no panacea. Contrary to the claims made by some vendors, it does not make programming a trivial task. OOP requires a sizable portion of ability and experience-perhaps even more than traditional programming techniques do. However, OOP definitely has its strengths: it often permits more elegant solu tions than are possible with conventional techniques; it promotes modularity and thus readability and maintainability of programs; and it contributes to the extensibility and reusability of software. This book is aimed at students of computer science as well as at practitioners who want to gain a perspective on new software development methods. Since more and more languages are being extended to include object-oriented features, this book also addresses programmers who want to make better use of these new features. The goal of this book is to convey the fundamentals of OOP, namely classes, inheritance and dynamic binding. The emphasis is on the concepts rather than on the specifics of a particular pro gramming language. In addition, readers should learn to determine for which problems OOP is most suitable, and which problems would be better solved with conventional means. Object-oriented programming is programming in the large. Although its principles can be explained on the basis of small examples, wider reaching examples are necessary in order to convey the power and elegance of this technique. This is precisely what is missing in most books on the subject. Chapter 11 thus presents the design and implementation of an adequately large viii Preface system, including source code, in order to drive home the ideas behind object-oriented programming. The examples in this book are not coded in any of the widespread languages such as Smalltalk or c++. Instead, Oberon-2, a language in the tradition of Pascal and Modula-2, was selected: The reason for this choice is that Oberon-2 is more compact than most of the other object-oriented languages; in fact, it is even smaller than Pascal, which makes it possible to master the lan guage quickly. Object-oriented elements are smoothly integrated into the language without displacing proven constructs such as records, arrays and procedures. Once the reader has understood the concepts presented in this book, it should be easy to transfer them to any other language. However, if the reader takes a liking to Oberon-2, the Oberon System, complete with compiler, editor and several other tools, can be obtained at no charge. Implementations are available for several platforms (see Appendix D). The case study printed in Chapter 11 is also available as source code. The Oberon System was developed by Professors Niklaus Wirth and Jiirg Gutknecht 1985-1987 at ETH Zurich [WiG92]. It consists not only of the Oberon language, but also of an operating system with the same name. The design of Oberon reflects the experience of the man who developed Algol W, Pascal and Modula-2. In Oberon-2, the author of this book added several extensions to the Oberon language that make it more suitable for object-oriented programming. This book is neither a general introduction to programming nor a handbook for Oberon-2; these tasks are covered by other texts [ReW92, Rei91]. The reader is assumed to be familiar with an imperative language such as Pascal or Modula-2. Chapter 2 explains Oberon-2 only enough to enable comprehension of the examples in this book. Appendix A contains the complete language definition. I want to express both gratitude and admiration for the two designers of Oberon for their elegant design of the operating system and the language, as well as for the ergonomic and efficient implementation that makes working with Oberon a pleasure. lowe many of the examples to my assistants, Robert Griesemer, Clemens Szyperski and Josef Tempi. Josef TempI also contributed valuable ideas for Oberon-2. Preface ix Last but not least, I want to thank Prof. Peter Rechenberg, Prof. Jorg R. Muhlbacher, Dr. Martin Reiser, Dr. Gunther Blaschek, and Dr. Erich Gamma for their careful reading of the manuscript and for their numerous suggested improvements. Zurich, 1993 Hanspeter Mossenbock Contents 1 Overview ............................................. '" ....................... ,. ................. 1 1.1 Procedure-Oriented Thinking .............................................. 1 1.2 Object-Oriented Thinking ..................................................... 2 1.3 Object-Oriented Languages .................................................. 3 1.4 How OOP Differs from Conventional Programming ...... 6 1.5 Classes as Abstraction Mechanisms .................................... 9 1.6 History of Object-Oriented Languages ............................. 11 1.7 Summary ............................................................................... 12 2 Oberon-2 ......................................................................................... 13 2.1 Features of Oberon-2 ........................................................... 14 2.2 Declarations .......................................................................... 14 2.3 Expressions ........................................................................... 16 2.4 Statements ............................................................................. 18 2.5 Procedures ............................................................................. 19 2.6 Modules ................................................................................. 21 2.7 Commands ............................................................................ 25 3 Data Abstraction ............... '" ...... , .................................... '" ........... 29 3.1 Concrete Data Structures .................................................... 29 3.2 Abstract Data Structures ..................................................... 32 3.3 Abstract Data Types ............................................................ 35 4 Classes .................................. '" ........................................................ 39 4.1 Methods ....................................................... ,. ........................ 39 4.2 Classes and Modules ........................................................... 43 4.3 Examples ............................................................................... 44 4.4 Common Questions ............................................................. 47 xii Contents 5 Inheritance ..................................................................................... 49 5.1 Type Extension ..................................................................... 49 5.2 Compatibility of a Base Type and its Extension .............. 52 5.3 Static and Dynamic Type .................................................... 55 5.4 Run-Time Type Checking ................................................... 57 5.5 Extensibility in an Object-Oriented Sense ........................ 59 5.6 Common Questions ............................................................. 62 6 Dynamic Binding ......................................................................... 63 6.1 Messages ............................................................................... 63 6.2 Abstract Classes ................................................................... 65 6.3 Examples ............................................................................... 67 6.4 Message Records .................................................................. 70 6.5 Common Questions ............................................................. 74 7 Typical Applications .................................................................... 75 7.1 Abstract Data Types ............................................................ 75 7.2 Generic Components ........................................................... 77 7.3 Heterogeneous Data Structures ......................................... 82 7.4 Replaceable Behavior .......................................................... 87 7.5 Adaptable Components ...................................................... 89 7.6 Semifinished Products ......................................................... 92 7.7 Summary ............................................................................... 94 8 Useful Techniques ....................................................................... 95 8.1 Initialization of Objects ....................................................... 95 8.2 Extending a System at Run Time ....................................... 97 8.3 Persistent Objects ................................................................. 99 8.4 Wrapping Classes in Other Classes ................................. 104 8.5 Extensibility in Multiple Dimensions ............................. 105 8.6 Multiple Inheritance .......................................................... 108 8.7 Models and Views ............................................................. 112 8.8 Iterators ............................................................................... 116 8.9 Modifying Inherited Methods ......................................... 118 9 Object-Oriented Design ............................................................ 121 9.1 Functional Design .............................................................. 121 9.2 Object-Oriented Design ..................................................... 122 9.3 Identifying the Classes ...................................................... 123 9.4 Designing the Interface of a Class ................................... 128 9.5 Abstract Classes ................................................................. 131 9.6 Relationships between Classes ......................................... 132 9.7 When to Use Classes .......................................................... 135 9.8 Common Design Errors .................................................... 137