CSSE 501 Object-Oriented Development

Course Overview

Course Goals Fundamentals and principles of object-

oriented development Object-oriented analysis, design and

Programming

Assumptions Familiar with preliminary

programming background Data types Program control structures: sequential.

selection, repetition Streams and files (program input and

output) Simple data structures: array Compilation and execution of simple

programs

An Example (C++) // File name: HelloWorld.cpp // Purpose: A simple C++ program which prints "Hello World!" on the screen

#include <iostream> // need this header file to support the C++ I/O system using namespace std; // telling the compiler to use namespace "std",

// where the entire C++ library is declared.

int main() { // Print out a sentence on the screen. // "<<" causes the expression on its right to // be directed to the device on its left. // "cout" is the standard output device -- the screen.

cout << "Hello World!" << endl; return 0; // returns 0,which indicate the successful // termination of the "main" function

}

If not…

Decide which programming language you are going to use in this course, and pick up a book, start to read it and practice programming

No time and material in this course will be teaching you those preliminary programming experience

Course Overview

Topics Abstraction, Encapsulation Interface and Implementation, Abstract

Data Type Object-Oriented Design Principles Classes, Methods, Instances Object Communication (Message

Passing) Inheritance, Multiple Inheritance

Course Overview

Topics (Cont.) Static and Dynamic Behavior Polymorphism

Overriding, Overloading, Polymorphic Variable

Object Interconnection Coupling and Cohesion

Reflection and Retrospection Exception, Error Handling

Course Overview Course Website

http://fac-staff.seattleu.edu/daia/web/teaching/fall07/csse501/csse501.htm

Instructor Lirong Dai, Ph.D., University of Texas at Dallas

Course Duties: Material Reading In-Class Exercises/Lab Programming Assignments Midterm Final

Today…

Chapter 1: Thinking Object-Oriented Chapter 2: Abstraction

Chapter 1: Thinking Object-Oriented

Why Object-Oriented? Comparison with non-OO approaches

What is Object-Oriented?

Programming

Programming a computer involves writing instructions that enable a computer to carry out a single task or a group of tasks

These set of instructions are called as programs or software

Programming languages: Java, C++, C#…

An Example// File name: HelloWorld.cpp // Purpose: A simple C++ program which prints "Hello World!" on the screen

#include <iostream> // need this header file to support the C++ I/O system using namespace std; // telling the compiler to use namespace "std",

// where the entire C++ library is declared.

int main() { // Print out a sentence on the screen. // "<<" causes the expression on its right to // be directed to the device on its left. // "cout" is the standard output device -- the screen.

cout << "Hello World!" << endl; return 0; // returns 0,which indicate the successful // termination of the "main" function

}

A Survey of Programming Techniques/Paradigm

Unstructured Programming Procedural Programming Modular Programming Object-Oriented Programming

Unstructured Programming All code is contained in a single continuous

block (e.g., “main” program) Has to rely on flow execution statements,

such as GOTO (e.g., Spaghetti code) Still used in

MS-DOS batch files Old languages, such as BASIC, FORTRAN Assembly language

Main Programdata

Program

MS-DOS Batch File Example

rem display and check if there is an argument if "%1"=="" goto noparameter echo the parameter is %1 goto exit :noparameter echo you must supply an argument to this batch file :exit

Unstructured Programming (Cont.)

Problems Difficult to read and debug Only works for very simple and small problems Tremendous disadvantages once the program

gets sufficiently large For example, if the same statement sequence is

needed at different locations within the program, the sequence must be copied

Solution: extract these sequences, name them and offer a technique to call and return from these procedures

Procedural Programming Able to combine returning

sequences of statements into one single place

A procedure call is used to invoke the procedure Data from main program to

procedures (i.e., parameters) After the sequence is processed,

flow of control proceeds right after the position where the call was made Processed data back to main

program Procedures, also known as

routines, subroutines, methods, or functions

Main Program

Procedure

Procedure calls

C Program Exampleint add( int, int); /* Function declaration */

main() {

int i=1; printf("i starts out life as %d.", i);

i = add(1, 1); /* Procure/Function call */

printf(" And becomes %d after function is executed.\n", i); }

/********************************************************/ int add( int a, int b) /* Procure/Function definition */ {

int c; c = a + b; return c;

}

Procedural Programming (Cont.)

Languages COBOL, FORTRAN, BASIC, C, Pascal …

Problems Difficulties of reasoning about programs To some degree difficulty of

parallelization Relatively low level In large, complicated programs,

modularity is generally desirable

Modular Programming Module

Generally, a component of a larger system, and operates within that system independently from the operations of the other components

Modular Programming A common functionality are

grouped together into separate modules

A program is now divided into several smaller parts which interact through procedure calls

Main Programdata

Module1data

+data1

Module2data

+data2

Procedure1 Procedure2 Procedure3

Modular Programming (Cont.) Example: a singly linked list

Operations on the list Append element in the end Delete element at the front

Application: queue

Implement the list in two separate modules Interface definition

Describe what is available Implementation files

Describe how it is made available Fundamental principles in software engineering

Change the implementation won’t affect the interface

Singly List Interface Definition

/* * Interface definition for a module which implements * a singly linked list for storing data of any type. */

MODULE Singly-Linked-List-1

BOOL list_initialize(); /* Initialize variables local to the module BOOL list_append(ANY data);

BOOL list_delete(); list_end();

ANY list_getFirst(); ANY list_getNext(); BOOL list_isEmpty();

END Singly-Linked-List-1

Singly List (Cont.) What if we need more than one list in the program?

/* * A list module for more than one list. */

MODULE Singly-Linked-List-2

DECLARE TYPE list_handle_t; /* list_handle_t represents list handle, which is used in every provided procedure to uniquely

identify the list in question */ list_handle_t list_create(); list_destroy(list_handle_t this);

BOOL list_append(list_handle_t this, ANY data); ANY list_getFirst(list_handle_t this); ANY list_getNext(list_handle_t this); BOOL list_isEmpty(list_handle_t this);

END Singly-Linked-List-2;

Singly List (Cont.)PROCEDURE foo() BEGIN

list_handle_t myList; myList <- list_create();

/* Do something with myList */ ...

list_destroy(myList); END

PROCEDURE foo() BEGIN

list_handle_t myList; /* List is created and initialized */

/* Do something with the myList */ ...

END /* myList is destroyed */

Singly List (Cont.)

PROCEDURE foo() BEGIN

SomeDataType data1; SomeOtherType data2;

list_handle_t myList; myList <- list_create(); list_append(myList, data1); list_append(myList, data2);

list_destroy(myList); END

/* Oops */ ...

Modular Programming

Problems Decouple data and behaviors

Module is oriented on operations but not actual data

Cannot guarantee type safety Programs can access memory in

inappropriate ways Inflexible Hard to extend

Object-Oriented Programming (OOP)

What is object-oriented programming? Principles of object-oriented programming

Kay's Description of OOP Object-oriented programming is based on

the principle of recursive design 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

What is an Object? The most fundamental concept/mechanism

of OOP From an application modeling perspective, an

object has the components: characteristics/attributes, services/behaviors), unique identifier, rules and policies, relationships

From a design modeling perspective, an object can be an example (instance) of a category (class), can be a category or a type, created (instantiated) by a category, can communicate…

What is a Class? From a modeling perspective, a class is a

template for a category. It defines characteristics, services, rules and policies, relationships

From a design perspective, a class is a special kind of object

From an implementation perspective, a class is a “global” object with class data members and class services

From a compiler’s perspective, a class is a programmer’s defined data type

Principles of Object-Orientation

Principle 1. Encapsulation: The object contains both the data and the methods (code) that manipulate or change that data

Case StudyIn this example, we have a family with a father (John), a mother (Jane),

two sons (Peter and Paul), and two daughters (Elizabeth and Mary). John is an actor and Jane is a dentist. All the children are students and the family dog is Lassie. Their family physician is Alice. This family owns a house in the suburbs. Although mowing the family lawn is normally a chore for the father, it can be a paid chore for any one of the children. However, working within the neighborhood is Jack, a professional lawn mower.

One morning, Jane notices that the lawn needs mowing, so she mentions to John that it is time to mow the lawn. John agrees and says that he will mow the lawn this evening. Later that evening, John comes home and is exhausted from a long day at the studio and decides to pay one of his children to mow the lawn. He looks for one of his children; he sees Mary first. He asks Mary to mow the lawn for five dollars. Mary agrees; however, Mary knows that Jack, a professional lawn mower, is willing to mow the lawn for four dollars. So Mary calls Jack to mow the lawn for four dollars and Jack agrees to mow the lawn. Jane comes home later that evening and she sees the lawn mowed. Thinking that John mowed the lawn, Jane complements John on the excellent condition of the lawn.

Principles of Object-Orientation Principle 2. Information Hiding: The object that contains the

attributes (data) defines what services (functions) are available to the other objects and prevents other objects from access or knowledge of the attributes (data) and how a service (function) is provided

Information hiding is important because it allows an object complete control over the integrity of the data contained within it. This gives us high cohesion and low coupling concerning the manipulation of data

Note: Encapsulation alone does not prevent the data of an object from being manipulated by functions other than the methods bound to the object. Protecting data from manipulation by entities outside the object can be achieved by requiring that access of data can only be provided by the services of the object that contains the data.

Principles of Object-Orientation Principle 3. Message Passing: An object

may communicate with another object only via the message-passing mechanism

Each message must be sent to a designated receiver, and the interpretation of the message depends on the receiver

Principles of Object-Orientation Principle 4. Late Binding: Support for the ability to

determine the specific receiver and its corresponding method (code) to be executed for a message at runtime

This is another way in which message passing in the OOP differs from a function call is that the specific receiver of any given message is not usually known until runtime, so the determination of which method to invoke cannot be made until then Late binding enables to model a real behavior of the world.

For example, if you are reading the textbook in a class at school, it is unlikely that you could have known who your classmates would be before the first day of the class. You only know who your classmates are once the class has begun, and even then some individuals might register late

Principles of Object-Orientation Principle 5. Delegation: Work is passed, via

message passing, from one object (client) to another object (agent) because from the client’s perspective, the agent has the service that the client needs. Work is continuously passed until it reaches the object that has both the data and the method (code) to perform the work

Principles of Object-Orientation Principle 6. Class/Instance/Object: All

objects are instances of a class. Instance can be created (instantiated) or destroyed (deleted) at runtime. How the object provides a service is determined by the class of which the object is an instance

Principles of Object-Orientation Principle 7. Generalization/Specialization:

Classes can be organized by using a hierarchical inheritance structure. In the structure, the specialized class (subclass) inherits the attributes, the relationships, the methods from the generalized class (superclass) that is higher in the structure

Principles of Object-Orientation Principle 8. Relationships: Collaboration

between objects to provide a service to a client are usually captured by an association relationship

Principles of Object-Orientation Principle 9. Reflection: Each object knows

the detailed information about the class(es) and the interface(s) to which it is an instance. This means that an application can, at runtime, acquire information about the object from the object itself