Upload
alexia-dana-cummings
View
214
Download
1
Tags:
Embed Size (px)
Citation preview
04/19/23 Assoc. Prof. Stoyan Bonev 1
COS240 O-O Languages AUBG, COS dept
Lecture 01Title:
OOP Basic Intro
Reference: COS240 Syllabus
04/19/23 Assoc. Prof. Stoyan Bonev 2
Lecture Contents:
• OOP Aspects• OOP Concepts• OOP Characteristics• OOP Terminology
04/19/23 Assoc. Prof. Stoyan Bonev 3
Software crisis
• Edsger Dijkstra, a Computer Science pioneer, explained the major cause for the software crisis:
• “... machines have become several orders of magnitude more powerful. To put it quite bluntly: as long as there were no machines, programming was no problem at all; when we had a few weak computers, programming became a mild problem, and now we have gigantic computers, programming has become an equally gigantic problem.”
04/19/23 Assoc. Prof. Stoyan Bonev 4
Software crisis
• In order to resolve software crisis, a variety of programming styles or paradigms or approaches or methodologies appeared.
5
Programming Paradigms
Other programming paradigms besides object-oriented are
- the imperative (or procedural) programming paradigm (e.g. languages such as Pascal or C)
- the logic programming paradigm (e.g. Prolog)
- the functional programming paradigm (e.g. LISP, ML or Haskell)
See course COS220 – Concepts of Programming Languages
Object-oriented and imperative programming paradigms are by far the most popular paradigms.
6
Imperative Programming Paradigm
Imperative language
=
Behaviour (i.e. operations: code in terms of procedures and/or functions)
+
Data structures (which are separate from behaviour)
Viewed as separate entities or Viewed as separate entities or Algorithms + Data Structures = ProgramsAlgorithms + Data Structures = Programs
7
Object-Oriented language
Classes and Objects
+
Inheritance
+
Communication via Messages
=
Object-Oriented Paradigm
Commonly performed with method (procedure/function)call, with call parameters
Data and behaviour areData and behaviour areencapsulatedencapsulated
in the classin the class
04/19/23 Assoc. Prof. Stoyan Bonev 8
What is Programming?
• Or different Aspects of Programming.
9
Aspects of Programming
Programming has many “aspects” or characteristics.
E.g.
Programming is controlling- computer does exactly what you tell it to.
Programming is problem solving- always trying to make computer do something
useful, e.g. finding an optimal travel route.
Programming is creative- must find a good solution out of many possibilities.
10
Two more aspects which are important for this course are
Programming is modeling- describe the relevant properties and behaviours of a
problem as a system of components, i.e. objects.
Programming is abstraction – identify important features of a problem without
getting lost in detail– ignore irrelevant features of problem.
11
These last two aspects are important for this course:
- When we write a program, we are actually creating a model of some real-world problem.
- In order to reduce the complexity of the problem, we use the concept of abstraction to simplify the model.
12
Abstraction
Abstraction is used to decrease the level of complexity of a problem.
In order to develop a class for one or more objects, it is important to abstract (i.e. consider) only the important attributes (data structures) and operations (methods) from the problem - only the ones that matter for the software solution.
Extraneous (i.e. irrelevant) detail should be omitted from consideration.
Note: for two different implementations of the same problem, the attributes and methods that are considered to be relevant may differ! See next slide!
13
Abstraction
14
- A cat object for a house lady
would have totally different characteristics (abstractions) compared to
- A cat object for a veterinary surgeon.
Both are cat objects (but different!).
It all depends on the problem to be solved – a cat object for a house lady or one for a vet.
15
Abstraction
16
Main concept
Object-oriented programming is creating a collection of independent, but cooperating, active "agents" ( “objects” or “instances”) that, working together, accomplish some desired task.
A popular approach to object-oriented program design is to concentrate on the responsibilities of objects.
- a responsibility is some defined behaviour of an object.
An object’s responsibilities are high-level statements about both the knowledge it maintains and theoperations it supports.
17
The Object-Oriented Mantra
• Objects do the work. The work is done by “instance methods” of the appropriate class.
• Well designed objects have clear responsibilities and clear interfaces.
• Objects are instances of a class. Their behaviour is implemented in instance methods.
18
Objects have behaviours
• In imperative/procedural programming, programs have– data, which is completely passive– functions/procedures, which can manipulate any data
• In OO programming, an object contains both data and methods that manipulate that data.– An object is active, not passive; it does things.– An object manages its own data.
• It can protect that data (by marking it private).• It can expose that data to other objects (by not
marking it, or by marking it public).• Data should not be exposed without good reason.
19
Objects have state
• An object contains data (members)
– The data represent the state of the object.
– Data can also describe the relationship of the object to other objects.
20
Object
21
22
Classes and Objects
• All objects are instances or members of a class.
• A class is a description of one or more similar objects– It is a template or blueprint for the object.
• Instance is an object described by a particular class.
• All objects of a given class use the same method (operation) in response to similar “messages”.
• Class provides a template for an object - it contains the definition of the data items comprising the object, and the implementation of the operations (behaviour) allowed on the object.
A rough approximation is to say that a class is an abstract data type.
23
Example
• A car encapsulates lots of information
• But, you do not need to know how a car works in order to use it– steering wheel and gear shift are the interface.– engine, transmission, gears, wheels, . . . are the
(hidden) implementation.
24
Likewise, you do not need to know how an object works in order to send messages to it.
But, you do need to know what messages it understands (i.e. what its capabilities are)
- the class of the instance determines what messages can be sent to it.
25
The eight fundamental concepts (“quarks”) of the object-oriented paradigm:
- Abstraction- Encapsulation- Information Hiding- Class- Object- Method- Message Passing- Polymorphism
See: Armstrong, “The Quarks of Object-Oriented Development”, in Communications of the ACM, 49:2, p.123-128, Feb 2006
26
Some people think the list should be extended to include such “quarks” as
- inheritance
- subtyping
- overriding
- reuse
27
Revision of Main Points1. Abstraction is the process of generalization of a real-world problem by reducing its information content, typically in order to retain only information which is relevant for a software solution, i.e. program.
It is a process of simplification – concentrating only on relevant problem details, while ignoring the irrelevant ones
- this greatly simplifies the design of the solution.
We use abstraction to “model” real-world objects.
E.g. for a person object, relevant details that we may wish to “model” may be name, address, age, sex, …and irrelevant details that we can “forget about” for our model may be eye and hair colour, shoe size, …
28
Forms of Abstraction
• Specialization – class hierarchies• Division in parts – aggregation • Multiple Views – polymorphism
• “Is-a” is a specialization• “Has-a” is an aggregation• ?? is a polymorphism
29
2. In object-oriented programming, encapsulation is the concept of keeping together data and the methods (aka functions) which act on them – the grouping of data and the methods that manipulate them together in a single software entity: the class.
30
3. Information hiding is the principle that a class should not expose its data to “users” (aka clients) of the class, but rather should offer an interface allowing users to access the class data indirectly. This allows the modification of how the data in the class is represented, and how the method algorithms are implemented, without changing the interface.Doing so, decouples the implementation of the class from its clients, which helps with making the code reusable.
An interface specifies what “services” or operations (i.e. methods) the class provides for its clients. It is the public view of the class.
31
Objects separate interface from implementation
- object implementation is “black box,” hiding internal workings and parts.
- object interface protects implementation from misuse.
Interface: public view- allows instances to cooperate with one another
without knowing too many details.- like a contract: consists of a list of capabilities
and documentation for how they can be used.
Implementation: private view- properties that help capabilities complete their
tasks.
32
An abstract data type (ADT) is a specification of a set of data, and the set of operations (i.e. procedures/functions) that can be performed on that data.
- It is a programmer-defined data type.
4. Classes are the mechanism for expressing abstract data types in object-oriented languages.
A class is a template or blueprint for an object. It specifies what data and operations exist for the class.
5. An object is an instance of a class.
An object is an instance of the data type, class.
Each object has state (aka attributes data), behaviour (aka operations) and a unique identity.
33
6. Method a way to access, set or manipulate an object’s information.
7. Message Passing the process by which an object sends data to another object or asks the other object to invoke a method.
8. Polymorphism is the ability of objects belonging to different types to respond to method calls of the same name, each one according to an appropriate type-specific behaviour.
34
Class Interface Diagram
Private data
hrs
mins
secs
SetTime
Increment
GetTime
Time(…)
Time
Time class
Constructors
Interface
Implementation
Public
35
Object-Oriented Programming Elements
1. An object-oriented program is structured as a “community” of interacting “agents” called objects.
2. Computation is performed by the objects communicating with each other, requesting that other objects perform some actions for the requesting object.
Objects communicate by sending and receiving messages.
A message is a request for some action, bundled with whatever information (i.e. parameters) may be necessary to complete the task.
36
3. Every object is an instance of a class.
A class simply represents a grouping (or template) of similar objects, such as integers, or lists, or whatever.
4. The class is the repository for behaviour associated with an object.
That is, all objects, that are instances of the same class, perform the same actions.
5. Classes may be organized into a singly-rooted tree structure, called an inheritance hierarchy.
Data and behaviour associated with instances of a class are automatically available to any class that is a descendant in this tree structure.
04/19/23 Assoc. Prof. Stoyan Bonev 37
More on Abstraction in OOP
• .
38
Levels of Abstraction in O-O Programs
An O-O program may be viewed from many levels of abstraction.
At the highest level of abstraction, we may view an O-O program as a community of interacting objects.
Important characteristics here are the lines of communication between the various agents (i.e. objects),
indicating interactions.
39
Abstraction in OO Programs - Units
The next level of abstraction is found in many (but not all) OO languages.
These languages permit a group of “agents” (classes or methods) working together to be combined into a “unit”.
Examples of a “unit”:
- package in Java
- namespace in C++ and C#
- class in C++, C# and Java
- Module in VB
40
“Units” allow a programmer to surround a collection of agents (a small community in itself) with a “box”, and control visibility from outside the unit (information hiding).
The “unit” also provides encapsulation – it groups together a set of agents working together.
41
Note: a class provides encapsulation at different level of abstraction compared to namespace and package.
A class groups together the attributes and operations of a single object, whereas namespaces and packages group together classes.
Modularity
Modular system – in which modules can be built separately and changes in one have minimum impact on others
Modularity supports independence of models Modularity enhances design clarity, eases
implementation Reduces cost of testing, debugging and
maintenance Cannot simply chop a program into modules
to get modularly Need some criteria for decomposition
Modularity
Criteria for achieving modularity: – coupling of modules
Low coupling is desirable, subject of Soft Eng – module cohesion
High cohesion is desirable, subject of Soft Eng – open closed principle – Liskov’s principle
Open-closed Principle
Principle: A module should be open for extension but closed for modification
Behavior can be extended to accommodate new requirements, but existing code is not modified
I.e. allows addition of code, but not modification of existing code
Minimizes risk of having existing functionality stop working due to changes – a very important consideration while changing code
Good for programmers as they like writing new code
Open-closed Principle… In OO this principle is satisfied by using
inheritance and polymorphism Inheritance allows creating a new class
to extend behavior without changing the original class
Consider example of a client object which interacts with a printer object for printing
Example
Example.. Client directly calls methods on Printer1 If another printer is to be allowed
A new class Printer2 will be created But the client will have to be changed if it
wants to use Printer 2 Alternative approach
Have Printer1 as a subclass of a general Printer For modification, add another subclass Printer
2 Client does not need to be changed
Example…
Liskov’s Substitution Principle
Principle: Program using object o1 of base class C should remain unchanged if o1 is replaced by an object of a subclass of C
If hierarchies follow this principle, the open-closed principle gets supported
Summary
Modularity is the criteria for deciding quality of the design
Modularity enhanced by low coupling, high cohesion, and following open-closed principle
51
Abstraction in OO Languages – Object Clients and Servers
The next level of abstraction considers the relationship between two individual objects.
Typically one object (server) is providing a service, and the other object (client) is using the service.
52
Abstraction in OO Languages - Description of Services
We can next examine just the “unit” providing a service, independent of the client.
We define the nature of the services that are offered, but not how those services are realized, i.e. implemented.
Example: operations for an integer stack data structure
void push(int val); // push data item onto stack
int pop(); // pop data item from stack
Services need to be declared as public, otherwise they will not be visible (i.e. accessible) to clients!
53
Services offered:
push a data item onto the stack
pop a data item from the stack
Services offered:
push a data item onto the stack
pop a data item from the stack
54
Interfaces are used to describe services at this level of abstraction.
A (service) interface is a mechanism that defines behaviour without describing an implementation.
It “advertizes” the services provided by a class – the public interface, i.e. the methods available to client classes and how they may be used.
E.g. interface in C++ for a stack:
class Stack { public: void push(int val); int pop(); ...};
Note that the use of the word“interface” here is not the same
as the syntactic entityinterface found in Java and C#.
55
Levels of Abstraction - An Implementation
Next we look again at the services provided, but this time from the implementation side.
E.g. in C++ for a stack
class Stack { public: void push(int val); int pop(); private: const int StackSize = 40; int top: int data[StackSize];};
Concern here is with the high-level approach to providing the designated service. Here, an array is being used to implement the Stack.
56
Levels of Abstraction - A Method in Isolation
Finally, we consider the implementation of each method in isolation – the precise sequence of operations required.
E.g. in C++
class Stack { public: void push(int val); int pop(); private: const int StackSize = 40; int top: int data[StackSize];}; int Stack::pop(){ return data[top--]; }
57
Every level of abstraction is important, Every level of abstraction is important, and often you move quickly back and and often you move quickly back and
forth between levels.forth between levels.
58
Abstraction Classification
Abstraction is used to help understand a complex system
– to separate out the important details from the unnecessary ones for the software solution.
This concept of abstraction can be subdivided into a variety of different forms …
59
60
“Is-a” and “Has-a” abstractions
The ideas of
division into parts and
division into specializations
represent the two of the most important forms of abstraction used in object-oriented programming.
These two important types of abstraction are
• Division into parts “Has-a” abstraction
• Division into specialization “Is-a” abstraction
61
“Has-a” Abstraction
Division into parts takes a complex system, and divides it into component parts, which can then be considered in isolation.
It is characterized by sentences that have the words such as “has-a”
• A car has-a engine, and has-a transmission • A bicycle has-a wheel • A window has-a menu bar
Allows us to drop down a level of complexity when we consider the component in isolation – specialization.
Works downwards
62
Is-a Abstraction
Is-a abstraction takes a complex system, and views it as an instance of a more general abstraction.
It is characterized by sentences that have the words “is-a”
• A car is-a wheeled vehicle, which is-a means of transportation • A bicycle is-a wheeled vehicle • A pack horse is-a means of transportation
Allows us to categorize an artifact and make it applicable to many different situations – generalization.
Works upwards
63
Both of the previous forms of abstraction workon a hierarchical tree of concepts – down or up.
64
Layers of Specialization
Yet another approach to dealing with complexity is to structure abstraction using layers of specialization.
This is sometimes referred to as a taxonomy.
For example, in biology, we divide living things into animals and plants.
Animals are then divided into vertebrates and invertebrates.
Vertebrates includes mammals, which can be divided into (among other categories) cats and dogs, and so on.
65
The same technique is used in object-oriented languages.
New interfaces can be formed from existing interfaces. (An interface is a syntactical construct in C# and Java. See later!)
A new class can be formed by inheriting from an existing (super) class.
In doing so, all the properties (data fields and behaviour) we associate with the original class become available to the new class.
66
67
So, a Java application may use the following methods:
setTitle(String) inherited from class Frame
setSize(int, int) inherited from class Component
show() inherited from class Window
repaint() inherited from class Component
paint() inherited from class Component
68
Inheritance Hierarchy
Another form of abstraction is a taxonomy, in object-oriented languages more often termed an inheritance hierarchy or generalization.
Here the layers are more detailed representatives of a general category.
- An example of this type of system is a biological division into categories such as
Living ThingAnimal
MammalCat
69
Living ThingAnimal
MammalCat
Each lower level is a more specialized version of the previous.
Each upper level is a generalization of the previous lower level.
04/19/23 Assoc. Prof. Stoyan Bonev 70
More on message passing
• i
71
Message-Passing Syntax
Use the term message passing (sometimes also called method lookup) to mean the dynamic process of requesting an object to perform a specific action.
In particular:
- A message always specifies some object, which is called the receiver, to perform some action.
- The action performed in response to the message is not fixed, but may differ depending upon the class of the receiver. That is, different objects may accept the same message, and yet perform different actions – different classes may have similarly-named methods.
72
Message passing in C++, C#, Java - Examples
aCard.flip();
aCard.setFaceUp(true);
aGame.displayCard(aCard, 45, 56);
Most OO languages implement message passing by invoking a class method
such as flip() or setFaceUp(true) or displayCard(aCard, 45, 56)
73
Message Passing Syntax
Although the syntax may differ in different languages, all messages have three identifiable parts: E.g.
• The receiver (the object to which the message is being sent) – the object which will perform some action.
• The selector (the text that indicates the particular message being sent) – the action, i.e. method being invoked.
• An optional list of arguments
aGame.displayCard(aCard, 42, 27)
receiver selector arguments
74
The most common syntax for message passing usesa dot operator (.) to separate the receiver from the message selector.
aCard.flip();
aCard.setFaceUp(true);
aGame.displayCard(aCard, 45, 56);
75
The Receiver Variable – accessing the receiver from within a method
A message is always passed to a receiver (i.e. the object for which a method is being invoked).
aGame.displayCard(aCard, 42, 27)
In most OO languages, however, the receiver does not appear in the argument list for the method.
Instead, the receiver is only implicitly involved in the method invocation.
But sometimes, it is necessary to access the receiver from within the method.
76
Inside a method, the receiver object can be accessed by means of a “pseudo-variable”.
A pseudo-variable is like an ordinary variable, only it need not be declared and cannot be modified – it is a syntactic keyword of the programming language.
• It is called this in Java, C++ and C#
• Every method of an object has a this reference that refers to the current object for which the method has been called.
• It is used in a method body when reference to the object itself is needed – self-reference
77
Implicit Use of This
Within a method, a message expression or a data access with no explicit receiver is implicitly assumed to refer to this, i.e. the current receiver object.
Example: code in C#
class PlayingCard {
...
public void flip() {setFaceUp(!faceUp);}
...
} A method and data variablewith no receiver specified.
78
This is assumed to be equivalent to
class PlayingCard {
...
public void flip() {this.setFaceUp(!this.faceUp);}
...}
79
Some style guidelines for Java and C# suggest the use of this when arguments in a constructor are used to initialize a data member.
The same name can then be used for the argument and a data member, with an explicit this being used to access the data member, and so distinguish between the two (identical) names.
class PlayingCard { public PlayingCard (int suit, int rank) { this.rank = rank; // this.rank is the data member this.suit = suit; // rank is the argument value this.faceUp = true; } ... private int suit; private int rank; private boolean faceUp;}
80
In C++, the pseudo-variable is a pointer – the this pointer.
Again, the this pointer can be used to refer to the invoking object inside a method.
class MyClass {
int i ...};
i = 10; // within some method - implicit
Or
this->i = 10; // explicit - equivalent
Thank Youfor
Your attention!