Object Oriented System Development Approach Information Technology Essay

Published: Last Edited:

This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.

There are three categories of systems development methodologies, which is structured design, Rapid Application Development and Agile Development. Structured design use a traditional step-by-step approach that flows logically from one phase to another phase; RAD uses user understandable level techniques to bring closer what is needed to the users; and Agile Development Agile methods are characterized as being at the opposite end of the spectrum from plan-focused methods and it is Most promote development, teamwork, collaboration, and process adaptability throughout the life-cycle of the project.

Extreme Programming is a set of practices for small to medium sized development to ensure quality and high business value in the code they produces. The ideas of extreme programming practices are concrete things that a team can do daily. Extreme programming save time and it is good for small project with high motivation and experienced teams but not the large mission-critical systems.

Waterfall development working with the phases which are planning, analysis, design and implementation and must in order, each phase depends on the completion of preceding phases. Good thing of waterfall development is we can know the requirements of project before we start and have minimum changes to the requirements as the project proceed and the bad is there is no room for changes once the development has started.

Prototyping is a methodology that perform analysis, design and implementation phases concurrently to build the first version of a product, the product can be improve later with users feedback. The advantages of prototyping are we can come out a real system quickly and can refine next requirement very quickly to do improvement.

Parallel development is quite similar to waterfall development, the difference is parallel development divide project into small projects and each of the phases is implemented on each of them. Parallel development reduces schedule time and lesser chance of changes but if subprojects not completely independent, it may affect others.

Phased development breaks the whole system into a series of versions and develops them sequentially. By this, the developers than can quickly develop a system to the user but users have to work with systems that are incomplete.


Inheritance is the concept that when a class of object is defined, any subclasses that is related or defined can be inherit to the definitions of one or more general classes. Inheritance comes from the fact that the subclass contains the attributes and methods of the parent class. It is also a way to compartmentalize and reuse the code which means we can add additional features to an existing class without modifying it. When creating a class, instead of writing completely new data members and functions, programmer can designate new class inherit the members of an existing class. The existing class will be called as base class or superclass and for the new class will be referred as derived class or subclass.

From the example below, Bicycle is the superclass of MountainBike, RoadBike and TandemBike. In the programming language, each class is allowed to have one direct superclass and each superclass has the potential for an unlimited number of subclasses.

Example in coding:

class Bicycle {


class MountainBike extends Bicycle {


In programming language, three kinds of inheritance has been offered, the three type of inheritance are public, protected and private. For public inheritance, it can be accessed directly by non-static member functions, friend functions and nonmember functions, is like everyone also can access it. Protected inheritance can only be accessed by non-static member function and friend functions as well as private inheritance

Good things by using this terminology is it let us avoid the redundancy of declaring the same instance variables in related classes. Besides, it also speeds up a program development and ensures an inherent validity to the defined subclass object. As a whole, inheritance enables us to create new classes that reuse, extend, and modify the behavior that is defined in other classes.

But then, if inheritance used with insufficiently mature design, it will also caused yo-yo problem which is an anti-pattern that happens when a programmer has to read and understand a long and complicated inheritance graph and the programmer keep flipping between the classes definition.


Encapsulation means as much as shielding. Each object-oriented object has a shield around it. Objects can't view each other. They can exchange things though, as if they are interconnected through a hatch.

Encapsulation is a language mechanism for restricting access to some of the object's components and construct that facilitates the bundling of data with the methods (or other functions) operating on that data. Encapsulation means that the internal representation of an object is generally hidden from view outside of the object's definition.

Encapsulation enables object-oriented experts to build flexible systems. Systems that can extended as your business extends. Every module of the system can change independently, no impact to the other modules. Encapsulation conceals the functional details of a class from objects that send messages to it. Below diagram shows that two objects has been encapsulated and both of them will not interference each other.

For example Java, an object-oriented language, which offer the programmer a degree of control over what is hidden, typically via keywords like public and private. Hiding the internals of the object protects its integrity by preventing users from setting the internal data of the component into an invalid or inconsistent state. A benefit of encapsulation is that it can reduce system complexity, and thus increases robustness, by allowing the developer to limit the interdependencies between software components.

Customer, waiter and kitchen are three shielded objects in the 'cup of coffee' example. Customer and kitchen do not know each other. The waiter is the intermediary between those two. Objects can't see each other in an object-oriented world. The 'hatch' enables them to communicate and exchange coffee and money.

Encapsulation keeps computer systems flexible. The business process can change easily. The customer does not care about the coffee brew process. Even the waiter does not care. This allows the kitchen to be reconstructed, is only the 'hatch' remains the same. It is even possible to change the entire business process. Suppose the waiter will brew coffee himself. The customer won't notice any difference.


The word polymorphism meaning "having multiple forms" which has the ability to assign a different meaning or usage to something in different contexts, it allow an entity such as a variable, function or object to have more than one form and allows two or more objects respond to the same message. For more specifically, it allows multiple objects of different subclasses to be treated as objects of a single super class, while automatically selecting the proper methods to apply to a particular object based on the subclass it belongs to.

In general, there are three types of polymorphism which are overloading polymorphism, parametric polymorphism and inclusion polymorphism.

Overloading polymorphism allows us to define operators whose behavior will vary depending on the parameters that are applied to them. As for parametric polymorphism, it has the ability to define several functions using the same name but with different parameters, like name or type. Parametric polymorphism will automatically choose the correct method to be adopted based on the type of data passed in the parameter. Lastly, Inclusion polymorphism has the ability to call on an object method without having to know the intrinsic type.


Class Person{

public static printInformation( Person p){



public static main (String args[]){

Student xyz = new Student();

Employee abc = new Employee();

printInformation ( xyz );

printInformation( abc);



We have a static method printInformation that takes in a Person reference as parameter. We can pass a reference of type Employee and type Student to the printInformation method as long as it is a subclass of the Person class.

The benefits of polymorphism are simplicity and extensibility. Example like I want to write code that deals with a family of types, the code can ignore the type and just interact with the base type of the family, this makes the code easier to understand and write, and also other subclasses can be added later to the family of types, and objects of new subclasses will also work with the existing code.


Object is the foundation of object-oriented programming, and is fundamental data types in object-oriented programming languages. These languages provide extensive syntactic and semantic support for object handling, including a hierarchical type system, special notation for declaring and calling methods, and facilities for hiding selected fields from client programmers. However, objects and object-oriented programming can be implemented in any language. Objects are miniature programs that are complete with their own private copy of all internal data. The designer of the object decides how the object can be used. This can be done independently of the application in which it is used properly designed and tested objects are robust and can be reused in new applications. The secret is in the way a user interacts with an object. Objects are the basic run-time entities in an object-oriented system. They may represent a person, a bank account, a table of data or any item that the program must handle. They may also resent user-defined data such as vectors, time and lists. Programming problem is analysed in terms of objects and the nature of communication between them. Program objects should be chosen such that they match closely with the real-world objects. As pointed out earlier, objects take up space in the memory and have an associated address like a record in Pascal, or a structure in C. When a program is executed, the objects interact by sending messages to one another.

Objects are used in software development to implement abstract data structures, by bringing together the data components with the procedures that manipulate them. Objects are the key in the concept of inheritance; thereby improving program reliability, simplification of software maintenance, the management of libraries, and the division of work in programmer teams. Object-oriented programming languages are generally designed to exploit and enforce these potential advantages of the object model. Objects can also make it possible to handle very disparate objects by the same piece of code, as long as they all have the proper method.

For example,

If "customer" and "account" are two objects in a program, then the customer object may send a message to the account object requesting for the bank balance. Each object contains data and code to manipulate the data. Objects can interact without having to know details of each other's data or code. It is sufficient to know the type of message accepted and the type of response returned by the objects. Although different authors represent them differently


In object-oriented programming, class is a template definition of the method and variable and usually we use class to hold methods, like main and static methods, every object is an instance or member of class.

Example, if we have a class named as Fish, then any kind of fish like jellyfish or shark will be the member of the class. A truck and a racing car are both examples of a car, and also in a university computing system, you might have a class to represent a student, an instructor, a classroom, a department, a course, a section of a course.

A class can have subclasses that can inherit all or some of the characteristic of the class. In relation to each subclass, the class becomes the superclass.

A class is also like a blueprint from which the individual objects are created, class is composed of three things which are name, attributes, and operations. Like the template above, we have a class named as Student, and within the class we have the attributes like the age of the student, name of the student etc, another example of code for a class with its attributes shown at below:

public class Dog{

public static void main( String args[]){

int age = 3;

String name = "Bobby";

System.out.println("Dog name : " + name);

System.out.println("Dog age : "+ age);




Method is a set of procedural statements for achieving the desired result. It performs different kinds of operations on different data types. In a programming language, methods are verbs, sometimes referred to as "functions". In object-oriented programming, a method is a subroutine that is exclusively associated either with a class (in which case it is called a class method or a static method) or with an object (in which case it is an instance method). Like a subroutine in procedural programming languages, a method usually consists of a sequence of programming statements to perform an action, a set of input parameters to customize those actions, and possibly an output value (called the return value) of some kind. Methods provide a mechanism for accessing and manipulating the encapsulated data stored in an object.

For example,

Pipi, being a bird, has the ability to fly. So fly() is one of Pip's methods. Pipi may have other methods as well, for example sing() or peck(wood) or walk() or eat(). Within the program, by using a method usually affects only one particular object; all birds can fly, but you need only one particular bird to do the flying.


Aggregation is a form of composition where one looks at the system as a whole and based on "has-a" relationship. The aggregate class contains a reference to another class and has ownership over that class, each class referenced is considered to be the part of the aggregate class. Example, a car class is an aggregation of different classes like engine, wheel, body etc.

Aggregation is different from composition that aggregation indicates ownership but composition don't. The important points that aggregation must have are has-a relationship between objects, object have independent life-cycles and parent-child relationship.

The example of aggregation:

public class Subject {

  private String name;

  public void setName(String name)


    this.name = name;


  public String getName()


    return name;



public class Student {

  private Subject[] studyAreas = new Subject[10];

  //the rest of the Student class


An aggregated object can reference other objects but it doesn't need them, example a person "has-a" address but if they were homeless, that person still will exist. It's not like composition, in design if you remove, the rest of the whole part will be also removed or disappear automatically like the car with the engine. In aggregation, the part of the whole still exist when the whole is destroyed just like a car and a stereo, and a car is an aggregation of engine, tyres, brakes, etc.


Composition is a relationship between two classes that is based on the aggregation relationship. Composition takes the relationship one step further by ensuring that the containing object is responsible for the lifetime of the object it holds. If Object B is contained within Object A, then Object A is responsible for the creation and destruction of Object B. Unlike aggregation, Object B cannot exist without Object A.

By composition, using instance variables that are references to other objects.

For example:

class Food {



class Wheat {

private Food food = new Food();



In the example above, class Wheat is related to class Food by composition, because Wheat has an instance variable that holds a reference to a Food object. In this example, Wheat is what I will call the front-end class and Food is what I will call theback-end class. In a composition relationship, the front-end class holds a reference in one of its instance variables to a back-end class.

The UML diagram showing the composition relationship has a darkened diamond.

Information Hiding

Information hiding is the process of hiding the details of an object in an abstraction, to reduce the external complexity and makes the object to become easier to use. Taking a bike as example, we access to the piston indirectly by using the 'start button' to run it, if we are allows to direct access to piston, it will be very difficult to control actions on the piston.

In another way, information hiding has the ability to prevent certain aspects of a class or software components from being access by clients. One of the common functions of information hiding is to hide the physical storage layout for data so that if it's changed, the change will be restricted to a small subset of the whole program.

It's reduces risk by shifting the code's dependency on an uncertain implementation onto a well-defined interface. Clients perform operations through the interface so if the implementation changes, the clients don't have to change.

Information hiding divides equipment, software or hardware into independent, interchangeable modules. A conceptual example that illustrates this principle is the modularization of a car, like example we decompose a car into modules into front, middle and rear part, or decompose the car into engine, transmission, steering, etc. Both way also can be used to decompose a car into modules.

Dynamic Binding

Dynamic Binding also known as Late Binding refers to the linking of a procedure call to the code to be executed in response to the call. It means that the code associated with a given procedure call is not known until the time of the call at run-time. It is associated with polymorphism and inheritance. A function call associated with a polymorphic reference depends on the dynamic type of that reference. If the type T of a variable with name N is implicitly associated by its content, we say, that N is dynamically bound to T. The association process is called dynamic binding. Both bindings differ in the time when the type is bound to the variable.

For example,

if condition() == TRUE then

n = 123


n = 'abc'

The type of n after the if statement depends on the evaluation of condition(). If it is TRUE, n is type of integer whereas in the other case it is of type string.

Another example is:

By inheritance, every object will have this procedure. Its algorithm is, however, unique to each object and so the draw procedure will be redefined in each class that defines the object. At run-time, the code matching the object under current reference will be called.


In this report, we had learnt that how to plan, analyze, design and develop information systems systematically using appropriate methodologies and strategies. It will develop strong skills in the analysis and determination of technological issues at management level. Also, plan, design and build prototype and functional application software and systems using acceptable and standard methods and tools for developing software; such as for analysis and design, choice of language, communication and database systems, and compiler-debugger tools. Each terminology is interrelated to each other with their own different role. For example, composition is depends on inheritance and polymorphism. Object-oriented approach to system development to manage information systems, all of the approaches has their own advantages and disadvantages that to fulfill each other's weaknesses and strengths so this mean we still cannot abandon the old traditional approaches until the newer approaches.