De La Salle University-Dasmariñas College of Engineering, Architecture and Technology Engineering Department- CPE

FOUR PILARS OF OBJECT ORIENTED DESIGN
HOMEWORK NO.3

Submitted By:
Depone, Carmela R.
CPE52

Submitted To:
Mr. Dwight Sabio
Instructor

Date Submitted:
August 4, 2014

ABSTRACTION
A model of a complex system that includes only the details essential to perspective of the viewer of the system or Only the characteristics of the system that are essential to the problem being studied are modelled; minor or irrelevant details are ignored.
Example and Explanation * An abstraction is a model of a complex system that includes only the essential details. * Abstractions are the fundamental way that we manage complexity. * Different viewers use different abstractions of a particular system. * Thus, while we see a car as a means of transportation, the automotive engineer may see it as a large mass with a small contact area between it and the road.

What does abstraction have to do with software development? * The programs we write are abstractions. * A spreadsheet program used by an accountant models the books used to record debits and credits. * An educational computer game about wildlife models an ecosystem. * Writing software is difficult because both the systems we model and the processes we use to develop the software are complex. * One of our major goals is to convince you to use abstractions to manage the complexity of developing software.
Advantages / Pros * Helps to manage the complexity of a large system. * Support our quality goals of modifiability and reusability. * Most modifications can be localized to just a few modules. * Supports the creation of generic modules that can be used in other systems.
Application / Use * Major application of Abstraction is basically to deal with the complexity of the system. * In other words we can say that we use abstractions to simply our work.
Reference
[1] Abstraction, Updated last April, 2014, Available: http://guruzon.com/1/oop-concepts/abstraction/what-is-abstraction-example-tutorial-characteristic-how#Explanation

ENCAPSULATION
The process of packaging your program, dividing each of its classes into two distinct parts: the interface and the implementation.
By combining the attributes and methods in the same entity, which in OO parlance is called encapsulation? * One of the primary advantages of using objects is that the object need not reveal all its attributes and behaviors. * In good OO design (at least what is generally accepted as good), an object should only reveal the interfaces that other objects must have to interact with it.
Details not pertinent to the use of the object should be hidden from all other objects. * Encapsulation is defined by the fact that objects contain both the attributes and behaviors.
Example, Data hiding is a major part of encapsulation * For example, an object that calculates the square of a number must provide an interface to obtain the result. * However, the internal attributes and algorithms used to calculate the square need not be made available to the requesting object. * Robust classes are designed with encapsulation in mind. * Encapsulating the data and behavior into a single object is of primary importance in OO development. * A single object contains both its data and behaviors and can hide what it wants from other objects.
Why Encapsulation Is Fundamental to OO
Encapsulation is really the fundamental concept of OO because Whenever the interface/implementation paradigm is covered, we are really talking about encapsulation. * The basic question is what in a class should be exposed and what should not be exposed, This encapsulation pertains equally to data and behaviour. * When talking about a class, the primary design decision revolves around encapsulating both the data and the behaviour into a well-written class.
How Inheritance Weakens Encapsulation? * Encapsulation is so fundamental to OO & Inheritance is also considered one of the three primary OO concepts. However, in one way, inheritance actually breaks encapsulation! * As already mentioned, Encapsulation is the process of packaging classes into the public interface and the private implementation. * In essence, a class hides everything that is not necessary for other classes to know about. * It makes a case that when using inheritance, Encapsulation is inherently weakened within a class hierarchy, Because it introduces a specific risk as Inheritance connotes strong encapsulation with other classes but weak encapsulation between a superclass and its subclasses. * The problem is that if you inherit an implementation from a super class and then change that implementation, the change from the super class ripples through the class hierarchy. * This rippling effect potentially affects all the subclasses. At first, this might not seem like a major problem; however, as we have seen, a rippling effect such as this can cause unanticipated problems. * For example, testing can become a nightmare. * But with proper implementation of Encapsulation makes testing systems easier.
Reference
[1] Encapsulation, updated last April, 2014, Available: http://guruzon.com/1/oop-concepts/encapsulation/what-is-encapsulation-example-tutorial-how-to-use

INHERITANCE
Inheritance as its name implies, involves inheriting attributes and behaviours from other classes. Inheritance represents the is-a relationship between two entities or objects. There is a true parent/child relationship and The child (or subclass) inherits directly from the parent (or super class). Remember that Composition is also as its name implies, involved building objects by using other objects.
Example
* One of the most powerful feature of Object Oriented programming is code Reusability. * Structured design provides code reuse to a certain extent hence you can write a procedure and then use it as many times as you want. * Inheritance also helps by organizing classes and factoring in commonalties of various classes. * Inheritance is a primary means of providing this functionality. * Inheritance allows a class to inherit the attributes and methods of another class.
This Inheritance UML notation example * Allows creation of brand new classes by abstracting out common attributes and behaviours. * One of the major design issues in OO programming is to factor out commonality of the various classes. * You have a Dog class and a Cat class, and each will have an attribute for eye color. * In a procedural model, the code for Dog and Cat would each contain this attribute. * In an OO design, the color attribute could be moved up to a class called Mammal along with any other common attributes and methods. * In this case, both Dog and Cat inherit from the Mammal class, as shown below:

* The Dog and Cat classes both inherit from Mammal. * This means that a Dog class actually has the following attributes: eyeColor // inherited from Mammal barkFrequency // defined only for Dogs
In the same vein, Dog object has the following methods: getEyeColor // inherited from Mammal bark // defined only for Dogs
Inheritance represents Is-a Relationships * For example there is a parent class (Shape Class) and Circle, Square and Star all inherit directly from Shape Class. * This relationship is often referred to as an is-a relationship because a circle is a shape, Square is a shape and Star is a shape. * When a subclass inherits from a super class, it can do anything that the super class can do. * In below figure, the name on each of the objects represents the Draw method for the Circle, Star and Square objects respectively. * When we design this Shape system it would be very helpful to standardize how we use the various shapes. * This way we could decide that if we want to draw a shape, No matter what shape, we will invoke a method called draw.

Advantages of Inheritance * There are two major benefits to inheritance. * The First, we can specialize existing classes (types) and write only the code that is changed. * In this way, we can reuse our existing classes (as base classes) and capitalize on the work already done. * We no longer have to "copy and paste" code. * Copying and pasting is particularly problematic because changes in one section of the code must be replicated in another—a dangerous and failure-prone model. * Instead, by using Inheritance, we can make changes in the base class that automatically update all the derived classes. * The second significant benefit of inheritance is that it allows us to treat the derived objects polymorphic ally.
Reference
[1] Inheritance, Updated last April, 2014, Available: http://guruzon.com/1/oop-concepts/inheritance-and-composition/what-is-inheritance-example-tutorial-uml-notation
POLYMORPHISM
Polymorphism means the ability to take on many forms; The term is applied both to objects and to operations. Polymorphism is tightly coupled to inheritance and is one of the most powerful advantages to object-oriented technologies. Polymorphism is a Greek word that means Many Shapes.
Polymorphism: Polymorphic object details with example * Suppose a financial company handles different subtypes of Funds, such as an Asia Fund, Domestic Fund, and so on. * Each with its own idiosyncrasies. * We model this situation using a generalized class(Fund) and a specialized class for each subtype of Fund with difference operations and states. * When the operation is actually executed, though the Fund object will take on one of many forms for example, an Asia Fund or a Domestic Fund. * In other words, the Fund object is polymorphic.
Polymorphism: Polymorphic operation details with example * Polymorphic operation - "One Operation, Many Methods". * A polymorphic operation is one whose method may take on many forms based on the class of the object carrying it out. * A polymorphic operation is one whose method may take on many forms based on the class of the object carrying it out. * Continuing with the same example, since all the Fund subtypes have to be able to accept deposits, we can define a Fund operation called accept deposit. * This operation is inherited by all the specializations. * We can also specify a method for this Fund operation that will be inherited by the specializations. * But what if one or more of the specializations for example, the Asia Fund—uses a different procedure for accepting deposits? * In this case, we can add documentation to the Asia Fund class that describes a method that overrides the one inherited from the generalized class.
For example, * The method described might involve supplementary charges. In practice, when capital investment causes a Fund to perform an accept deposit operation, the method that is used to carry out the operation will take on one of many forms. * This is what is meant by a polymorphic operation. * With polymorphic operations, the selection of the method depends on which particular class (Asia Fund, Domestic Fund, and so on) is carrying it out. * Now let's look at an Object Oriented Programming example. * By using polymorphism and grouping the Circle into a Shape category, Shape figures out that it is a Circle and knows how to print itself (see below figure):

Shape.print(); // Shape is actually a Circle
Shape.print(); // Shape is actually a Square
Polymorphism - One Interface, Many Implementations * Polymorphism means "one interface, many possible implementations."
For example, * Cars are designed with polymorphism in mind. * They all use the same interface-an accelerator pedal-to change speed, even though the internal method may differ from model to model. * The auto industry designs cars this way so that the drivers do not have to learn a new interface for each new model of car.
Two types of polymorphism 1. Static (compile time) polymorphism 2. Dynamic (run time) polymorphism
Static polymorphism means that the information required to call a function is available at compile time itself. * Hence function calls can be resolved at compile time. The exact function to call is determined by the difference in either the number or type of functions parameters. * Static polymorphism is achieved through function overloading, operator overloading and even function templates (in Java/C++). * It is always faster and efficient than dynamic polymorphism because the run time cost of function call resolution is avoided.
For example, * An employee object may have two print() methods one taking no arguments and one taking a prefix string to be displayed along with the employee data. * Given these interfaces, when the print() method is called without any arguments, the compiler, looking at the function arguments knows which function is meant to be called and it generates the object code accordingly.
Dynamic polymorphism means that the information required to call a function is not known until run time. * If a derived class needs to redefine a particular method defined in the base class, the method is declared as virtual in the base class and redefined, to fit its own needs, in the derived class. * The virtual function in the base class basically defines the interface of that function. Each derived class of the base class with virtual methods can redefine the methods with its own implementation. * A base-class reference (and pointer in case of C++) can be used to point to an object of any class derived from that base. * When a base reference or pointer points to a derived object that contains a virtual function, the exact function to call is determined based upon the type of object calling the method at runtime. * Thus, when different derived objects are pointed to by the base class reference or pointer, appropriate versions of the virtual function are executed. * Since the call is resolved at runtime, dynamic polymorphism results in slightly slower execution of the program.
For example, * Consider an application that serializes and de-serializes different types of documents. * We can have ‘Document’ as the base class and different document type classes deriving from it. E.g. XMLDocument, Word Document, etc. * Document class will define ‘Serialize ()’ and ‘De-serialize ()’ methods as virtual and each derived class will implement these methods in its own way based on the actual contents of the documents. * When different types of documents need to be serialized/de-serialized, the document objects will be referred by the ‘Document’ class reference (or pointer) and when the ‘Serialize ()’ or ‘De-serialize ()’ method are called on it, appropriate versions of the virtual methods are called.
Reference
[1] Polymorphism, Updated last April, 2014, Available: http://guruzon.com/1/oop-concepts/polymorphism/what-is-polymorphism-example-tutorial-uml-diagram-notation