Seminarsonly.Com

>>

Custom Search

Object-oriented techniques achieve further reusability through the encapsulation of programs and data. The techniques and mechanisms we shall discuss here are primarily concerned with paradigms for packaging objects in such a way that they can be conveniently reused without modification to solve new problems.

Instantiation and Object Classes
Instantiation is perhaps the most basic object-oriented reusability mechanism. Every programming language provides some built-in data types (like integers and floating-point numbers) that can be instantiated as needed. Objects may either be statically or dynamically instantiated. Statically instantiated objects are allocated at compile-time and exist for the duration that the program executes. Dynamically instantiated objects require run-time support for allocation and for either explicit deallocation or some form of garbage collection.

The next step is to provide a way for programmers to define and instantiate their own objects. This can be done by providing the programmer with a facility to define object classes, as is the case in Smalltalk. An object class specifies a set of visible operations, a set of hidden instance variables and a set of hidden methods which implement the operations. The instance variables can only be modified indirectly by invoking the operations. When a new instance of an object class is created, it has its own set of instance variables, and it shares the operations' methods with other instances of its class. A simple example is the class ComplexNumber.

The programmer would define an interface consisting of the arithmetic operations that complex numbers support, and provide the implementation of these operations and the internal data structures. It would be up to the programmer to decide, for example, whether to use a representation based on Cartesian or polar coordinates. An alternative approach to instantiation is to use prototypical objects rather than object classes as the "template" from which new instances are forged.

This is exactly what we do when we make a copy of a text file containing a document composed in a formatting language like TeX ~ or troff: we reuse the structure of the old document, altering its contents, and possibly refining the layout. This approach is useful to avoid a proliferation of object classes in systems where objects evolve rapidly and display more differences than similarities.

<<back