Programming Languages

Transcription

1 Programming Languages Week 9 Exercises Object-oriented programming in Python (2) Objects are especially useful for factoring state and behaviour. When two (or more) different classes of object are specicialisations of a more general idea, each of those classes can share a single description of the state and behaviour that they all have in common. (Avoiding duplication of description or code is sometimes called the DRY principle : Don t Repeat Yourself.) 1. Create a class Student, representing students. Each student should have three properties: a name, an identifying number, and a year of entry. Give the properties unusual names to dissuade programmers from accessing them directly. Define accessors (with sensible names) for each of the three properties. Add a repr method so that the Student objects print themselves nicely. class Student(): def init (self, name, number, year): self._name = name... # similarly for number and year def name( self): return self._name... # similarly for number and year return "Student(" + self.name() \ + ", #" + str(self.number()) \ + ", " + str(self.year()) + ")" s = Student(" Werner Learner", 123, 2017) print(s) #=> Student( Werner Learner, #123, 2017) 2. Create a class Teacher, representing teachers. Each teacher has three properties: a name, an ID number, and an office number. Give the properties unusual names, and again define an accessor for each of the properties. Don t forget a repr method for printing. class Teacher(): def init (self, name, number, office): self._name = name... # similarly for number and office def name( self): return self._name... # similarly for number and office return "Teacher(" + self.name() \ + ", #" + str(self.number()) + \ ", " + str(self.office()) + ")" t = Teacher(" Nate Pontificate", 456, 301) print(t) #=> Teacher( Nate Pontificate, #456, 301)

2 Refactoring and inheritance Students and Teachers have much in common. They both have names, and they both have ID numbers. The similarity is because they are specialisations of a more general idea, which we might call academic. Refactoring the two classes will move the properties that they share into a single base class, called Academic from which Student and Teacher will inherit what it means to be an academic. The Student class will the specialise the idea of academic with just those properties that are unique to students. Similarly, the Teacher class will the specialise the idea of academic with properties that are unique to teachers. 3. Create a class Academic, representing only the common properties of both Students and Teachers. The easiest way to do this is to copy one of your existing classes (e.g., Student), rename it to Academic, and then remove all the parts that are specific to students (the year of entry). In other words, Academics only have a name and an ID number. class Academic(): # a copy of the Student class, renamed def init (self, name, number): # no year... # the same initialisation, but omit the year... # define accessors for name and number only return " Academic(" +... # name and number only a = Academic(" Tinka Thinka", 789) print(a) #=> Academic( Tinka Thinka, #789) The two original classes Student and Teacher can now be made much smaller, by inheriting their common properties from the Academic class. 4. Create subclasses of Academic, Student and Teacher, representing only their distinguishing properties. To create a subclass C, which inherits from a base class B, just write the class definition as class C(B):.... Within the methods of C (including the instance initialisation method init ) the methods of the base class B can be called as B.method(self,...). class Student( Academic): def init (self, name, number, year): Academic. init (self, name, number) self._year = year def year( self): return self._year return Academic. repr (self) + "Student(" + str(self.year()) +") " s = Student("Ken Sikha", 248, 2017) print(s) #=> Academic(Ken Sikha, #248) Student (2017) class Teacher( Academic): def init (self, name, number, office):... # similar to Student, but with an office instead of a year... # don t forget the accessor for office return... # similar to Student, but with office instead of year t = Teacher(" Snorey Borey", 357, 207) print(t) #=> Academic( Snorey Borey, #357) Teacher (207) 2

3 Overriding methods in subclasses Refactoring broke the printed representation of Students and Teachers. One way to fix it would be to let the Academic class handle the printing of the representation of all of its subclasses. Each subclass would only be resposible for providing a printed representation of its specific properties. For this to work, Academic will be the only class that implements the repr method. When an instance of any of the three classes is asked for its representation, the method in Academic will be invoked. Within that method, self will be bound to the object whose representation we want. We can ask that object for its class, and then ask the class for its name (a string). Every object has a property class that contains a reference to its class. Classes are objects too, and every class has a property name that contains its name as a string. To obtain a string describing the properties, we can ask self for a propertystring. In Academic, this method returns a string describing the object s name and number. The two subclasses will override this method to return a string containing all the properties of the object: those of Academic, followed by the property specific to the object (year or office). Since Academic might change, it would be wrong to access name and number directly from the propertystring method of Student and Teacher. Instead, the two propertystring methods in these classes should first invoke Academic.propertyString(self) to get their Academic properties, and then append another string describing their own specific property (year for Students, office for Teachers). 5. Implement propertystring in the three classes so that a single implementation of repr in Academic will print complete information about an object. class Academic():... # as before, until... return self. class. name + "(" + self.propertystring () + ")" def propertystring( self): # properties specific to Academic return self.name() + " #" + str(self.number()) class Student( Academic): # delete the repr method, and replace it with def propertystring( self): # properties specific to Student return Academic. propertystring( self) + " " + str( self. year()) class Teacher( Academic):... # similar to Student, but with an office instead of a year print( Student(" Ken Sikha", 248, 2017)) #=> Student( Ken Sikha # ) print( Teacher(" Snore Bore", 357, 207)) #=> Teacher( Snore Bore # ) Class properties and methods Methods defined inside a class definition are shared between all instances of the class. Class variables defined inside a class definition are also shared between all instances of the class. These variables are accessible like normal instance variables of self but they are stored inside the class object itself. In other words, they are properties of the class object itself. Methods can also be defined for the class object. Class methods begin with a They are called through the class (rather than an instance of the class) and their first argument is the class object itself. One of many uses for a class variable is to store a list of all the instances of a class. 3

4 A template (almost complete) for classes might look like this: class MyClass( MySuperclass): myclassvar1 = initialvalue myclassvar2 = initialvalue def init (self,...): self. myinstancevariable1 = initialvalue self. myinstancevariable2 = initialvalue... def def myclassmethod1(cls,...): Modify the Student class so that it remembers all of its instances. Add a class variable _allstudents to the Student class, with initial value an empty list. Within the init method, append each newly-initialised instance to the _allstudents list. Add a class method to Student called allstudents(clazz) which returns the list _allstudents. Test your additions as follows: print( Student(" Ken Sikha", 765, 2017)) #=> Student( Ken Sikha # ) print( Student(" Ben Shiba", 432, 2017)) #=> Student( Ben Shiba # ) print Student. allstudents() #=> [ Student(Ken Sikha # ), Student(Ben Shiba # )] Static methods One more kind of method can be defined inside a class. class def hello(): # note: no implicit self argument print " hello" MyClass().hello() #=> hello Static methods behave just like instance variables containing a normal function. Their advantage over normal functions is that the static method is shared between all instances. 4

5 If you get this far, have some fun for a while Download this file: Create a new file, and at the top import the following: from graphics import * from random import randint, random from math import copysign Add definitions for two global variables W and H to hold the width and height of a window. Initialise both W and H to 400. Define two more global variables R and V to hold a maximum radius and velocity. Initialise both R to 10 and V to 1. W, H = 400, 400 R = 10 V = 1 Define a class called Ball that inherits from a class (provided by graphics.py) called Circle. Within Ball: Define a class variable call allballs, with initial value an empty list. Define an init method that calls Circle. init (self, Point(randint(R, W-R), randint(r, H-R)), randint(1, R)) to initialise the parts of Ball that are inherited from Circle, sets self.dx and self.dy to 1 + random() * V, and appends self to allballs. Define a method update(self) that calls self.getcenter() to obtain the point at the center of the ball, calls self.getradius() to obtain the radius of the ball, checks if center.getx() + radius >= W or center.getx() - radius <= 0 and, if so, calls self.bouncex(), checks if center.gety() + radius >= H or center.gety() - radius <= 0 and, if so, calls self.bouncey(), calls self.move(self.dx, self.dy). Define a method bouncex that negates self.dx and then calls move(self.dx, 0). Define a similar method bouncey that works vertically instead. Define a class method step(cls, win) that iterates a variable ball over allballs, and for each ball calls ball.update(). Define a global variable win initialised with GraphWin("Balls", W, H, False). Add ten Balls to win by calling Ball().draw(win) ten times. Run the simulation until the user clicks in the window, like this: while not win. checkmouse(): Ball.step(win) win. update() win. close() Modify bouncex and bouncey to remove 10% of the energy of the ball every time it bounces. Create a subclass EnergyBall(Ball) that overrides bouncex and bouncey to increase the energy of the ball by 10% every time it bounces. Add ten of these to the simulation. 5