1 COSC2767: Object-Oriented Programming Haibin Zhu, Ph. D. Associate Professor of CS, Nipissing...
-
Upload
rudolf-wilkins -
Category
Documents
-
view
217 -
download
0
Transcript of 1 COSC2767: Object-Oriented Programming Haibin Zhu, Ph. D. Associate Professor of CS, Nipissing...
1
COSC2767: Object-Oriented Programming
Haibin Zhu, Ph. D.
Associate Professor of CS, Nipissing University
2
Contact Me Haibin Zhu, Ph. D. Associate Professor of CS, Nipissing
University Room: A124A Ext.: 4434 Email: [email protected] URL: http://www.nipissingu.ca/faculty/haibinz Office Hour: Mon. & Tue.12:30pm-3:30pm;
or by appointment
3
Course Description Covers the concepts of OOP languages and
systems fundamental abstraction, modularity and
encapsulation mechanisms in OOP Advanced OOP concepts
polymorphism and operator overloading; message passing via generic functions; late versus early binding times; and inheritance mechanisms and their relationship to the type systems of programming languages.
Templates, Design Patterns Java and Eclipses
4
How to get the goals Read and remember
Read the books, remember the language Think
Think in objects, think in classes Practice
Do as many coding as possible and make them running
Ask Email me questions
5
Prerequisite Basic knowledge of
Programming COSC1557, COSC1567
6
The Textbooks Used Timothy A. Budd, The Introduction to
Object-Oriented Programming (3rd Edition), Addison-Wesley, 2001, ISBN 0201760312
Avinash C. Kak, Programming with Objects: A comparative presentation of object-oriented programming with C++ and Java, John Wiley & Sons, 2003. ISBN: 0-471-26852-6.
7
Lecture 1
Thinking in Objects
8
Contents
Methodology(Philosophy) Programming Techniques Object-Oriented Languages Object and Large Systems
9
Thinking Methodology
Induction (Abstract) From specialization to generalization
From different dogs to create the word “dog”
Dog
10
Thinking Methodology
Deduction(infer) From generalization to specialization
From the word “dog” you have learnt to know an animal is or not a dog.
DOG
11
Design Methodologies
Functional decomposition (Top-Down) The whole system is characterized by a
single function, and then the function is decomposed into a set of functions in a process of stepwise refinement.
12
Functional decomposition
The System
Function1 Function2 Function3
Function11 Function12
. . . . . .
. . . . . .
. . . . . .
Studying
Desk Table top Filing cabinet Bookshelves
Left drawer Middle drawer Right drawer
13
Design Methodologies Functional composition (bottom-up)
You can have different components of functions such as that from a function library
You can compose them into a module with a more significant function.
14
Functional composition
The System
Function1 Function2 Function3
Function11 Function12
. . . . . .
. . . . . .
. . . . . .
Studying
Desk Table top Filing cabinet Bookshelves
Left drawer Middle drawer Right drawer
15
Functional (De)Composition
Also known as top-down development Widely deemed to be a “good thing” Regard thing to be developed as a hierarchy State top level, and decomposing into smaller
functions. Decomposition continues until code level. Modules with well-defined semantics that can be
directly implemented. Procedures owe the data Data plays a secondary role Does not necessarily reflect the states of
abstraction in the application.
16
Object-Orientation
It is a kind of thinking methodology Everything in the world is an object; Any system is composed of objects (certainly
a system is also an object); The evolution and development of a system
is caused by the interactions among the objects inside or outside the system
17
Everything in the world is an object
A flower, a tree, an animal A student, a professor A desk, a chair, a classroom, a building A university, a city, a country The world, the universe A subject such as CS, IS, Math, History, …
18
Any system is composed of objects
A law system A cultural system An educational system An economic system An Information system A computer system
19
The development of a system is caused by the interactions
Nipissing University is developed by the interactions among: students professors staffs officers of Ontario officers of Canada … ...
Inside Nipissing
Outside Nipissing
20
Design Methodologies Object-Orientation is one of the
computational thinking methodologies. Object-Orientation is a kind of design
methodology(OOA/OOD) Objects are the building blocks of the
program(interface object(editor, menu, file, etc), data managing object(db), etc.).
Objects represent real-world abstractions within the application.
21
Design Methodologies
Object-orientation supports both induction: objects -> a class
This needs the tools for OOA/OOD. and deduction: a class ->objects
This needs the programmers to learn about the class library.
22
Design Methodologies
Object-orientation supports both Top-down:
from a superclass to subclasses; complex objects to simple objects.
Bottom-up: from subclasses to a superclass Simple objects to complex objects
23
Object-Orientation “The World is Object-Oriented”
----Alan Kay said. If you know the world, you know object-
orientation. So, object-orientation is easy.
24
Programming is like writing. If you can write a demonstration, you
can make a program. So, programming is also easy. Then, Object-oriented programming
equals easy + easy, that’s too(2) easy.
Programming
25
Programming
But, actually, programming is not so easy, because a real good program is not easily programmed. It needs the programmers’ lots of wisdom, lots of knowledge about programming and lots of experience.
It is like writing, to be a good writer needs lots of experience and lots of knowledge about the world.
Learning and practice are necessary.
26
Programming Techniques
The evolution of programming techniques is to make programming languages
more expressive to develop complex systems more
easily
27
Programming Techniques
Unstructured Programming Procedural Programming Modular & Structural Programming Abstract Data Type Object-Oriented Programming
28
Unstructured Programming
Usually, people start learning programming by writing small and simple programs consisting only of one main program. Here ``main program'' stands for a sequence of commands or statements which modify data which is global throughout the whole program.
Main Program
Data
29
Drawbacks
This programming technique can only be used in a very small program.
For example, if the same statement sequence is needed at different locations within the program, the sequence must be copied. If an error needed to be modified, every copy needs to be modified.
This has lead to the idea to extract these sequences(procedure), name them and offering a technique to call and return from these procedures.
30
Procedural Programming
With procedural programming, you are able to combine sequences of calling statements into one single place.
A procedure call is used to invoke the procedure. After the sequence is processed, flow of control proceeds right after the position where the call was made .
Main Program
Procedure
31
Procedures With parameters and sub-procedures
(procedures of procedures) , programs can now be written more structured and error free.
For example, if a procedure is correct, every time it is used it produces correct results.
Consequently, in cases of errors you can narrow your search to those places which are not proven to be correct.
32
Now a program can be viewed as a sequence of procedure calls.
The main program is responsible to pass data to the individual calls, the data is processed by the procedures and the resulting data is presented.
Thus, the flow of data can be illustrated as a hierarchical graph, a tree.
Procedure Program view
33
Procedure Program view
Main Program
Data
Procedure1Procedure2 Procedure3
34
Modular Programming Modular programming is subdividing your
program into separate subprograms such as functions and subroutines.
With modular programming, procedures of a common functionality are grouped together into separate modules.
A program therefore no longer consists of only one single part. It is now divided into several smaller parts which interact through procedure calls and which form the whole program.
35
Main Program(Also a module)
Data
Data Data1
Module2
+Data Data2
Module1
+Data Data1
Procedure1Procedure2
The main program coordinates calls to procedures in separate modules and hands over appropriate data as parameters.
Procedure3
36
Modular Programming
Each module can have its own data. This allows each module to manage an internal state which is modified by calls to procedures of this module.
Each module has its own special functionalities that supports the implementation of the whole program.
37
Structural Programming Also structured programming A subset of procedural programming that
enforces a logical structure on the program being written to make it more efficient and easier to understand and modify.
Certain languages such as Ada, Pascal, and dBASE are designed with features that encourage or enforce a logical program
38
Structural Programming
Three Types of Structures in a structured program
Statement sequence(s1,s2,…,sn)
Branch(if-then-else)
Loop(for,do, and while loops)
Keep no goto!!! Keep modules!!!
How many basic structures for programming?
39
Abstract Data Types (ADTs) A set of data values and associated
operations that are precisely specified independent of any particular implementation.
Come with Modular Programming Abstraction Model Properties of Abstract Data Types Abstract Data Types and Object-Orientation
40
Abstraction: Handling Problems
A process of generalization by reducing the information content of a concept or an observable phenomenon, typically in order to retain only information which is relevant for a particular purpose.
Try to understand the problem to separate necessary from unnecessary details: You try to obtain your own abstract view, or model,
of the problem. This process of modeling is called
abstraction.
41
Problem Model
Abstraction
Two of the most important types of abstraction are the following: Division into parts: Has-A abstraction Division into specialization: Is-A
abstraction
42
Has-A Abstraction Division into parts takes a complex system,
and divides into component parts, which can then be considered in isolation. Characterized by sentences that have the words ``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.
43
Is-a Abstraction Is-a abstraction takes a complex system, and
views it as an instance of a more general abstraction. 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 artifacts and
information and make it applicable to many different situations.
44
Model A model is an abstraction or conceptual
object used in the creation of a predictive formula or a solution.
A model defines an abstract view to the problem and focuses only on problem related stuff and that you try to define properties: the data which are affected; the operations which are identified;
ADT is a kind of Model.
45
•Abstract data types are a partial solution to models •ADT defines the interface to a data abstraction without specifying implementation detail.
Abstract data types(ADT)
46
Properties of ADT With abstraction, you create (1) a well-
defined entity which can be properly handled.
These entities define (2) the data structure of a set of items. For example, each administered employee
has a name, date of birth and social number....
47
Properties of ADT(Cont’d)
The data structure can only be (3) accessed with defined operations. This set of operations is called interface and
is exported by the entity. An entity with the properties just
described is called an abstract data type (ADT).
48
Interface
Operations
Abstract Data Structure
Abstract Data Type
ADT
49
Definition (ADT)
ADT is characterized by the following properties: 1. It exports a type. 2. It exports a set of operations. This set is
called interface. 3. Operations of the interface are the only
access mechanism to the type's data structure.
4. Axioms and preconditions define the application domain of the type.
50
Example: ADT List
Type List. The interface to instances of type List is
defined by the interface definition file. Operations: insert, get, append,
delete,search,…
51
List The application domain is defined by the
semantics meaning of the provided operations. Axioms and preconditions include statements such as ``An empty list is a list.'' ``Let l=(d1, d2, d3, ..., dN) be a list. Then
l.append(dM) results in l=(d1, d2, d3, ..., dN, dM).''
``The first element of a list can only be deleted if the list is not empty.''
52
Encapsulation(1)
Combine the data and the operations Enclosing of both variables and functions Keep details of the data and operations from
the users of the ADT Once you have created an ADT for complex
numbers, say Complex, you can use it in the same way like well-known data types such as integers.
53
Encapsulation(2) Allows Modularity Controlled access to data Separates implementation from
interface It extends the built-in types
54
Object-Oriented Programming
Object is derived from abstract data type Object-oriented programming has a web of
interacting objects, each house-keeping its own state.
Objects of a program interact by sending messages to each other.
55
Object1
Data1+Procedures1
Data Data1 Object3
Data3 + Procedures3
Object2
Data2 + Procedures2
Object4
Data4 + Procedures4
56
Object-Oriented Programming
In object-oriented programming , instead of calling a procedure which we must provide with the correct handle, we would directly send a message to the object in questions.
Roughly speaking, each object implements its own module.
57
Object-Oriented Programming
Each object is responsible to initialize and destroy itself correctly.
Consequently, there is no longer the need to explicitly call a creation or termination procedure.
58
Kay’s Description of OOP Everything is an object Objects perform computation by making requests of
each other through the passing of messages Every object has it's own memory, which consists of
other objects. Every object is an instance of a class. A class
groups similar objects. The class is the repository for behavior associated
with an object Classes are organized into singly-rooted tree
structure, called an inheritance hierarchy.
59
ADT and Object-Orientation
ADTs allows the creation of instances with well-defined properties and behavior.
In object-orientation, ADTs are referred to as classes.
Therefore, a class defines properties of objects which are the instances in an object-oriented environment.
60
ADT and Object-Orientation(2)
ADTs define functionality by putting main emphasis on the involved data, their structure, operations as well as axioms and preconditions.
Object-oriented programming is ``programming with ADTs'': combining functionality of different ADTs to solve a problem.
Therefore instances (objects) of ADTs (classes) are dynamically created, destroyed and used.
61
ADT and Object-Orientation(3)
•ADTs still lack self-reference and conceptual locality of objects.•Data types and operations are almost objects, but need to put them together and give the result a name which can be self-referenced.
62
A Formula
Object-Orientation = Object (Abstraction) + Class (ADT & Classification) + Inheritance (Reusing) + Dynamic Binding (Polymorphism,
Flexibility)
63
Inheritance(Hierarchy)
Expresses commonality among objects Allows code reusability Highlights Generalization/Specialization
relationships We will learn more in the following
lectures.
64
Polymorphism
The ability of objects to respond differently to the same message or function call.
We will discuss more in the following lectures.
65
Modules Information hiding Data encapsulation Abstract data types Classes and Objects
Object-Orientation Evolution
66
Simply Remember
Encapsulation(Data & Operations)--- A technique for Information Hiding-----the users of the objects could not see the details of the data and operations of the objects.
Data Abstraction ---- the procedure to find a class from objects.
Abstract Data Type---- Class.
67
Object-Oriented Languages An object-based programming language is one
which easily supports object-orientation. Smalltalk:1972-1980, Alan Kay C++:1986, Bjarne Stroustrup Java:1992 (Smalltalk + C++), James Gosling C#:
Developed at Microsoft by Anders Hejlsberg et al, 2000 Event driven, object oriented, visual programming
language (C++ and Java) Others:
Effile, Objective-C, Ada, ...
68
Programming in the Small and Programming in the Large
Programming in the Small: One programmer, understands everything from
top to bottom. Major problem is the development of algorithms.
Programming in the Large: System is developed by large team of
programmers Major problems are management of details and
communication between programmers and between their respective software subsystems.
69
Programming in the Small: One programmer, understands everything from
top to bottom. Major problem is the development of algorithms.
Programming in the Large: System is developed by large team of
programmers Major problems are management of details and
communication between programmers and between their respective software subsystems.
Objects and Large Software Systems(1)
70
Objects and Large Software Systems(2)
Object view Makes systems more intuitively understandable Unifies design and programming method Initial program thoughts are informal objects-and-
interactions descriptions, even when using a non-OO language.
Divides code into logical chunks individuals of a team can be experts in, and outsiders can understand via interfaces
Allows "off the shelf" code libraries to be reused Supports code evolution: internals can always be re-
written as long as interface stays the same
71
Objects and Large Software Systems(3)
So, in large software system, we need more CONCEPTS and STRUCTURES of object-orientation than PROGRAMMING SKILLS
Those are OOA(Object-Oriented Analysis) and OOD(Object-Oriented Design), that will be discussed more deeply in Software engineering or Software designing methodology.
72
Summary Methodology (Philosophy) Programming Techniques Object-Oriented Languages Object and Large Systems
73
The End
The End of Lecture 1