Object-Oriented-Programming! (OOP)

Size: px

Start display at page:

Download "Object-Oriented-Programming! (OOP)"

Stephen Melton
5 years ago
Views:

1 Object-Oriented-Programming! (OOP)

2 Basically it s all about abstraction & information hiding n Good programs consist of layer upon layer of reusable code (think of software tools). n The programmer should be free to tinker with the internal workings of a set of software tools, but with little risk of breaking programs that use the tools. n This is accomplished by introducing layers of abstraction. Good programmers have been doing this since the beginning of programming. There are many ways of doing this. n In object oriented programming, bundled sets of data and code are initialized and then passed around and used within the program. Data within objects is never accessed directly. It is only accessed via code in the objects.

3 Review of subroutine basics n Calling a subroutine (...output_list...) = foo(...input_list...) n Declaring a subroutine sub foo { (...input_list...) Perl statements... return (...output_list...) } n Not restricted to returning lists, can return hashes or other objects

4 Review of reference basics n References point to stuff in memory $anonarray = [...list of values...]; $anonhash = {...list of key/value pairs...}; $anonsubroutine = sub {...Perl statements..}; n Recover stuff with dereference operator ( -> ) value = $anonarray->[index] value = $anonhash->{key} (...output_list...) = $anonsubroutine->(...input_list...)

$99792458 }; my $anonfunc = sub { print "hello world\n"; }; print $anonarray->[4],"\n"; print $anonhash->{"pi"},"\n"; $anonfunc->(); demo:$

5 demo #1 #!/usr/bin/perl use warnings; use strict; my $anonarray = [1,2,3,4,"five"]; my $anonhash = { "pi" => , "e" => , "c" => }; my $anonfunc = sub { print "hello world\n"; }; print $anonarray->[4],"\n"; print $anonhash->{"pi"},"\n"; $anonfunc->(); demo: references3.pl

6 #!/usr/bin/perl use warnings; use strict; demo #2 An anonymous hash containing anonymous functions my $anonhash = { hello => sub { print "hello world\n"}, bye => sub { print "goodbye cold cruel world\n"} whatever => sub { print $_[0]\n"} }; $anonhash->{hello}(); $anonhash->{bye}(); $anonhash->{whatever}( any text ); demo: references4.pl

7 back to OOP n Many useful library modules (e.g. bioperl) are written using an object-oriented programming style n Using Objected oriented modules is easy n Writing Object oriented moduels is a little harder than using them,! but easier than writing traditional modules n Key concepts: n information hiding n data is hidden from the calling routines n Encapsulation n Data and functions encapsulated into one object. Data manipulated by functions not directoy. n Abstraction n Hierarchies of subroutines & functions, each hides the details of it s data and implementation from calling routines

n OOP terminology (translated into perl) n Object -- a hash reference whose values are!

8 Perl Objects n Perl extends the capabilities of packages and modules to automatically build objects for you and to hide some of the messy details. n OOP terminology (translated into perl) n Object -- a hash reference whose values are! references to data and subroutines n Method -- A subroutine incorporated in an object n Class -- a package that declares objects and references

n n bless() distinguishes an ordinary hash from an object Perl needs to know which hash

Bless() attaches a tag to a hash reference n Existence of a tag tells perl to treat a

$= \%somehash; print hash references is: $s\n"; bless($s); print blessed reference is:$

9 n n bless() distinguishes an ordinary hash from an object Perl needs to know which hash references are objects so that it knows to treat them a little bit differently. Bless() attaches a tag to a hash reference n Existence of a tag tells perl to treat a hash reference as an object n The tag is just a string which is the name of the package where the reference (the referent) was declared package demopackage; my %somehash; my $s = \%somehash; print hash references is: $s\n"; bless($s); print blessed reference is: $s\n"; demo: bless1.pl

What does bless() really do to a hash reference?

package: n A key for each global perl identifier n

10 What does bless() really do to a hash reference? n Marks the hash with a tag that is the package name where the bless is applied n Automatically adds hash entries corresponding to globals in the package: n A key for each global perl identifier n The value is a reference to the corresponding data or functions

$creating an object with new() & bless() my $s = demopackage::new(); # create an object print $s\n ; # print the reference $s->test("foo", "goo"); # invoke a method # ---------the package$

11 creating an object with new() & bless() my $s = demopackage::new(); # create an object print $s\n ; # print the reference $s->test("foo", "goo"); # invoke a method # the package starts here package demopackage; sub new { return bless {}} # bless on an empty hash # print each element of the argument list sub test { foreach (@_) { print "$_\n"; } } demo: bless2.pl

Huh! Why is there an extra element in @_?

blessed hash. n A class, is just a package. n An object, is just a blessed hash.

12 Huh! Why is there an extra element n Recall that: n A method, is just a subroutine that is invoked by dereferencing a function reference, in a blessed hash. n A class, is just a package. n An object, is just a blessed hash. n When invoking a method in an object, Perl automatically adds a reference-to-the-object itself, to the beginning This is so that the method can access the other data and functions in the class, if it needs to.

13 Example: accessing private variables my $s = demopackage::new(); $s->set( ); $s->print_parm(); # the package starts here package demopackage; our $parm; sub new { return bless {} } sub set { my $self = shift; # shift first argument $self->parm = shift; # shift second argument } sub print_parm { my $self = shift; print $self->parm,"\n"; } demo: bless4.pl

14 Writing object oriented modules A practical example illustrated by a sequence of examples

15 Working example: queues A queue consists of two things: 1) A list whose items are retrieved in First in, first out (FIFO) order. 2) A description of the queue, e.g. ten items or less. Dequeue (leavequeue) Enqueue (enterqueue) Harry David Fernando Rosie How do we represent a queue? 1) The list part of the queue is represented as an array variable 2) The description of the queue is represented as string variable

16 #!/usr/bin/perl use warnings; use strict; Queue version 1 # a queue is an array with a description my $description = '10 items or less'; # add customers to a queue unshift(@queue, 'Harry'); unshift(@queue, 'David'); unshift(@queue, 'Fernando'); unshift(@queue, 'Rosie'); # checkout the customers print "line: $description\n"; while(my $who = { print "checked out $who\n"; }

17 Discussion Problems? 1) How to handle multiple queues? Replicate the variables and replicate the code for manipulating them -- yuk! 2) The code is not reusable 3) The code will be difficult to maintain. For example, when I come back in a month to modify it, I will have to understand the implementation in order to understand what it is doing, e.g. why did I unshift and pop? Solve many of the problems by implementing queues as a set of subroutines.

18 Queue version 2 #!/usr/bin/perl use warnings; use strict; my $aisle1 = newqueue('10 items or less ); joinqueue($aisle1, 'Harry'); joinqueue($aisle1, 'David'); joinqueue($aisle1, 'Fernando'); joinqueue($aisle1, 'Rosie'); print "The queue is: ". description($aisle1). "\n"; while(my $who = leavequeue($aisle1) ) { print "checked out $who\n"; } subroutines allow us to abstract away details of the implementation.

19 sub newqueue { return { } } subroutines for Queue 'DESCRIPTION' => $_[0], 'QUEUE' => [] sub description { return $_[0]->{'DESCRIPTION'}; } sub joinqueue { unshift(@{$_[0]->{'queue'}},$_[1]); } sub leavequeue { return }

20 Perl Objects (reminder) n We will make our subroutines resusable by putting them in a module n OOP terminology (translated into perl) n Object -- a variable containing a blessed hash reference! which in turn contains data and subroutine! references n Method -- A subroutine incorporated in an object n Class -- a package that declares objects and references n Syntax: Instead of joinqueue($ailse1, 'Fernando'); We will write $aisle1->joinqueue('fernando');

21 Queue version 3 #!/usr/bin/perl use warnings; use strict; use Queue; package name method my $ailse1 = Queue::new('10 items or less'); $ailse1 ->joinqueue('harry'); $ailse1 ->joinqueue('david'); $ailse1 ->joinqueue('fernando'); $ailse1 ->joinqueue('rosie'); print " queue : ".$ailse1 ->description."\n"; while(my $who = $ailse1 ->leavequeue) { print "checked out $who\n"; }

$pm package Queue; # package is always the first statement sub new { return bless { 'DESCRIPTION' => $_[0], 'QUEUE' => [] } } sub description { return $_[0]->{'DESCRIPTION'}; } sub joinqueue {$

22 Queue.pm package Queue; # package is always the first statement sub new { return bless { 'DESCRIPTION' => $_[0], 'QUEUE' => [] } } sub description { return $_[0]->{'DESCRIPTION'}; } sub joinqueue { unshift(@{$_[0]->{'queue'}},$_[1]); } sub leavequeue { return } 1; # 1 is always the last statement Essentially the same routines as before, but in in object oriented style and in a file Queue.pm.

23 1. use Queue; Summary 2. my $queue = Queue::new('10 items or less'); 3. $queue->description(); 1. use gives the script access to the objects in the Queue class. 2. The identifier on the LHS of -> is a package name (a class), so perl knows that new is a subroutine in Queue.pm which returns: 1. A hash with references to the subroutines and globals in Queue.pm 2. A tag with the package name, i.e. a blessed hash 3. Because the hash reference $queue was blessed, perl knows that all identifiers on the RHS of $queue-> are found in Queue.pm. 4. The parameter list of description has the class name (Queue) automatically shifted onto it, so the method can access other methods and data in the class.

24 Inheritance n Objects, can inherit methods and data from other objects. AbstractQueue is a is a is a DisneyQueue WalmartQueue JHSPHQueue n Methods and variables in parent object are incorporated into child objects

25 Queue version 4 #!/usr/bin/perl use warnings; use strict; use DisneyQueue; my $ride1 = DisneyQueue::new( Mr. Toad s wild ride ); $ride1 ->joinqueue('harry'); $ride1 -> joinqueue('david'); $ride1 -> joinqueue('fernando'); $ride1 -> joinqueue('rosie'); print $ride1 ->queuelength," waiting in the "; print $ride1 ->description," queue\n"; while(my $who = $ride1 ->dequeue) { print "$who checked out\n"; }

26 DisneyQueue.pm package DisneyQueue; require = qw/abstractqueue/; # Is a use warnings; use strict; sub queuelength { } return $_[0]->{'QUEUE'} }; 1;

27 AbstractQueue.pm Same as queue.pm, but with a more sophisticated new method new can be inherited to make AbstractQueue, DisneyQueue, etc. sub new { my $invocant = shift; # either the package name, or the reference } my $classname = $invocant ref($invocant); return bless ( {'DESCRIPTION' => $_[0],'QUEUE'=> [] }, $classname ); sub description { return $_[0]->{'DESCRIPTION'}; } sub enqueue { unshift(@{$_[0]->{'queue'}},$_[1]); } sub dequeue { return } The behind the scenes trick is that the tag is copied from the! invocant to the new object (see Programming Perl ).

http://www.iinteractive.com/moose/ Moose is an extension of the Perl 5 object system.

28 Moose is an extension of the Perl 5 object system. The main goal of Moose is to make Perl 5 Object Oriented programming easier, more consistent and less tedious. With Moose you can think more about what you want to do and less about the mechanics of OOP.

29 Moose takes care of all the messy housekeeping for you A module package MyClass1; use Moose; sub dosomething { print "hello world\n" } 1; The main #!/usr/bin/perl -w use MyClass1; my $object = MyClass1->new(); # returns an object, i.e. a blessed Hash $object->dosomething(); # invokes the 'dosomething' method

30 What you get automagically n new() n attributes, getters and accessors n type checking (for attributes) n subclassing

PERL Scripting - Course Contents

PERL Scripting - Course Contents Day - 1 Introduction to PERL Comments Reading from Standard Input Writing to Standard Output Scalar Variables Numbers and Strings Use of Single Quotes and Double Quotes