Modules andObject-Oriented Programming

Modules (Packages)

Programming in the LargeInformation hiding• Limit the ways in which one part of the

program can access another.• Allow proprietary software to be called

without the technique being published.Separate compilation.

Separate compilation and linking

Compiler produces • Import table: List of imported symbols• Export table: List of exported symbols• Relocation table: List of “absolute” addresses

used in code.Imported symbol in code compiles into

reference in import table.Absolute address in code is listed in relocation

table.

Two-pass linker

Pass 1: Find absolute addresses for all static entities (objects and code). Extract library functions used.

Pass 2: Replace all imported and “absolute” addresses in compiled code with true absolute addresses.

Package declaration (Ada)

package Stacks is type Stack is private; procedure Push(S: in out Stack; X: in out Integer) procedure Pop(S: in out Stack; X: out Integer) function “=“(S,T: Stack) return Boolean; (from Barnes, Programming in Ada-95)

privateMax: constant := 100;type IntegerVector is array(Integer range <> of

Integer)type Stack is record S: IntegerVector(1 .. Max); Top: Integer range (0 .. Max) := 0; end record;end;

Package body

package body Stacks isprocedure Push(S: in out Stack; X: in Integer) is begin S.Top := S.Top+1; S.S(S.Top) := X; end Pushetc.

Package use

declare use Stacks; St : Stack;begin Push(St,N); … Pop(St,M);end;

Information hiding in packages

type Stack: Fields Stack.S and Stack.Top are externally visible.

type Stack is private: Only assignment, =, and /= are visible.type Stack is limited private: Only visible

functions are those declared so by user.

Object-oriented programming

• Information hiding as in modules• Viewpoint shift. A module is just a hunk

o’ code. An object is an active data structure.

• Class hierarchy and inheritance• Dynamic method binding

Let X be an object of class C with method M. Is “X.M(N)” anything more than syntactic sugar for “C_M(X,N)”?

• Yes, with dynamic method binding.• With inheritance, syntactic sugar is not

to be sneezed at.

Class definition

• Data members (fields)• Subroutine members (methods)• Base class and derived class.

Class definition in Javapublic class Rectangle { private float xSpan,ySpan; public Rectangle() { this(1.0,1.0); } public Rectangle(float x, float y) { setRect(x,y); } public void setRect(float x, float y) { xSpan=x; ySpan=y; }public float xTop() { return xSpan; }public float xBot() { return 0.0; } … }

Derived class in Javapublic class locatedRectangle extends

Rectangle { private float xL, yL; // lower left corner public locatedRectangle() { setCorner(0.0,0.0); } public void setCorner(float xa, float ya) { xL = xa; yL = ya; } public float xTop() { return xL+xSpan; } public float xBot() { return xL; } … }

Creating an object in Java

{ locatedRectangle R, Q; // declaration float X; R = new locatedRectangle(); Q = R; X = R.xTop(); }/* R and Q are pointers to the same heap

object. Constructors are invoked in order from superclass to subclass.*/

Dynamic method binding

Rectangle A;locatedRectangle R1,R2;R1 = new locatedRectangle(); A = R1; // Cast from sub to superR2 = (locatedRectangle) A; // downcast… A.xTop() …; // dynamic method: uses // xTop() for locatedRectangle // not for Rectangle

“final” classes and methods

A class declared “final” cannot be have a derived class.

A method declared “final” cannot be overridden.

Any declared use of a final class or method can be resolved at compile time, and saves the overhead of dynamic disambiguation.

Dynamic method binding: Implementation in vtables

Method access through vtables

Rectangle A;… A.xTop() … compiles to Follow A to the heap object. Follow vtable pointer to vtable. Follow vtable[1] to code for A.xTopIn all classes derived from Rectangle, xTop is

vtable[1].

Abstract classes

A method with no body is abstract.A class with an abstract method is

abstract. Abstract classes cannot have objects;

they can only have derived classes.Used to provide a “hook” for dynamic

method binding.

Example: Apply a function to every member of an array.

We will discuss four solutions to this:• Abstract classes in OOP• Interfaces in OOP• Generics• Functional parameters

Example: applier.java

abstract class ArrayApplier {public abstract int f(int x);public void ApplyToArray(int[] A, int[] B) { for (int i=0; i < A.length; i++) B[i] =f(A[i]); } }class applyIncr extends ArrayApplier { public int f(int i) { return i+1; } }

Using the abstract class

public class applier {public static void main(String args[]) {int A[] = new int[] {1,2,3}; int B[] = new int[3];applyIncr Incr = new applyIncr();applyDouble Doub = new applyDoub();Incr.ApplyToArray(A,B);Doub.ApplyToArray(A,B); } }

Interfaces• Interface I: A collection of abstract methods• Class C implements I, instantiates Q.• Method M declares a variable of type I.• M is called with object of type C. M’s call to X.Q uses

C’s definition of Q.interface I { public void Q(); }class C implements I { public void Q() { Body of C’s Q }}public void M(I X) { … X.Q(); … } C P = new C(); // In some other method M(P);

Multiple implementations

A class can extend only one base class, but may implement many interfaces.

Some say that this achieves a kind of multiple inheritance.

Example: applier2.java

interface IntFun { public int f(int x); }class Incr implements IntFun { public int f(int i) { return i+1; }public class applier2 {public static void ApplyToArray(IntFun Q, int[] A, int[] B) { for (i=0; i<A.length; i++) B[i]=Q.f(A[i]);}

applier2.java (cntd)

public static void main(String args[]) {int A[] = new int[] { 1,2,3 };int B[] = new int[3];Incr Inc = new Incr();ApplyToArray(Inc,A,B):} } // end applier2

TestVisitor.java: Features

• Hiding of data fields: Standard OOP practice. Small methods are compiled inline. E.g. x.getChild() is compiled as if it were x.child.

• Dynamic method biding of (x.getChild()).accept to A’s accept or B’s accept.

• “Visitor” design pattern for coding

TestInterface.java: Features

• Use of interface allows different visitors over the same data structure. Different visitors may process nodes differently or may choose different paths to traverse.

• Replace visitA and visitB by overloading visit. Doesn’t affect functionality or expressivity. Elegant or confusing?

Point of the visitor design

A data structure with multiple types. Here A and B. More realistically, an expression tree with additive nodes, multiplicative nodes etc.

Various operations to do on this data structure. Each operation acts differently on different types. Here MyVisitor and DumbVisitor. More realistically, evaluate, pretty print, optimize, search, etc.

You don’t want to build the code for the operations into the data structure types.

You don’t want to write in the operation if (x instanceOf A) processA((A) x) else if (x instanceOf B) processB((B) x) else …which is ugly, type unsafe, and slow.

Overloading and Inheritance

The type of the formal parameter must be a supertype of the actual parameter.

A method name may be overloaded with parameters that are subtypes of one another. (See TestOverload.java)

If so, use the most specific match.If “most specific match” is ambiguous,

compiler error. (TestOverload1.java)

C++ OOP vs. Java

• Objects can be stack variables• Static method binding is the default. To get

dynamic binding, declare method as “virtual”.• Multiple inheritance: A derived type may

extend several base types. Complicated rules for constructors etc. If method call is ambiguous, error. Dynamic binding is difficult.