lecture 2

Lecture 2

Object-oriented programming

Definitions of OOP OOP is a programming paradigm,

which utilizes encapsulation, inheritance and polymorphism.

(From standard programming

languages textbook)

Definitions of OOP OOP is a method of implementation in

which programs are organized as cooperative collections of objects, each of which, represents an instance of some class, and whose classes are all members of a hierarchy of classes united via inheritance relationship.

(Grady Booch, Object-oriented analysis and design)

Definitions of OOPOOP is a way of modeling computation which attempts to mimic the way we see the world around us.

Grady Booch on Abstraction

is one of the fundamental ways that we as humans cope with complexity

arises from recognition of similarities between certain objects, situations or processes in the real world

facilitates principle of least astonishment

Grady Booch on Abstraction

denotes the essential characteristics of an object that distinguish it from all other kinds of objects and thus provides crisply defined conceptual boundaries, relative to the perspective of the viewer

captures the entire behavior of some object, no more, no less, and offers no surprises or side effects that go beyond the scope of the abstraction.

Encapsulationpublic class Car { private String serialNumer; private String make; private double tankVolume; private double speed;}

Encapsulationpublic class Car {

// Public section public String getSerialNumber() { return serialNumber; }

public String getMake() { return make; } public double getTankVolume() { return tankVolume; } public double getSpeed() { return speed; }

// Private section private String serialNumer; private String make; private double tankVolume; private double speed;

}

Encapsulation is the process of compartmentalizing the

elements of an abstraction that constitute its structure and behavior; encapsulation serves to separate contractual interface of an abstraction and its implementation.

(from Grady Booch’s Object-oriented analysis and design)

Inheritance Is-a relationship (is kind of)

Dog is a Mammal Professor is (usually) Human Running is an Exercise

Inheritance is about organizing abstractions into hierarchies.

Inheritance At the top of inheritance hierarchy is a base

class.

Typically, a base class would be abstract, meaning it would correspond to a concept, a not to a physical entity. This class would explicitly prohibit you to create instances of itself.

public abstract class Engine {} Implies that Engine myEngine = new Engine();would not compile.

Inheritance

Derived class inherits interface and implementation from the base class.

Inheritance for extension Is when derived class adds functionality to the

base class public class Point { public class ColorPoint

extends Point { public int getX(); public Color getColor(); public int getY(); }}

Another example public class Derived extends Base { public void build() { super.build(); // do some more } }

Inheritance for reuse Is when derived class doesn’t add functionality

to most methods of the base class Sometimes, the designer of a base class may intentionally specify

a method as final.

public class Base { public final void getName() { return sName; } }public class Derived extends Base { public void getName() { // WOULD NOT COMPILE }}

An interface is an expression of pure design, whereas class is a mix of design and implementation.

From Arnold & Gosling 'Java programming language'

public interface IDatabase { public String getName(); public ITable getTable( String name ); public Iterator tables(); public Iterator tableNames();}

public class RelationalDatabase implements IDatabase

public class FileDatabase implements IDatabase

public void setDatabase( IDatabase db ) { if ( db instanceof RelationalDatabase ) { processRelationalDatabase(

(RelationalDatabase)db ); } else if ( db instanceof FilelDatabase ) { processFilelDatabase( (FilelDatabase)db ); } ...} DON’T DO THIS….

class GraphicalTextEditor :

public TextEditor, Component;

public class TextEditor {}public class Component {}

public class GraphicalTextEditor extends TextEditor { public Component getComponent() { return c; }

// Inner class GraphicalTextEditorComponent which takes care

// of the graphical aspect of this text editor. private class GraphicalTextEditorComponent extends Component { } private Component c =

new GraphicalTextEditorComponent();}

AggregationObjects of a class have a reference

(member field) one or more objects of another class

public class Car {…private Engine engine;

}

Object of another class is passed as an argument into a method.

public class PnLCalculator { public static double computePnL(

ITrade[] tradeList ) { } private PnLCalculator() {}}

Uses

Interface can extend another interface

public interface List extends Collection

public interface IDynamicProperties { public void addProperty( String name, Object value ); public Object getProperty( String name ); public Object removeProperty( String name ); public Iterator properties(); public Iterator propertyNames();}

public interface Clonable { public Object clone();}

public class Entity implements IDynamicProperties, Clonable { .. // Implementation of Dynamic properties interface public void addProperty( String name,

Object value ) { htProperties.put( name, value ); } ... // implementation of Clonable interface { public Object clone() { Entity newEntity = new Entity(); // copy all fields return newEntity; } }

public class TreeNode { public Object deepCopy() { TreeNode newNode = new TreeNode(); // copy all the fields

// copy children for ( Iterator i = getChildren();i.hasNext(); ) { TreeNode child = (TreeNode)i.next(); newNode.addChild( child.deepCopy() ); } }}

public interface Iterator { public boolean hasNext(); public Object next();

public void remove();}

for ( Iterator i = getChildren(); i.hasNext(); ) { TreeNode child = (TreeNode)i.next(); newNode.addChild( child.deepCopy() );}

public abstract class Entity

public String getName() { return name; }

public void setName( String name ) { this.name = name; } public abstract Object getUniqueId(); private String name;

}

IFoo

AbstractFoo

DefaultFoo ABitDifferentFoo

VeryDifferentFoo

Please read• Chapters 2, 4, 5 ,6, 10, 11 in Java

programming language by Arnold & Gosling

• Chapters 1 and 2 in Design Patterns by Gamma, etc.