B3.1 Fundamentals of OOP

B3.1.1: Classes, Objects and Evaluating OOP

Why classes: storing 2 birds needs 8 separate variables or 4 parallel lists. With a Bird class, each bird is one object holding all its own data, and all birds go in one list.

OOP features

Advantages and disadvantages

Suitable? Yes for systems with many interacting entities (passenger records, games). Not worth it for a short one off script (an automated server task).

B3.1.2: UML Class Diagrams

A UML class diagram is a standard diagram of a class that any developer can read. Attributes become instance variables, behaviours become methods.

Normal design: attributes private, methods public, helper methods private. void means the method returns nothing (typical for setters).

Other UML diagrams (not drawn in this course): sequence, use case, state, package.

B3.1.3: Static vs Non-static

Static methods can only use static variables directly, because they have no object (no self). In Python, a static variable is declared in the class body, outside __init__. Java uses the static keyword.

class Book:
    booksBorrowed = 0                        # STATIC: one copy, shared by all books

    def __init__(self, title):
        self.__title = title                 # NON-STATIC: each book has its own
        self.__borrowed = False

    def borrow(self):
        self.__borrowed = True
        Book.booksBorrowed += 1              # accessed through the CLASS name

    @staticmethod
    def getBooksBorrowed():                  # static method: no self
        return Book.booksBorrowed


one = Book("Community and Support")
two = Book("Where is Archibald?")
three = Book("Horticulture for the Balcony")
one.borrow()
two.borrow()
print(Book.getBooksBorrowed())

2

B3.1.4: Defining Classes and Instantiating Objects

class Plant:
    def __init__(self, name, family, distribution, bloom):   # constructor
        self.__name = name                  # private instance variables
        self.__family = family
        self.__distribution = distribution
        self.__bloom = bloom

    def getName(self):                      # accessor (getter)
        return self.__name

    def getBloom(self):
        return self.__bloom

    def setBloom(self, b):                  # mutator (setter)
        self.__bloom = b

    def __str__(self):                      # text version of the object
        return self.__name + " (" + self.__family + ")"


fav = Plant("Narcissus", "Amaryllidaceae", "Worldwide", True)   # instantiation
print(fav)                 # calls __str__
print(fav.getName())       # dot notation
fav.setBloom(False)
print(fav.getBloom())

Narcissus (Amaryllidaceae)
Narcissus
False

Classes usually go in their own file and are imported into a runner file: from Plant import Plant.

B3.1.5: Encapsulation and Information Hiding

Encapsulation: bundling data and the methods that act on it inside one class, with the data hidden (private) and accessed only through public methods. Information hiding: other code can't see or change the internal data directly.

The textbook swaps these. In Python two underscores = private, one = protected (by convention). Public variables mean the code is not encapsulated.

• Accessor (getter): returns a private value. Mutator (setter): changes it, and can validate first.
• Features of encapsulated code: private attributes, public getters and setters, data only changed through methods, private helper methods.

class Dish:
    def __init__(self, name, costPrice):
        self.__name = name
        self.__costPrice = costPrice
        self.__retailPrice = self.__calcRetail()

    def __calcRetail(self):                  # private method: hidden markup
        return self.__costPrice * 1.6

    def setCostPrice(self, c):
        if c > 0:                            # setter can validate
            self.__costPrice = c
            self.__retailPrice = self.__calcRetail()

    def getRetailPrice(self):
        return self.__retailPrice


d = Dish("Spaghetti Carbonara", 8.50)
d.setCostPrice(10)
print(d.getRetailPrice())
d.setCostPrice(-5)                           # rejected
print(d.getRetailPrice())
print(d.__costPrice)                         # can't reach private data

16.0
16.0
AttributeError: 'Dish' object has no attribute '__costPrice'. Did you mean: 'setCostPrice'?

Objects in Lists

Same list and loop skills as B2, but you reach the data through the object's methods with dot notation.

class Game:
    def __init__(self, title, age, minutes):
        self.__title = title
        self.__age = age
        self.__minutes = minutes

    def getTitle(self):
        return self.__title

    def getAge(self):
        return self.__age

    def __str__(self):
        return self.__title + ", age " + str(self.__age) + "+"


games = []
games.append(Game("Chicken vs the Egg", 12, 120))
games.append(Game("Foxes and Hedgehogs", 14, 180))
games.append(Game("Cards against History", 18, 60))
games.append(Game("Better or Worse", 5, 20))
del games[2]                                  # remove by index

age = 13
for g in games:                               # selection with objects
    if g.getAge() <= age:
        print(g)

Chicken vs the Egg, age 12+
Better or Worse, age 5+

# linear search by attribute (games list from above)
target = "Better or Worse"
index = -1
for i in range(len(games)):
    if games[i].getTitle() == target:
        index = i
if index != -1:                               # NOT index > 0: index 0 is valid
    print("Found at", index)
else:
    print("Not found")

# bubble sort by title
n = len(games)
for i in range(n - 1):
    for j in range(n - 1 - i):
        if games[j].getTitle() > games[j + 1].getTitle():
            games[j], games[j + 1] = games[j + 1], games[j]
for g in games:
    print(g.getTitle())

Found at 2
Better or Worse
Chicken vs the Egg
Foxes and Hedgehogs

Comparing strings: Python uses > and ==. Java needs .equals() and .compareTo() (returns 0 if equal, <0 if first comes before, >0 if after).

Textbook bugs to avoid: its searches use if index > 0, which misses a match at index 0 (use != -1). Its Python bubble sort loop ranges are wrong, and its binary search goes the wrong way.

Practice Questions

a1 = Article("Top 10 creepy movies", "Patrick D", 350)