1. What is Object? Using Brian Mitchell’s notes for reference
Objects are tangible entities that exhibit some well defined behavior
Some typical object characteristics:
A tangible or visible thing
Something that may be apprehended intellectually
Something toward which thought or action is directed
Text book definition: An object has state, behavior, and identity; the structure and behavior of similar objects are defined in their common class` ( Inheritance )

2. 3 Characteristics of an object
State
Behavior
Identity
Example:
All of the objects
that are depicted
in the above
window have an active state, well defined behavior and unique
identity
Climate Control
System
Ignition
CD Player
Buttons
Equalizer
Shift

3. Objects Objects are active entities (identity)
Objects exits at run time
Objects store information that is the result of prior operations ( the object state )
Current state of the object can be used to determine how object carries out its operations in future ( State Machine )
The current state of the object always represents the consequences of all the previous operations that were performed on the object. Object’s state does not change spontaneously !

4. Object State
Definition: The state of an object encompasses all of the (usually static ) properties of the object plus the current (usually dynamic ) values of each of these properties.
State is defined by the current values of the object properties.
A property of an object is an inherent or distinguishing characteristic, trait, quality of feature that contributes to defining the uniqueness of the object

5. Object Properties
Properties are usually static ( i.e., we can not dynamically create new object properties)
All properties must contain valid values
Must be enforced by object’s behavior
State may effect the behavior of an object

6. Example representing object’s state:
class Person {
public:
string name;
long int ssn;
string address; };
int main() {
Person * p = new Person();
Person * p2 = new Person();
p->name = “John Smith”;
p->ssn = ;
// …
return 0; }
Objects state is determined by the current values of the objects properties. The object properties are contained within the member variables of the class.

7. Example of Object State
In the example name, ssn, and address represent properties of the Person class.
The Person class declaration is used to define object’s structure.
Class declaration DOES not create actual objects
All objects must be created from valid class definitions. The pointer variables p and p2 points to an actual (distinct) objects.
p and p2 point to distinct instances of object Person, even though they were created from the same class
Both instances share common structure (common set of properties and behavior ), but reside in different memory addresses as unique entities.

8. Encapsulating the state of an object
It is a good engineering principle to encapsulate the state of an object rather than exposing it to outside users
Promotes data hiding
Enables object’s designer to control access to the internal object’s state
Protects the internal integrity of the object
Enables design decisions to be changed later without impacting external object users.
As long as public interface is the same, internal behavior of object can change without affecting external users

9. Example of encapsulation:
class Person {
public:
inline int getSSN() const;
inline int setSSN(const int newSSN);
inline int setName(const string & name);
inline string getName() const;
private:
string name;
int ssn; };

10. Example of encapsulation:
int Person :: getSSN() const {
return ssn; }
int Person :: setSSN(const int newSSN){
if( newSSN == 0 ) // Protect attributes from malicious users !!!
return 1; // Error !
this->ssn = newSSN;
return 0; // Success
int Person :: setName(const string & name){
if ( name == “” ) // Protect attributes from malicious users !!!
return 1; // Error !
this->name = name;
return 0; // Success
string getName() const {
return name;

11. Encapsulation/State summary
The internal object representation is hidden from outside users
If we change internal representation of the object, no client will be affected by the change, this facilitates reuse.
We explicitly defined the operations that are allowed to be performed on the object.
Only special clients (subclasses via inheritance) will have permission to directly modify the internal state of the object
All objects within the system encapsulate some state and that the state within a system is encapsulated by objects

12. Object Behavior
Definition: Behavior is how an object acts and reacts, in term of its state changes and message passing.
Behavior is visible and testable
Current state of an object represents cumulative results of its behavior
Objects can be acted upon, or they can act on other objects
All objects allow certain operations while not supporting others
The set of operations allowed to act upon an object define its behavior
Not all operations are suitable or implemented for a given object. Mechanism must exist to reject improper or unsupported requests.

13. Behavior
Behavior can be rejected statically ( Compile time error ), or dynamically ( Runtime error or runtime exception )
Object behavior can be updated at a later time to support new versions of the object.
The set of supported operations on an object must always make sense with respect to the definition of the objects definition.
Example: When you press brake pedal in your car, - you expect your car to stop, not accelerate.

14. Operations
An operation denotes a service that a class offers to its clients
There are five different kinds of operations that a client may perform on an object:
Modifier: An operation that alters the state of an object
Selector: An operation that access the state of an object, but does not alter the state
Integrator: An operation that permits all parts of an object to be accessed in some well-defined order
Constructor: An operation that creates an object and/or initializes its state
Destructor: An operation that frees the state of an object and/or destroys the object itself

15. Roles and Responsibilities
Collectively, all of the methods associated with a particular object comprise its protocol.
Protocol defines the envelop of allowable behavior
Protocol comprises the entire static and dynamic view of the object
Roles of the object define allowable behavior of the object

16. Roles and Responsibilities
Knowledge that the object must maintain
Actions that the object is allowed to perform
Services that the object provided for all of the contracts that it supports

17. Objects As State Machines
The current behavior of an object is often influenced by its history
The existence of state within an object means that the order in which operations are invoked are important.
Example: Network protocols (TCP protocol )
Object behavior is event and time driven
Each object acts like a tiny, independent machine

18. Active and Passive objects
A passive object can only under a state change when it is explicitly acted upon.
An active object encompasses its own thread of control
Active objects are generally autonomous
Active objects can exhibit some behavior without being operated upon by another object
Example: An object responsible for controlling a game simulation
Every OO system must have at least one active object

19. Object identity
Identity is a property that distinguishes an object from all other objects
The failure to recognize the difference between the name of an object and the object itself is the source of many kinds of errors in OO programming
The current object state and the collection of allowable operations do not fully characterize the object.

20. Object identity
It is possible for two or more distinct objects to have the same state and support the same operations. Because objects are distinct they each have their own identity, thus they are different.
Car * c1 = new Car(“bmw”);
Car * c2 = new Car(“bmw”);
c1 and c2 both support the same operations and the same state, yet they have different identities

21. Copying, Assignment & Equality of Objects
Structural sharing takes place when the identity of an object is aliased to a second name
This arrangement may leads to two or more variable names that operate on the same object
Copy Operation is performed by a copy constructor
When a copy operation is performed on an object, a new object must be created and the state of the first object must be loaded into the new object
Car x(“bmw”);
Car y(x);

22. Assignment Operation
The assignment operator by default will create an alias of the original object. Most languages allow to override the default behavior of the assignment operator.
Issues of doing Shallow and Deep copy. Be careful !
Car x(“bmw”);
Car y=x; // By default calls copy constructor unless constructor is declared explicit

23. Equality Operation
The equality operation can check to see if two names designate the same object, or if two names designate distinct objects that have the same state.
In C++ operator== investigates if two objects are aliases of each other.

24. Object Life Span
The lifetime of an object extends from the time it is first created until the time it is explicitly destroyed
Objects in C++ are created by either declaration or allocation
Car x(“bmw”); // By declaration
Car * x = new Car(“bmw”); // Allocation

25. Object lifespan Objects are destroyed in C++ in one of two ways:
If the object was created by declaration, it is destroyed when the variable that is representing object goes out of scope.
Example: { … } block end or function return.
If the object was created by allocation, it is destroyed when the programmer issues the delete instruction. Otherwise, you get lost memory.
Car * p = new Car(“bmw”);
delete p;

26. Object lifespan
Objects are destroyed in Java by an automatic housecleaning process. That is the object is destroyed, when there are no more references to the object.
Whenever an object is created, its constructor is automatically called so that proper initialization can be performed
Whenever an object is destroyed its destructor is automatically called so that the object can perform any necessary cleanup
Objects allocated dynamically on heap, must be explicitly de allocated by the programmer executing delete operation
In Java an object is terminated when it is explicitly destroyed once all references to the object are broken. Cleanup is performed automatically using garbage collection algorithm

27. Lifespan and Persistence
Persistent objects have slightly different semantics regarding destruction
When object is deleted, its full state is stored into persistent database on hard driver ( non-volatile storage )
Later on, object’s state can be loaded back from the persistent storage.

28. Classes Programming is largely a matter of subcontracting
The various functions of a larger problem are decomposed into smaller problems by subcontracting them to different elements of the design
The class is used to capture the structure and behavior that is common to all related objects that are created from the same class
Individual object is a concrete entity that performs some role in the overall system. It’s a template for creating a collection of related objects
All objects of the same class support the same collection of operations and have a common set of possible states

29. Classes
A class is a template or definition that is used to create an object.
The class definition describes the structure and behavior of an object
Objects that conform to a class description are instances of the class
The class definition is used to create a set of objects that share a common structure and behavior.
A class description must list operations that are allowed on objects of the class, and possible states for the objects of the class defined through class properties.
A class is not an active entity
Classes are described in source code
Objects created from classes, and exit at run time

30. Classes
A class represents a set of objects that share a common structure and common behavior.
Example: car
Class: Class car
Object: The actual cars

31. Example: Class Mailbox
Recall that a class definition must describe the operations that are allowed on objects of the class and the possible states for objects of the class
Class Mailbox
Operations:
Add a message
List all stored messages
Delete a message
Show a particular message

32. Example: Mailbox Properties: Linked list of messages
Note that a “Message” is abstract with respect to class Mailbox
Message could be
Buffer of raw data
May be defined by a struct
May be objects defined by another class (Message )

33. Interface and Implementation
A class has both an outside view and an inside view
The interface of the class represents the outside view
Emphasis is placed on the providing the correct level of abstraction
The interface is also used to protect the classes internal structure and the secrets of its behavior
The interface includes the declaration of all the operations applicable to instances of this class ( methods), declarations of other classes(nested classes), constants, variables and exceptions

34. Interface and Implementation
The implementation of a class represent its inside view
The implementation is used to encompass the secrets of the classes behavior.
Algorithms and data structures

35. Class Access Rights
In both the Java and C++ programming languages the interface of a class can be broken down into three parts:
Public, protected, and private
The class interface can be divided into distinct sections whereby each section can be protected by any one of the three available access control rights
The developer must decide which protection mechanism to use

36. Class Access Rights
Public – A declaration that defines that results in all class attributes being accessible to all clients
Protected – A declaration that causes the class attributes to be accessible only to the class itself and its subclasses ( via inheritance )
Private – A declaration that causes the class attributes to be accessible only to the class itself.
Exception: friend functions and classes
Friends are not supported by Java, only C++

37. Class Access Rights Example
class BankAcct {
private:
string address;
string name;
int balance;
public:
int getBalance() const;
string getName() const;
int setName(const string & name);
// … };

38. Class types In the early stage of OO Design you need to select classes
Most classes can be categorized by the following types
Data Managers, Data or State classes. To maintain data or state information.
Example “playing card”
Data Sinks or Data Sources: classes that accept data, and classes that generate data

39. Class types Facilitator or Helper classes View of Observer classes
Classes that maintain little of no state information but assist in the execution of complex task – an interest calculation class
View of Observer classes
Classes that display or visualize information
Data views are usually independent of the actual data tat is being displayed

40. Class Relationships Classes usually do not exist in isolation.
Example: objects that compose a car
Classes are generally related in a variety of ways
The relationship between classes is used to construct the class structure of a system design
We are interested in exploiting the similarities between classes for software reuse

41. Class Relationships
Example: A class may be thought of as a specialized version of another class
Desire to exploit similarities between classes
Most operations are identical or similar, however, there might be a few differences
This is the inheritance relationships, we will study inheritance later

42. Class Relationships Example
Employee has name, address, salary, Department
Manager is an employee. Manager must also manage the employees that work for the manager. Manager manages a list of employee
Engineer is an employee, but engineer is a special type of employee
This is “is a relationship”
Employee
Manager
Engineer

43. Class Relationships types
There are three basic kinds of class relationships
Generalization/Specialization. This is inheritance, and denotes an “is a” relationship
Manager “is an” Employee
Aggregation/Containment. This denotes a “part of” relationship
Example: Car contains transmission
Association: This denotes a semantic dependency among otherwise unrelated classes
Manager can “use” employees to solve tasks

44. Association
Association is a way of representing a bi-directional relationship between two objects
Common association cardinalities
One-to-one
One-to-many
Many-to-many

45. Aggregation
Aggregation is used to enable objects to physically contain other objects
Aggregation asserts a direction to the whole/part of relationship

46. Using
“Using” relationships among classes parallel peer-to-peer links among the corresponding instances of these classes
A “Using” relationship among classes requires the designer to specify which class ( or set of classes ) are users of service and which class ( or classes ) are the suppliers of the service
A “Using” relationship usually takes the form of an object created as a local variable or an object being passed to a member function as a parameter

47. Using example void MailBox::Print(string & msg ) { cout << msg;}
In the above example, the string class is not “part of” the mailbox class, nor does it specialize it – it is a Using relationship

48. Instantiation
Instantiation is the act of providing additional information to a class that is required before instances of that class can be created
Instantiation is generally required when we want to build “type-safe” classes.
In C++ instantiation is facilitated by using templates. A well documented shortcoming of Java is its lack of template support

49. Example of instantiation
Garray<BankAcct> * gaAcct = new Garray();
Garray<WidgetMgmt> * gaWidget = new Garray();
BankAcct * ba = new BankAcct();
BankAcct * ba1 = new BankAcct();
ba->setAcctNum(12345);
ba1->setAcctNum(123456);
gaAcct->AddItem(ba);
gaAcct->AddItem(ba1);
gaWidget->addItem(ba); // causes error

50. Relationship among classes
Most object oriented languages provide the following mechanisms for capturing the relationships among classes
Association
Inheritance
Aggregation
Using
Instantiation