The document discusses object-oriented design, emphasizing the concepts of objects, classes, methods, attributes, encapsulation, and inheritance. It explains how to model real-world scenarios using class diagrams and highlights the importance of abstraction and composition in software development. Additionally, it provides examples, such as modeling a greengrocery and a chess set, to illustrate key principles of object-oriented programming.

1. Object-Orientated Design
Damian Gordon

2. Object Orientation
• An object is any tangible thing we can see touch and
manipulate.

3. Object Orientation

4. Object Orientation
• Software objects are models are similar in the sense that they
have certain features and can do certain things.

5. Object

6. Features
Behaviours

7. Attributes
Methods

8. Attributes
Methods
Attributes:
A Collection of
variables

9. Attributes
Methods
Attributes:
A Collection of
variables
Methods:
A Collection of
procedures

10. Hair Colour
Eye Colour
HeightWeight
Length
Lie Down( ) Fetch( )
Sit( )
Bark( )
Roll Over( )

11. Attributes
Methods
Encapsulation

12. Object Orientation
• To create an object what we typically do is first create the
general class that a specific object comes from, and then we
create a specific object of that class.
• For example, if a want to model a specific dog, first create the
general CLASS of DOG, and then create a specific instance of
that class, an OBJECT, called TINY the dog.

14. Object Orientation
• Sometimes it’s easier to model things as an OBJECT, but often
it’s easier to model a collection of things as a CLASS, and then
create instances (‘OBJECTS’) of that CLASS.
• We can use UML (the Unified Modelling Language) to model
Object-Orientated programs, and one modelling tool within
UML is called a CLASS DIAGRAM.

15. Object Orientation
• Let’s imagine we wanted to create a CLASS DIAGRAM for the
following scenario:
– We work in a greengrocer, we sell APPLES and ORANGES; APPLES are
stored in BARRELS and ORANGES are stored in BASKETS.

16. Object Orientation
• APPLES are stored in BARRELS and ORANGES are stored in
BASKETS.

17. Object Orientation
• APPLES are stored in BARRELS and ORANGES are stored in
BASKETS.
Apple

18. Object Orientation
• APPLES are stored in BARRELS and ORANGES are stored in
BASKETS.
Apple Barrel

19. Object Orientation
• APPLES are stored in BARRELS and ORANGES are stored in
BASKETS.
Apple Barrel
Orange

20. Object Orientation
• APPLES are stored in BARRELS and ORANGES are stored in
BASKETS.
Apple Barrel
Orange Basket

21. Object Orientation
• Let’s add in more rules to the scenario:
– Many APPLES are stored in one BARREL and many ORANGES are
stored in one BASKET.

22. Object Orientation
• Many APPLES are stored in one BARREL and many ORANGES
are stored in one BASKET.
Apple Barrel
Orange Basket
*
* 1
1

23. Object Orientation
• Many APPLES are stored in one BARREL and many ORANGES
are stored in one BASKET.
Apple Barrel
Orange Basket
*
* 1
1
go in >
go in >

24. Object Orientation
• Let’s add some attributes:

25. Object Orientation
Apple Barrel
Orange Basket
*
* 1
1
go in >
go in >
+colour
+weight
+size
+weight
+orchard
+date_picked
+location

26. Object Orientation
Apple Barrel
Orange Basket
*
* 1
1
go in >
go in >
+colour: string
+weight: float
+size: int
+weight: float
+orchard: string
+date_picked: date
+location: string

27. Object Orientation
Apple Barrel
Orange Basket
*
* 1
1
go in >
go in >
+colour: string
+weight: float
+barrel: Barrel
+size: int
+apples: list
+weight: float
+orchard: string
+date_picked: date
+basket: Basket
+location: string
+oranges: list

28. Object Orientation
• Now let’s add some methods:

29. Object Orientation
Apple Barrel
* 1go in >
+colour: string
+weight: float
+barrel: Barrel
+size: int
+apples: list
+pick(backet: Basket)
+squeeze( ): juice
+sell(cust: Customer)
+discard( )

30. Object Orientation
Orange Basket
* 1
go in >
+weight: float
+orchard: string
+date_picked: date
+basket: Basket
+location: string
+oranges: list
+pick(backet: Basket)
+squeeze( ): juice
+sell(cust: Customer)
+discard( )

31. Information Hiding

32. Object

33. Attributes
Methods

34. Attributes
Methods
Encapsulation

35. Hair Colour
Eye Colour
HeightWeight
Length
Lie Down( ) Fetch( )
Sit( )
Bark( )
Roll Over( )

36. Hair Colour
Eye Colour
HeightWeight
Length
Lie Down( ) Fetch( )
Sit( )
Bark( )
Roll Over( )
OTHER
CLASSES

37. Object Orientation
• An OBJECT is made up of ATTRIBUTES and METHODS. Some of
these can be private to the CLASS, and some can be public and
used by other classes.
• The public elements (ATTRIBUTES and METHODS) of the CLASS
are referred to as the INTERFACE (or PUBLIC INTERFACE).

38. Hair Colour
Eye Colour
HeightWeight
Length
Lie Down( ) Fetch( )
Sit( )
Bark( )
Roll Over( )
OTHER
CLASSES

39. Hair Colour
Eye Colour
HeightWeight
Length
Lie Down( ) Fetch( )
Sit( )
Bark( )
Roll Over( )
OTHER
CLASSES

40. Object Orientation
• A common real-world example is the television. Our
interface to the television is the remote control.
• Each button on the remote control represents a method
that can be called on the television object.

41. Object Orientation
• The public interface is very important, we have to design it
carefully, because it can be difficult to change in the future,
and changing it will cause problems for any client objects that
are calling it.
• We can change the internals as much as we like (e.g. to make it
more efficient, or to access data over the network as well as
locally) and the client objects will still be able to talk to it,
unmodified, using the public interface.

42. Abstraction

43. Object Orientation
• ABSTRACTION means dealing with the level of detail that is
most appropriate to a given task.
• For example, a DRIVER of a car needs to interact with steering,
gas pedal, and brakes. The workings of the motor, drive train,
and brake subsystem don't matter to the driver. A MECHANIC,
on the other hand, works at a different level of abstraction,
tuning the engine and bleeding the breaks.

44. Object Orientation
Driver Car
drives >
+brakes
+accelerator
+steer( )
+change_gears( )
+apply_brakes( )
Mechanic Car
fixes >
+disc_brakes
+engine
+transmission
+adjust_breaks( )
+change_oil( )

45. COMPOSITION

46. Object Orientation
• COMPOSITION is the act of collecting several objects together
to create a new one.
• Composition is usually a good choice when one object is part
of another object.

48. Object Orientation
• A car is composed of an engine, transmission, starter,
headlights, and windshield, among numerous other parts.
• The engine, in turn, is composed of pistons, a crank shaft, and
valves. In this example, composition is a good way to provide
levels of abstraction.
• The car object can provide the interface required by a driver,
while also providing access to its component parts, which
offers the deeper level of abstraction suitable for a mechanic.

50. Object Orientation
• Let’s try modelling computer chess as a CLASS DIAGRAM:

51. Object Orientation
• Let’s try modelling computer chess as a CLASS DIAGRAM:
Player Chess Set
2 1
make_move >

52. Object Orientation
• The diagram shows that exactly two players can interact with
one chess set.
• This also indicates that any one player can be playing with only
one chess set at a time.

53. Object Orientation
• Just for fun, let’s try to model at an object level instead of at a
class level.
• For this we use an OBJECT DIAGRAM.

54. Player
Class

55. Player
Player 1
Player 2
Class Objects

56. Object Orientation
• This is an OBJECT DIAGRAM (or INSTANCE DIAGRAM):
Chess Set
Player 1
Player 2
make_move
make_move

57. Object Orientation
• An OBJECT DIAGRAM or INSTANCE DIAGRAM describes the
system at a specific state in time, and is describing specific
instances of objects, not the interaction between classes.

58. Object Orientation
• Lets return to the class diagram:

59. Object Orientation
• Lets return to the class diagram:
Player Chess Set
2 1
make_move >

60. Object Orientation
• Thinking about the composition of a Chess Set we know it’s
made up of a board and 32 pieces.
• The board further comprises 64 positions.
• The composition relationship is represented in UML as a solid
diamond.

61. Object Orientation
Player
Chess Set
2
1
make_move >

62. Object Orientation
Player
Chess Set
2
1
make_move >
Piece
32
1

63. Object Orientation
Player
Chess Set
2
1
make_move >
Piece
32
Board
1
1 1

64. Object Orientation
Player
Chess Set
2
1
make_move >
Piece
32
Board
1
1 1
Position
64
1

65. Object Orientation
• Finally let’s add some attributes to the class diagram:

66. Object Orientation
Player
Chess Set
2
1
make_move >
Piece
32
Board
1
1 1
Position
64
1
+pieces: list
+board: Board
+chess_set: ChessSet
+positions: Position+chess_set: ChessSet
+chess_board: Board

67. INHERITANCE

68. Object Orientation
• INHERITANCE is the last type of relationship we’ll look at.
• Inheritance is simple, it means that one class can inherit
attributes and methods from another class.
• So often we look for classes that have a lot in common, and
create a single class with those commonalities, and use that
class to give those features to all the other classes.

69. Object Orientation
• Let’s look at an example of chess pieces:
• We know that all PIECES are part of a CHESS_SET and have a
COLOUR (so they should be in our BASE CLASS).
• Each piece has a different SHAPE attribute and a different
MOVE method to move the piece to a new position on the
board at each turn.

70. Object Orientation
Piece
+chess_set: ChessSet
+colour: Sting
Pawn
+shape: String
+move(Board)
Queen
+shape: String
+move(Board)
Castle
+shape: String
+move(Board)
Bishop
+shape: String
+move(Board)
Knight
+shape: String
+move(Board)
King
+shape: String
+move(Board)

71. Object Orientation
• Inheritance also gives us POLYMORPHISM.
• Polymorphism is the ability to treat a class differently
depending on which subclass is implemented.
• All the board has to do is call the move() method of a given
piece, and the proper subclass will take care of moving it as a
Knight or a Pawn.

72. etc.