1. Fundamentals of OO

2. Note that the individuals are not identical.
Example: Classroom
Attending the lecture we have several individuals
Wade - loves Chinese food
George - an outdoorsman
Wendle - is a sports nut
Lee - doesn't eat anything with a vowel in its name
These are the students of our lecture
Note that the individuals are not identical.
Wade George
Wendle
Lee

3. Abstraction and Classes
From our perspective, we see them as an instantiation of a "Class", Student
has a name
attends class
has a grade
completes assignments
Note the each student looks the same
even though the are different individuals
A Class defines an "Abstraction"
OO Abstractions are based on
data (name, attendance)
"Attributes"
simple access
behavior (completes assignments, attends class)
"Operations/Methods"
complex properties
relationships (student in course)
external implementations

4. Objects, Instances of a Class
Classes define what properties will exist in each instance
Objects provide distinct instances that exhibit those properties
Class
Objects
George : Student
Name=“George”
Attendence=100%
Current
Grade=A
Lee : Student
Name=“Lee”
Attendence=85%
Current
Notice that the data members are replicated in each object. Each object is an instance of Student. It does not make sense to replicate member functions.
Grade=B

5. Encapsulation and Objects
Classes form the interface for interaction, Objects provide the implementation
they are instances of a class (student)
they have unique behavior
they have state
Class
Objects
Student
GetName()

6. Messaging Supports Encapsulation
We interact with objects through "messages"
Messages allow object to determine implementation rather than the sender determining the implementation for each instance.
Messages are passed and handled, rather than invoked like functions.

7. Polymorphism Supports Encapsulation
Allows an object of any implementation type, which satisfies the interface defined by the abstraction, to be used by a generic reference to an abstraction.
Promotes a separation of interface and implementation
class GraduateStudent : Student ;
float calculateScore(Student s);
GraduateStudent George;
calculateScore(George)
Wade is an undergraduate
Student
George is an graduate
Student
Polymorphism says that you can treat both Wade and George as Students if the distinction between undergraduate and graduate is not important.

8. Hierarchies
Organize lower level abstractions into more complex abstractions
Hierarchies allow more complex abstractions to be understood
Two basic forms
Inheritance
Generalization - Specialization
Base Class - Derived Class
Parent - Child
Abstract Class - Concrete Class
Aggregation (many-to-one relationships)
Whole - Part
Containership
Collection
Group

9. Inheritance Hierarchy
an "is-A" relationship
Inheritance
for type - a re-use of common interface
for class - a re-use of common interface and implementation
Person
Student
Name
Name
Attendence
Current
Grade

10. Aggregation Hierarchy
a "has-A" relationship
assembly-part - where the aggregation of parts makes up the whole
ex: airplane is an aggregation of wings, wheels, motor, prop, etc.
container-contents - where the container exists with or without contents
ex: classroom is an aggregation of students, instructor, tables, chairs, etc.
group-member - where members are logically associated with whole
ex: course has students and teachers as members
"weak has-A" - where there is more of a peer-to-peer relationship between abstractions (association)
ex: Instructor has students, Students have instructor

11. Summary of Object-Oriented Concepts
Abstraction
Class
Attribute
Behavior
Relations
Encapsulation
Object
Message
Polymorphism
Hierarchies
Inheritance
Aggregation
“Is-A” relationships are implemented through inheritance.
“Has-A” relationships are implemented through data members.
Data structures are used to implement the various “Has-A” relationships. For example, multiple children are maintained through container data structures such as arrays and linked lists.

12. Comparison of Functional vs. OO Views
Register
Student
Submit
Grade
Students
Grades
Students
Student/Grades
Print
Transcript

13. Addition of a New Student Type
Register
Student
Submit
Grade
Students/
Pass Fail Students
Grades/PF
Impact
Areas
Students
Student/Grades/PF
Print
Transcript
function override
Changes in data types cause significant impact to functional approaches
OO approaches allow new object types to re-define functionality

14. Addition of New Report Type
Register
Student
Submit
Grade
Impact
Areas
Students
Grades
Students
Student/Grades/PF
Student/Grades/PF
Print
Transcript
Print
Report Card
Changes in functionality based on stable data causes significant impact across objects
Functional approaches allow new functions to augment functionality

15. Re-organization of OO Abstractions
Data dependent behavior handled by derived classes
New functionality handled by new associated classes ("wrappers", "adapters", "views")

16. Exercise: Identifying OO Properties
Provide examples of the following concepts using an Answering Machine.
Class:
Attribute:
Behavior:
Object:
Association:
Inheritance:
Aggregation:

17. Assignment: Identifying OO Properties
Provide examples of the following concepts using a domain you are familiar with. Prepare your results on a transparency for presentation to the class.
Class:
Attribute:
Behavior:
Object:
Association:
Inheritance:
Aggregation:

18. Sample Package View

19. Sample Class View
Diamond implies composition: All MediaTopics together comprise a CardCatalog.
Notice that this sample class view does not include visibility indicators.

20. Acknowledgements
This presentation is an adaptation of material developed by Jim Stafford, John Hopkins University. Used by permission.