Lecture 2
This presentation is the property of its rightful owner.
Sponsored Links
1 / 32

Lecture 2 PowerPoint PPT Presentation


  • 57 Views
  • Uploaded on
  • Presentation posted in: General

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.

Download Presentation

Lecture 2

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Lecture 2

Lecture 2

Object-oriented programming


Definitions of oop

Definitions of OOP

OOP is a programming paradigm, which utilizes encapsulation, inheritance and polymorphism.

(From standard programming languages textbook)


Definitions of oop1

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 oop2

Definitions of OOP

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


Grady booch on abstraction

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 abstraction1

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.


Encapsulation

Encapsulation

public class Car {

private String serialNumer;

private String make;

private double tankVolume;

private double speed;

}


Encapsulation1

Encapsulation

public 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;

}


Encapsulation2

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

Inheritance

Is-a relationship (is kind of)

Dog is a Mammal

Professor is (usually) Human

Running is an Exercise


Lecture 2

Inheritance is about organizing abstractions into hierarchies.


Inheritance1

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.


Inheritance2

Inheritance

Derived class inherits interface and implementation from the base class.


Inheritance for extension

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

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

}

}


Lecture 2

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

From Arnold & Gosling 'Java programming language'


Lecture 2

public interface IDatabase {

public String getName();

public ITable getTable( String name );

public Iterator tables();

public Iterator tableNames();

}


Lecture 2

public class RelationalDatabase

implements IDatabase

public class FileDatabase

implements IDatabase


Lecture 2

public void setDatabase( IDatabase db ) {

if ( db instanceof RelationalDatabase ) {

processRelationalDatabase( (RelationalDatabase)db );

} else if ( db instanceof FilelDatabase ) {

processFilelDatabase( (FilelDatabase)db );

}

...

} DON’T DO THIS….


Lecture 2

class GraphicalTextEditor :

public TextEditor, Component;


Lecture 2

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();

}


Aggregation

Aggregation

Objects of a class have a reference (member field) one or more objects of another class

public class Car {

private Engine engine;

}


Lecture 2

Uses

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

public class PnLCalculator {

public static double computePnL(

ITrade[] tradeList ) {

}

private PnLCalculator() {}

}


Lecture 2

Interface can extend another interface

public interface List extends Collection


Lecture 2

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();

}


Lecture 2

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;

}

}


Lecture 2

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() );

}

}

}


Lecture 2

public interface Iterator {

public boolean hasNext();

public Object next();

public void remove();

}


Lecture 2

for ( Iterator i = getChildren(); i.hasNext(); ) {

TreeNode child = (TreeNode)i.next();

newNode.addChild( child.deepCopy() );

}


Lecture 2

public abstract class Entity

public String getName() { return name; }

public void setName( String name ) {

this.name = name;

}

public abstract Object getUniqueId();

private String name;

}


Lecture 2

IFoo

AbstractFoo

VeryDifferentFoo

ABitDifferentFoo

DefaultFoo


Please read

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.


  • Login