1.2 programming paradigms

procedural programming

programming paradigm where programs are formed from sequences of instructions and broken down modularly into routines and subroutines

characteristics of procedural programs

-instructions are executed in the order in which they appear

-subroutines can be called from anywhere in the program

-data is stored as variables and constants

-data structures can have a local or global scope

structured approach to program design and construction

uses assignment, sequence, selection and iteration

characteristics of the structured approach

-designed from the top down(elements are broken down into smaller tasks)

-keeps programs easy to understand and maintain as they are easier to navigate

-testing can be carried out on individual modules

-easier to develop collaboratively as each module can be assigned separately

hierarchy charts

charts representing the structure of a structured program

each procedure is diaplayed as a rectangle and connected to parent or child procedures with a line, with parent procedures above their children

object-oriented programming

programming paradigm where programs are formed from, and designed around, objects which contain their own properties and methods

OOP main principles

inheritance, encapsulation, abstraction and polymorphism

why OOP is used

-programs have a clear structure which makes developing and testing easier, as well as splitting projects among teams

-the use of classes allows code to be reused throughout the program(and sometimes in other programs) improving readability and data efficiency

class

a blueprint for objects specifying their properties and methods

(a “type of thing”)

properties and methods

data and instructions in a class, respectively

can be public or private(accessible from anywhere in the program, or only from within the object and its inheritors)

class definitions

lists of a class's name, properties and methods in text form

object

containers of data and instructions created from a class

instantiation

the creation of an instance of an object from a class using a constructor

constructor

a method in a class called to create and initialise an object from it, assigning a reference to a variable of the class type

constructors can be implicit(automatic, with default parameters) or explicit(eith user-defined parameters)

encapsulation

the process of combining properties and methods to form a class

inheritance

the process by which a class is given the properties and methods of another class in addition to its own, in an is-a relationship

overriding

when a class inherits another it can override its methods, changing the implementation but keeping the name(for itself, not the inherited class)

association

associated objects form part of their container object as a property, in a has-a relationship

aggregation

association where an object will continue to exist if its container object is destroyed

composition

association where an object will cease to exist if its container object is destroyed

polymorphism

where objects are processed differently depending on their class

OOP design principles

-encapsulate what varies

-favour composition over inheritance

-program to interfaces, not implementation

encapsulate what varies

components of a program which are likely to change should be encapsulated as it better protects against said changes unwantedly affecting other parts of the program

favour composition over inheritance

composition should be used over inheritance wherever possible as it is seen as more flexible

program to interfaces, not implementation

programming to depend on interfaces rather than implementations improves code flexibility, and allows unrelated classes to easily make use of similar methods

interface

a set of abstract procedures determining what methods an object should have, without providing the code for them

implementations

classes that fulfil the rules determined by interfaces and provide the code

class diagrams

used to visually represent the relationships that exist between classes

classes are represented by boxes with different connectors representing different kinds of relationship, can exhibit various levels of detail

inheritance diagrams

sshow inheritance relationships that exist between classes- unfilled arrows point from classes to their inheritees and always point upwards

association in class diagrams

association is shown in class diagrams using diamond headed arrows, unfilled and filled diamonds correspond to aggregation and composition respectively

association in UML

in unified modelling language, association between two classes is modelled using lines

a normal line represents bidirectional association while a line with an arrow represents one-way association where a class can call the one the arrow is pointing to but not vice versa

class diagrams with properties and methods

class boxes are split into three, containing the class's name, properties and methods from top to bottom respectively

plus and minus signs in front of properties and methods denote they are public and private respectively

hashtags indicate protected properties or methods