1 Object Oriented Programming Daniel Albu Based on a lecture by John Mitchell Reading: Chapter 10

Object-oriented programming uPrimary object-oriented language concepts Dynamic Lookup Encapsulation Inheritance Subtyping uProgram organization Work queue, Geometry program, Design Patterns uComparison Objects as closures?

Objects uAn object consists of hidden data instance variables, also called member data hidden functions also possible public operations methods or member functions can also have public variables in some languages uObject-oriented program: Send messages to objects hidden data method 1 msg 1... method n msg n

Object-Orientation uProgramming methodology Organize concepts into objects and classes Build extensible systems uLanguage concepts dynamic lookup encapsulation subtyping allows extensions of concepts inheritance allows reuse of implementation

Dynamic Lookup u In object-oriented programming, object  message (arguments) code depends on object and message uIn conventional programming, operation (operands) meaning of operation is always the same If we need a certain operation to be able to perform various commands according to its input, we need to use, for example, the switch-case structure.

Example uAdd two numbers x  add (y) different add if x is integer, complex uConventional programming add (x, y) function add has fixed meaning Very important distinction: Overloading is resolved at compile time, Dynamic lookup at run time

Language concepts u“dynamic lookup” different code for different object integer “+” different from real “+” uencapsulation usubtyping uinheritance

"Abstraction and encapsulation are complementary concepts: abstraction focuses on the observable behavior of an object... encapsulation focuses upon the implementation that gives rise to this behavior... encapsulation is most often achieved through information hiding, which is the process of hiding all of the secrets of object that do not contribute to its essential characteristics." -Grady Booch in Object Oriented Analysis and Design (one of the developers of UML)

Encapsulation uBuilder of a concept has detailed view uUser of a concept has “abstract” view uEncapsulation separates these two views Implementation code: operate on representation Client code: operate by applying fixed set of operations provided by implementer of abstraction message Object

Language concepts u“Dynamic lookup” different code for different object integer “+” different from real “+” uEncapsulation Implementer of a concept has detailed view User has “abstract” view Encapsulation separates these two views uSubtyping uInheritance

Subtyping and Inheritance uInterface The external view of an object uSubtyping Relation between interfaces uImplementation The internal representation of an object uInheritance Relation between implementations

Object Interfaces uInterface The messages understood by an object uExample: point x-coord : returns x-coordinate of a point y-coord : returns y-coordinate of a point move : method for changing location uThe interface of an object is its type.

Subtyping uIf interface A contains all of interface B, then A objects can also be used B objects. uColored_point interface contains Point Colored_point is a subtype of Point Point x-coord y-coord move Colored_point x-coord y-coord color move change_color

Inheritance uImplementation mechanism uNew objects may be defined by reusing implementations of other objects uDue to inheritance, if we update / fix / change the original object, the changes are also rolled to objects inheriting from it.

Example class Point private float x, y public point move (float dx, float dy); class Colored_point private float x, y; color c public point move(float dx, float dy); point change_color(color newc); uSubtyping Colored points can be used in place of points Property used by client program uInheritance Colored points can be implemented by reusing point implementation Technique used by implementer of classes

OO Program Structure uGroup data and functions uClass Defines behavior of all objects that are instances of the class uSubtyping Place similar data in related classes uInheritance Avoid reimplementing functions that are already defined

Example: Geometry Library uDefine general concept shape uImplement two shapes: circle, rectangle uFunctions on implemented shapes center, move, rotate, print uAnticipate additions to library

Shapes uInterface of every shape must include center, move, rotate, print uDifferent kinds of shapes are implemented differently Square: four points, representing corners Circle: center point and radius Things like size and circumference are calculated in a different way in these 2 shapes and thus need to be implemented separately and cannot be inherited.

Subtype hierarchy Shape CircleRectangle uGeneral interface defined in the shape class uImplementations defined in circle, rectangle uExtend hierarchy with additional shapes

Code placed in classes uDynamic lookup circle  move(x,y) calls function c_move uConventional organization Place c_move, r_move in move function centermoverotateprint Circlec_centerc_movec_rotatec_print Rectangler_centerr_mover_rotater_print

Example use: Processing Loop Remove shape from work queue Perform action Control loop does not know the type of each shape e.g. we want to reduce the size of all the shapes currently on screen

Example use: Processing Loop Remove shape from work queue Perform action Control loop does not know the type of each shape e.g. we want to reduce the size of all the shapes currently on screen resize(0.5)

Example use: Processing Loop Remove shape from work queue Perform action Control loop does not know the type of each shape e.g. we want to reduce the size of all the shapes currently on screen resize(0.5)

Example use: Processing Loop Remove shape from work queue Perform action Control loop does not know the type of each shape e.g. we want to reduce the size of all the shapes currently on screen resize(0.5)

Example use: Processing Loop Remove shape from work queue Perform action Control loop does not know the type of each shape e.g. we want to reduce the size of all the shapes currently on screen resize(0.5)

Example use: Processing Loop Remove shape from work queue Perform action Control loop does not know the type of each shape e.g. we want to reduce the size of all the shapes currently on screen resize(0.5)

Just make sure that every object you run the resize function on, has it implemented in it

Subtyping - refers to compatibility of interfaces. A type B is a subtype of A if every function that can be invoked on an object of type A can also be invoked on an object of type B. Inheritance - refers to reuse of implementations. A type B inherits from another type A if some functions for B are written in terms of functions of A. So what’s the difference?

Subtyping differs from inheritance Collection Set Sorted Set Indexed Array Dictionary String Subtyping Inheritance

Design Patterns uClasses and objects are useful organizing concepts uCulture of design patterns has developed around object-oriented programming Shows value of OOP for program organization and problem solving

What is a design pattern? uGeneral solution that has developed from repeatedly addressing similar problems. uExample: singleton Restrict programs so that only one instance of a class can be created Singleton design pattern provides standard solution uNot a class template Using most patterns will require some thought Pattern is meant to capture experience in useful form Standard reference: Gamma, Helm, Johnson, Vlissides

Example Design Patterns uSingleton pattern There should only be one object of the given class package { public class Singleton { private static var _instance:Singleton; public function Singleton(lock:SingletonLock) { } public static function getInstance():Singleton { if (_instance == null) _instance = new Singleton(new SingletonLock()); return _instance; } class SingletonLock { }

Example Design Patterns uVisitor design pattern Apply an operation to all parts of structure Generalization of maplist, related functions Standard programming solution: –Each element classes has accept method that takes a visitor object as an argument –Visitor is interface with visit() method for each element class –The accept() method of an element class calls the visit() method for its class

Taken from:

Façade Design Pattern uis a structural object pattern, which means it is a pattern related to composing objects into larger structures containing man objects. uImplementation: relatively little actual code uExample: A compiler

Closures as objects? public function Main() { init(); } public function init():void { //create a counter var counter1:Function = newCounter(); trace( counter1() );//1 trace( counter1() );//2 trace( counter1() );//3 var counter2:Function = newCounter(); trace( counter2() );//1 trace( counter2() );//2 trace( counter1() );//4 --> scope of i is still with counter1 } public function newCounter():Function { var i:int = 0; //variable i gets bound into returned anonymous function return function():int { //i is available to the scope of the anonymous function i=i+1; return i; }

History of class-based languages uSimula 1960’s Object concept used in simulation uSmalltalk 1970’s Object-oriented design, systems uC ’s Adapted Simula ideas to C uJava 1990’s Distributed programming, internet uActionScript ’s Adapted Java ideas into Flash

Varieties of OO languages uclass-based languages (C++, Java, …) behavior of object determined by its class uobject-based (Self, JavaScript) objects defined directly umulti-methods (CLOS) operation depends on all operands (Common Lisp Object System)

Summary uObject-oriented design uPrimary object-oriented language concepts dynamic lookup encapsulation inheritance subtyping uProgram organization Work queue, geometry program, design patterns uComparison Objects as closures?

This presentation can be downloaded from: