Old Programming Paradigm

• Computer system consists of data and

programs.
Object Oriented Programming • Programs manipulate data.
• Programs organized by
• functional decomposition
Based on Levent Akın’s CmpE160 • dataflow
Lecture Slides
• modules

1 2

New Programing Paradigm Object Oriented Programming

• Computer system consists of a set of • consists of the following major concepts:

objects. • Abstraction
• Objects are responsible for knowing and • Encapsulation
doing certain things. • Polymorphism
• Objects collaborate to carry out their • Inheritance
responsibilities.
• Programs organized by classes,
inheritance hierarchies and subsystems
3 4
 Abstraction Abstraction and Information Hiding
• separation of a data type’s logical
properties from its implementation
• the process of representing data about real-
• Problem solvers have traditionally used
world things in software abstraction to manage system complexity.
• examples of abstractions:
• The focus in using abstraction is to define
Thing Abstraction Examples a part or component of a system so that
Person academic records this component can be viewed as a black
medical information
job history
box.
• The component can be understood without
Car garage records knowing its details or specifics.
official records
• There is no need to know how this component
is to be used at a higher level.
5 6

Procedural Abstraction Data Abstraction

• All programming languages support • Several programming languages, such

abstraction through subprogram
constructs (e.g., procedures and
functions). This type of abstraction is
usually called procedural abstraction.
as Eiffel, Java, and C++, support data
abstraction.
• The purpose of data abstraction is to
view each data structure or object as
consisting of data values and operations
on these values.

7 8
 Information Hiding
• The purpose of information hiding is to
make inaccessible certain details that do
not affect the other modules in the
system.
• Hence, the data type and its actions
constitute a closed system, the details of
which are hidden from the other
modules.
9 10
Polymorphism
• ability to determine which of several
operations with the same name should
be performed
• from one, many forms
• example: function overloading
• in programming, allow the compiler or
run-time circumstances to decide which
form to use
11
Encapsulation
• association (bundling) of data and the
operations that can be performed on that data
• separates the representation of data from the
applications that use that data by “hiding” the
data; i.e. not allowing the programmer to
manipulate the data except by the associated
operations
• enforces information hiding
Binding Time
• time at which a name or symbol is
bound to the appropriate code or value
• static binding – compile-time binding;
example: function overloading
• dynamic binding – run-time binding;
example: virtual function overloading
• polymorphism is a combination of both
static and dynamic binding
12
 Overloading and Binding Time Inheritance

• overloading functions allows compiler to • a mechanism used with a hierarchy of

decide what to call or create classes by which each descendant class
inherits the properties (data and
• usually done at static binding time
operations) of its ancestor class
• creation of new encapsulated types from
existing encapsulated types
• allows incorporation of existing features
with additions and replacements

13 14

Inheritance Detailed Program Specification

• derived class – class that inherits

• Tells what the program
• base class – class that is inherited
must do, but not how it
does it.

• Is written documentation
about the program.

15
 Heart of Object-Oriented Programming Modeling

• Don't make a new language, extend
your old one.
• Objects should be abstractions of
problem domain.
• All phases of software life-cycle are
modeling
• analysis - modeling of problem
• design - modeling of solution
• implementation - making model run on a
computer
• maintenance - fixing/extending your model

17 18

Assumption about Modeling Modeling

• Basing system design on structure of • Claim: people model the world with
problem makes system "objects"
• more reusable • objects
• more extensible • classes
• relationships between objects
• relationships between classes

19 20
 Modeling Objects and Relationships

• Advantages of object-oriented software • Ahmet is Ece's father. Ece is Ahmet's

development daughter.
• more natural - matches the way people • Kurt is Kemal's dog. Kemal is Kurt's
think owner.
• single notation - makes it easy to move
• Fatma is Cemal's employer. Cemal is
between software phases
Fatma's employee.

21 22

Objects and Attributes Objects and Behavior

• Ahmet's name is “Ahmet Kara". • Ahmet goes on a trip.

• Ahmet's age is 27. • Ahmet makes reservations.
• Ahmet's address is Nispetiye Cad. No • Ahmet buys tickets.
15/1, Etiler • Ahmet travels by airplane.
• What about Ahmet's job? Ahmet's wife? • Ahmet checks into hotel.

• What is an attribute, and what is a

relationship?

23 24
 What Really is an Object? What Really is an Object?

• Reservation -- a promise to give service • Anything we can talk about can be an

to a customer object, including relationships ("the
• Ticket -- proof that customer has paid for husband of the first party", "first-born
service in advance son").
• Flight • What are we trying to model?
• Payment -- an event (transaction?) in • Models should be as simple as possible,
which money is exchanged but no simpler.

25 26

Classification Classification

• We naturally put objects into classes • Ahmet is an employee.

that have similar characteristics. • Ahmet is a father.
• Hasan is a man. Mammals • Ahmet is a sky-diver.
• Ayşe is a woman. • Ahmet is under 30.
Dogs People
• Kurt is a dog.
Women Men
• All women are people. Kurt • Is Ahmet an instance of Employee,
• All people are mammals. Ayşe Hasan Father, Sky-diver, and Under30?

27 28
 C++ class data type
• A class is an unstructured type that
encapsulates a fixed number of data
components (data members) with the
functions (called member functions) that
manipulate them.
• The predefined operations on an instance
of a class are whole assignment and
component access.
29
C++ Classes
• a class must be designed (naming of
all members and the properties of
those members) and then
implemented (statements written)
• an instance of a class is created by
declaring an object variable of that
class
31
C++ Classes
• primary instrument of object oriented
programming in C++
• allows the user to design true types by
• abstraction of data about the thing being
modeled and
• encapsulate the results of that abstraction with
the operations that will work on that type
• the parts of a class are called its members
• members can be data objects (variables)
and functions to manipulate the data
objects
30
Class Specification (Definition) Statement Syntax
class className
{
… member-list …
};
where member-list is a listing of the
functions and data objects of the
class
32
 Member Access Modifiers Member Access Modifiers

• access modifiers set how a member may be • protected – like private, but can be
accessed
• all members in a class are given an access inherited
modifier • all members of a class are private by
• public – indicates that the member may be default
accessed by code outside of the class and
can be inherited • access is always explicitly stated by
• private – indicates that the member may convention
only be accessed by code inside of the
class and cannot be inherited

33 34

Accessor and Mutator Functions class DateType Specification

• Accessor function member: function that only // SPECIFICATION FILE ( datetype.h )

accesses (does not modify) the value(s) of the class DateType // declares a class data type
{
data member(s)
public : // 4 public member functions
• Mutator function member: function that
void Initialize (int newMonth, int newDay, int newYear ) ;
modifies the value(s) of the data member(s) int YearIs( ) const ; // returns year
int MonthIs( ) const ; // returns month
• Constant function member: function that int DayIs( ) const ; // returns day
cannot modify data members and includes the private : // 3 private data members
reserved word const at the end of the
int year ;
function heading int month ;
int day ;
} ;
35 36
 Use of C++ data type class Client Code Using DateType
#include <iostream>
• Variables of a class type are called objects #include “datetype.h” // includes specification of the class
(or instances) of that particular class. using namespace std;
int main ( void )
{
• Software that declares and uses objects of DateType startDate ; // declares 2 objects of DateType
the class is called a client. DateType endDate ;
bool retired = false ;
startDate.Initialize ( 6, 30, 1998 ) ;
• Client code uses public member functions endDate.Initialize ( 10, 31, 2002 ) ;
(called methods in OOP) to handle its class cout << startDate.MonthIs( ) << “/” << startDate.DayIs( )
objects. << “/” << startDate.YearIs( ) << endl;
while ( ! retired )
{ finishSomeTask( ) ;
• Sending a message means calling a public . . .
member function. }
}

37 38

2 separate files generally

used for class type DateType Class Instance Diagrams

// SPECIFICATION FILE ( datetype .h )

// Specifies the data and function members.
class DateType
{
startDate endDate
public:
. . .

private:
. . . Private data: Private data:
} ; Initialize Initialize
year 1998 year 2002
YearIs YearIs
// IMPLEMENTATION FILE ( datetype.cpp ) month 6 month 10
MonthIs MonthIs
day 30 day 31
// Implements the DateType member functions.
DayIs DayIs
. . .

39 40
 Implementation of DateType
member functions
int DateType :: MonthIs ( ) const
// IMPLEMENTATION FILE (datetype.cpp) // Accessor function for data member month
#include “datetype.h” // also must appear in client code {
return month ;
void DateType :: Initialize ( int newMonth, int newDay, }
int newYear )
// Post: year is set to newYear. int DateType :: YearIs ( ) const
// month is set to newMonth. // Accessor function for data member year
// day is set to newDay. {
{ return year ;
year = newYear ; }
month = newMonth ;
day = newDay ; int DateType :: DayIs ( ) const
} // Accessor function for data member day
{
return day ;
41 42
42
}

Familiar Class Instances

and Member Functions Scope Resolution Operator ( :: )

• The member selection operator ( . ) selects either data
members or member functions.
• Header files iostream and fstream declare the istream,
ostream,and ifstream, ofstream I/O classes.
• Both cin and cout are class objects and get and ignore
are member functions.
cin.get (someChar) ;
cin.ignore (100, ‘\n’) ;
• These statements declare myInfile as an instance of
class ifstream and invoke member function open.
ifstream myInfile ;
myInfile.open ( “A:\\mydata.dat” ) ;
• C++ programs typically use several class types.
• Different classes can have member functions with the
same identifer, like Write( ).
• Member selection operator is used to determine the
class whose member function Write( ) is invoked.
currentDate .Write( ) ; // class DateType
numberZ .Write( ) ; // class ComplexNumberType
• In the implementation file, the scope resolution
operator is used in the heading before the member
function’s name to specify its class.
void DateType :: Write ( ) const
{ . . .

43 } 44

Namespace
namespace mySpace
{
// All variables and functions within this
// block must be accessed using scope
// resolution operator (::).
} • Using directive:
Purpose: Avoid namespace pollution.
45
Rules for Use of Namespace std
(within text)
• Qualify names in prototypes and/or
function definitions.
• If name used more than once in a
function block, use a using declaration.
• If more than one name is used from a
namespace, use a using directive.
47
Three Ways to Access Members
within a Namespace
• Qualify each reference:
mySpace::name with every reference.
• Using declaration:
using mySpace::name;
All future references to name refer to mySpace::name.
using namespace mySpace;
All members of mySpace can be referenced without
qualification.
46
Exceptions
• An exception is an unusual situation that
occurs when the program is running.
• Exception Management
• Define the error condition
• Enclose code containing possible error (try).
• Alert the system if error occurs (throw).
• Handle error if it is thrown (catch).
48
 try, catch, and throw Exception Example

try #include <iostream>

{ #include <fstream>
// code that contains a possible error #include <string>
… throw string(“An error has occurred in using namespace std;
function …”);
int main()
{
}
catch (string message)
double d, e;
{ ifstream inFile;
std::cout << message << std::endl; inFile.open("data.dat");
return 1;
}
49 50

Exception Example

try
{
inFile >> d;
if (d == 0)
throw string(“Not acceptable");
e = 1.0/d;
}
catch (string message)
{
cout << "Bad Data! Program aborted!" << endl;
exit(1);
}
inFile.close();
cout << e << endl;
return 0;
}
51