Chapter 58 - Use of Object-Oriented Programming (OOP)

Object-Oriented Programming (OOP) attempts to capture data, information and related functionality (code) to form structured items known as objects. In OOP, the world is viewed as a collection of objects.

Objects are instances of classes (defined in the main body). They can be anything: from specific things such as cars and planes, to more abstract things such as bank accounts or data structures (stacks).

Objects have their own attributes, states and methods (behaviours)

Attributes are variables or data members that belong to a class and represent its characteristics or state

A state of an object is represented by its attributes e.g the radio is on/off

Actions performed by an object (think of them like subroutines) often by altering attributes.

A class is a blueprint/template for an object and it defines the attributes and behaviours (methods) of objects in that class. These attributes are defined as the instance variables within a class.

• Name of the class • The attributes: all the information shared with any object of this class type. Like variables. • The methods/behaviours: the code associated with the class that allows you to change/access its attributes. Like subroutines

As a general rule, attributes/instance variables are defined as private whereas most methods are defined as public. This allows other classes to access the methods but not see/change the attributes. Therefore objects need to use messages to interact with with another object’s state.

A constructor initialises the attributes within a class. Constructors are procedures with the name new. E.g def __init__ new (someAttributes).

An instance of a class - the creation of an object They have the name new when object is created. E.g my_dog = new Dog(someArguments)

print(my_dog.name)

print(my_dog.bark())

Messages can either be getter or setter messages. In some languages, getter messages are written as functions (returning the value you wanted to get) wheras setter messages are written as procedures (usually used to change the state of the object).

Each object belongs to a class All objects of the same class have the same structure and methods but they have their own data Objects belonging to a class are instances of that class.

This is where an object encapsulates its states (value of attributes/instance variables) and its behaviours/methods into a single entity so the attributes/behaviours of one object can’t affect those of the other.

Classes can inherit attributes and methods from a parent class. A child in OOP is known as a subclass and a parent class is known as a superclass

class Vehicle: def __init__new(self,doors,price): self.doors = doors self.price = price class Car(Vehicle): def __init__new(self,doors,price,wheels): super().__init__(doors,price) #super.new(doors,price) self.wheels = wheels

Polymorphism enables methods to do different things based on the object they are acting upon. An example is overriding.

Overriding: defining a method with the same name and formal argument types as a method inherited from a superclass.

class Animal: def __init__ new (self,sound): self.sound = sound def makeSound(self): pass class Dog(Animal) def__init__ new (self,sound): super().__init__ new (sound) def makeSound(self): return f”The Dog goes {self.sound}”