Slide1 l.jpg
Sponsored Links
This presentation is the property of its rightful owner.
1 / 28

Object Oriented Programming PowerPoint PPT Presentation

Object Oriented Programming Some Interesting Genes Object Oriented Programming A Brief Encounter What Abstract Data Types Classes Objects Methods Inheritance Polymorphism Why Productivity increase Better code Reusable code Easier to model real things Object Oriented Design

Download Presentation

Object Oriented Programming

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

Slide1 l.jpg

Object Oriented Programming




Object oriented programming l.jpg

Object Oriented Programming

A Brief Encounter

Slide3 l.jpg


  • Abstract Data Types

  • Classes

  • Objects

  • Methods

  • Inheritance

  • Polymorphism

Slide4 l.jpg


  • Productivity increase

  • Better code

  • Reusable code

  • Easier to model real things

Object oriented design l.jpg

Object Oriented Design

  • one identifies real objects and the operations on them that are interesting.

  • these operations can then by systematically implemented.

  • for example: we might have pdf’s and cdf’s as different objects.

  • methods might be means, median, maxima and so on.

Object oriented design6 l.jpg

Object Oriented Design

  • a basic principle (or perhaps hope) is that by faithfully representing the objects we get easier to implement functions.

  • if a cdf object knows how to answer all the cdf questions then it is more useful.

  • if, instead, the cdf is implemented as two vectors (xpos and ypos), it is harder for others to use it.

Three big ideas l.jpg

Three big ideas

  • Abstraction: think only about the components of the problem that are important.

  • Encapsulation: keep the means used to produce the result secret. Other programs get to see only what you want them to.

  • Modularity: group related services into a module with a well defined interface. Other programs should rely only on the interface.

Adt s l.jpg


  • we usually write programs to manipulate data

  • data can almost always be represented in many different ways

  • we don’t want our program to depend on the representation of the data

  • an abstract data type provides with a mechanism to avoid a dependence on representation

Slide9 l.jpg


  • a point in the plane can be represented either in terms of its x and y coordinates or in terms of r and q.

  • if we write a program that assumes one form or the other then we cannot easily change (and cannot easily use data obtained in different ways) our representation.

Slide10 l.jpg


  • if instead we employ the rather simple tactic of only accessing the data through a function (a macro in many languages) then we can make the access independent of the representation.

  • have a look at the R code in

  • ~rgentlem/Rexamples/xy.R

Classes l.jpg


  • A class is a specification. It generally consists of some slots and some functions or methods that act on those slots.

  • The slots represent values that are intrinsic to the class.

  • There are many different classes that can represent a single ADT.

Classes12 l.jpg


  • Consider a triangle. If we know the lengths of the three sides then we know all about the triangle.

  • So we could implement triangles as objects with three slots: the lengths of each side.

  • We could also implement them as classes with 2 side slots and the angle between the two.

Classes13 l.jpg


  • Why would I prefer one implementation over the other? (Basically efficiency)

  • An operation that we might want to perform on a triangle is finding its area.

  • Should we make area a slot?

  • Should we compute it each time it is needed?

Instances l.jpg


  • Once I have defined the class I need to obtain some objects that are of that class.

  • These are called instances. And one usually says something like instantiate.

  • All programming is done on instances of a class.

Some subtleties l.jpg

Some Subtleties

  • Much of the usefulness of object oriented programming comes from the fact that different instances have different values for the slots.

  • Sometimes we want there to be a slot that has the same value for all instances. This is a class slot (not all OO systems have this).

Objects l.jpg


  • One definition of an object is that it is a set of operations that share a state.

  • The state consists of one or more values that can only be viewed and modified by operations belonging to the object.

  • The state information is available through the slots.

Objects17 l.jpg


  • Some implementations allow direct access to the slots (usually for efficiency) but this can break the data abstraction.

  • In other implementations one can only access slots through accessor functions.

  • Then the implementation can change but I need to only change the accessors, not all my code.

Classes vs objects l.jpg

Classes vs Objects

  • an object is a specific entity that exists at run time

  • a class is a static entity that exists in the program code

  • a class describes how to create an object (and in some languages how to interact with that object)

Instances objects l.jpg


  • We instantiate an object with a call to a constructor. Usually it has a nice name like new.

  • x = new(“circle”, r=3.3)

  • Now x is an instance of the circle class.

  • The next step is to think about functions that operate on circles (or more properly instances of the circle class).

Methods l.jpg


  • A method is a function. But it is a special type of function.

  • Methods act on instances. The argument list for a method is often referred to as a signature. The types of the arguments to a method are used to determine which method should be called.

Methods21 l.jpg


  • Methods can have single dispatch. That means that the appropriate method is determined by using a single argument.

  • This is the system used in the S class system. There it is the class of the first argument that is used.

  • For multiple dispatch we want to use all (or many) of the arguments to determine the appropriate method. (S4 methods).

Methods22 l.jpg


  • A method is simply a function that has been called from a generic.

  • In many systems it is not possible to call a method directly (and usually it is not a good idea in any system).

  • Accessing slots directly breaks the notion of an ADT.

Programming l.jpg


  • let’s return to the code in xy.R.

  • in S4 classes there are no accessor functions created by default

  • you must write your own, this is what I have done using Xpos and Ypos

  • can you see a problem with taking that approach?

Problem l.jpg


  • Why do I have to have Xpos.xy and Xpos.rt?

  • I really just want Xpos!

  • This is where generic functions come in. They basically act as dispatchers.

  • The mechanisms used to determine which method (we can think of Xpos.xy and Xpos.rt as methods) differ between languages.

Generic functions l.jpg

Generic Functions

  • a generic function is a dispatcher

  • it determines the type of arguments and looks for a method that will match those arguments.

  • that method is then invoked with the arguments used for the generic function.

Costs l.jpg


  • so what does this cost?

  • it tends to be slower (this does not have to be true) in terms of execution time

  • the burden goes from programming to design (often a good thing).

Nextmethod l.jpg


  • in most (but not all) languages there is a concept of the next method that would be appropriate (after the current method).

  • In the S3 class system there is a NextMethod function.

  • In the S4 object system it is being developed.

Why bother l.jpg

Why bother?

  • you know you are only going to write small programs

  • it’s easier to learn good style on small programs

  • small programs have a tendency to grow into large programs

  • small program, written well, can be used as components in large programs

  • Login