Introduction to Objects

• Objects are the fundamental building blocks of object-oriented

systems
• What is an object?
• It represents any “thing”
• It has a boundary in space and time
• It is an abstraction
• It encapsulates state and/or behavior
• It has identity
 Introduction to Classes

• Classes are abstractions that allow us to deal with whole collections of objects
that share some commonalties.
• Examples of classes in a Student Records Management System

Course College
Class Semester Instructor
Section
Student
Class Department
Grade Major
Class Syntax
• A box divided into compartments Student
• Name
• Attributes major: String
• Operations gpa: Real
• Responsibilities
• Used-defined compartments
standing: String
add(Class Section)
drop(Class Section)
-- The set of students
known to the registration
system
-- An exception occurs if
gpa falls below 2.0
Class Names
• The name should be a noun or noun phrase
• The name should be singular and description of each object in the
class
• The name should be meaningful from a problem-domain perspective
• “Student” is better than “Student Data” or “S-record” or any other
implementation driven name
• Avoid jargon in the names
• Try to make the name descriptive of the class’s common properties
Exercise – Class Identification

• Identify meaningful classes in the Elevator System

Return to Objects – Object Syntax
• Object syntax is similar to class
syntax, except
• the name identifies specific or generic
object joe: Student
• the name includes the class that the
object belongs to major: String = “CS”
• Remember, individual objects are gpa: Real = 4.0
instances of classes standing: String = “”

add(Class Section)
drop(Class Section)
Attributes
• Attributes represent characteristics or properties of objects
• They are place holders or slots that hold values
• The values they hold are other objects
• The name of an attribute communicates its meaning
• An attribute can be defined for individual objects or classes of objects
• If defined for a class, then every object in the class has that attribute (place
holder)
Attributes from an Analysis Perspective

• An attribute relates an object to some other object

• It has the same semantics as an association

joe: Student
Is basically the
name: String = “Joe Jones”
same as ...

joe: Student name

Joe Jones : String
1
Attributes from a Specification Perspective

• An attribute represents an obligation to provide or manage a certain

(single) piece of information

 For example, each Student

Student object must major: String
be able to gpa: Real
encapsulate a standing: String
major, a GPA, and
a standing
 Attribute Syntax
[visibility] name [multiplicity] [:type] [=initial-value]
[{property-string}]
visibility: public “+”, protected “#”, or private “-”
name: capitalize first letter of each word that makes up the name, except for the first
multiplicity: number, range, or sequence of number or ranges.
type: build-in type or any user-defined class
initial-value: any constant and user-defined object
property-string: e.g, changeable, addOnly, frozen
Operations
• Meaning from three perspectives
• Analysis: Ways in which objects interaction
• Specification: An obligation to provide a service
• Implementation: A function member, a method
 Operations
Student Class Section
major: String name: String
GPA: Real takes> capacity: Integer
standing: String
add(Student)
add(Class Section)
drop(Class Section) drop(Student)
checkPrerequisites(Students)

Course <has
Prerequisite
Operation Syntax
[visibility] name [(parameter-list)] [:return-
type] [{property-strong}]
visibility: “+”, “#”, “-”
name: verb or verb phase, capitalize first letter of every word, except first
parameter-list: coma separated list of parameters
return-type: primitive type or user-defined type
property-string: isQuery, sequential, guarded, concurrent
Type of Relationships in Class Diagrams

A consolidated snippet of the UML Meta-model

Relation

Generalization Association Dependency

Binary Association N-ary Association

Aggregation
Associations
• An association is a structural relationship that specifies that objects of
class may be connected to objects of another class
• Meaning from three perspectives
• Analysis: Links between objects
• Specification: Obligation to provide a connection between objects
• Implementation: Object pointers, references, linking structures, etc.
Associations
is registered for>
Student Semester

g>
ri n
tak
es>

du
ld
he
is
teaches> Class
Instructor
Section
is
<works for

in
st
an
ce
of
>
sponsors>
Department Course
Coming up: Association Names
Association Names
• Associations may be named
• The names should communicate the meaning of the links
• The names are typically verb phases
• The name should include an arrow indicating the direction in which the name
should be read
Navigation
• The navigation of associations can be
• uni-directional
• bi-directional
• unspecified

teaches> Class
Instructor
Section
is
<works for

in
st
an
ce
of
>
sponsors>
Department Course
Coming up: Navigation
Generalization
• Generalization is another kind of relationship in UML – see Meta
Model
• From an analysis perspective, it is a pure generalization/specialization
concept, i.e., the specialization is a subset of the generalization

Graduate
Person Student
Student
Generalization
• From a specification/implementation perspective,
generalization can represent sub-typing,
inheritance, type capability, and substitutability
(depends on the language)

Student
Person
major: String
name: String GPA: Real
address: String standing: String

changeAddress(new_address) add(Class Section)

drop(Class Section)
Coming up: Generalization
Exercise – Simple Associations
• From an analysis perspective:
• Identify meaningful associations and generalization/specializations among
classes in the Elevator System
Class Diagrams

• Class Diagrams describe

• the types of objects in a system
• their properties (attributes and operations)
• relationships between objects
• They can also include
• Grouping concepts like packages
• Constraints
• Various kinds of annotations
Multiplicity Constraints
is registered for>
Student Semester
1..*
0..* 1

g>
ri n
tak
es>

du
ld
he
0..8
1..*

is
teaches> Class
Instructor
1..3 0..6 Section
1..* is
<works for

in
st
an
ce
of
1 >
1 sponsors> 1..*
Department Course
Coming up: Multiplicity Constraints
Questions

• From the previous diagram

• How many classes can a student take?
• Do you have to be registered in any classes to be a student?
• Do I need to teach this class to be an Instructor? Do I need to teach ANY
classes?
Multiplicity Constraints

• A multiplicity constraint can be

• a single number
• a “*”, meaning an arbitrarily large number or simply “many”
• a range, denoted by “min..max”
• a sequence of single numbers and ranges
Dependencies

A consolidated snippet of the UML Meta-model

Relation

Generalization Association Dependency

Binary Association N-ary Association

Aggregation
Dependencies
• A dependency is a type of relationship
• It says that one modeling component “uses” another.
• If the later changes then, the former may have to change as well

Student

Prerequisite
add(Course)
drop(Course)
Coming up: Dependencies
Dependencies
• Meaning from three perspectives
• Analysis: physical or logical dependency between the connected classes
• Specification: a “uses” relationship at an interface level
• Implementation: a “uses” relationship at an implementation level.

Just think: uses!

Dependencies
• Syntax:
• a dashed link with an straight-line arrowhead point to a component on
which there is a dependency
• Dependencies can be defined among: classes, notes, packages, and
other types of components
• Can dependencies go both ways?
• Any problems with having lots of dependencies?
Aggregations (is part of)

A consolidated snippet of the UML Meta-model

Relation

Generalization Association Dependency

Binary Association N-ary Association

Aggregation
Aggregation
• Aggregation: is a special kind of association that means “part of”
• Aggregations should focus on single type of composition (physical,
organization, etc.)

Crust 1 1

1
1 1 *
Sauce Serving Pizza Order
1..3 1 1
Cheese Serving
0..9 1 4..*
Topping Serving
Slice
Composition (very similar to aggregation)

• Think of composition as a stronger form of aggregation. Composition

means something is a part of the whole, but cannot survive on it’s
own.

Room Building
Lets look at BookstoreExample4.jpg
• Does John McCain (who has 7 houses) have a problem using this
system?
• If Barack Obama decides to create a Federal sales tax, how would we
change the system?
• Why is there a display method in Item, Book, MusicCD and Software?
• An ItemOrder is part of how many Orders?
• Can you explain how a search works using this diagram?
Class Exercise

• Lets create the WeGrow class diagram

Validating a class diagram

• One of the most important, and often overlooked

issues is how to validate a class diagram. (Usually
best for an diagram at the implementation
perspective)

• Given a specification or a use-case, can you look at

the class diagram and use attributes and methods
to “execute” a use case?
• Lets try it for the WeGrow class diagram
Questions

• What’s the difference between an attribute and an

association with another class? For example, should “grade”
be an attribute or a link to another class called “Grade”?

• When during the software engineering life cycle should you

build classes diagrams?
More Questions

• How do you know when a class diagram is complete?

• How can you manage change control on all the class diagrams for
project?

• What do you do with class diagrams after a system has been built
and delivered?
Bonus Slide!

• If you’re interested in Auto-generating UML, Netbeans has an option

to do it.
• Install the UML plugin
• Right-click on a project
• Choose “Reverse Engineer”
• Go to the new UML project
• Select a package and choose to generate a new UML diagram