OO programming has a lot of advantages over procedure programming, many of them are achieved by data encapsulation.

Procedure programming can also call existing functions to achieve code reusing, but functions and data are separate - in other words, functions are stateless - they don’t remember their own state across different calls. Whenever a function is called, all data to be manipulated have to be passed to and returned by the function. Data are therefore exposed to programmers, who may manipulate the data wierdly or carelessly. Besides, a single piece of data may be passed around and handled by a lot of functions within a large project. When an error finally emerges, it may be very difficult to find out where the error happens.

In comparison, OO programming with data encapsulation can avoid these problems. Because data are encapsulated with functions to form an object, functions can remember their own state and their results. There is no longer need to pass this part of data to these functions every time they are called. Sensitive or private data can be therefore isolated from outside world. If anyone wants to do anything on the data, they have to do it through the object’s functions, which can be well defined and error-proof.

This simulates real world objects better. Take a man as an object. This object can have a data members such as body temprature. Other people can not directly change his body temprature without going through his own cooperation and physical reaction. So body temprature is a private data members isolated from the public. This isolation eliminates the possibility that other programs may accidentally change an object’s own sensitive data inproperly.

A well-written class is cohesive and self-contained. It contains all necessary data to similate the real-world problem, all necessary functions to manipulate these data and provide services to outside world. It exists and functions quite independently, reducing the coupling with outside world to the lowest extent, and therefore may be reused in different occasions.

An object “knows” how to behave itself properly – how to construct and initialize itself, how to response to different kinds of external messages properly, how to destroy itself, etc.. Once a class is properly written and fully tested, other programs can simply make use of it to perform a certain task, and will have little chance to encounter any error.  This greatly reduces the complexity of programming and possibility of errors.

So generally speaking, OO programming and data encapsulation has the following advantages:

1.        Reduces data exposure: because private data are encapsulated within objects, when their functions are called, less data need to be tranmitted. These reduces the exposure of data and the chance of errors.

2.        Clearer responsibility for data: because each object is responsible for his own private data and others can not wrongly change it, when a piece of data is wrong, we easily know who is doing the wrong thing.

3.        Less error-prone: if a project uses only those well-written and fully tested classes, it is much easier to organize, modify, debug and maintain than those written in procedural languages. The bigger the size, the more obvious the advantage.

4.        More stable for clients: when a class's implementation is changed, as long as its function signatures are not changed, a program which uses this class will not be affected.

5.        Enhances software reuse: by composition (including other object as data member) and inheritance (build a new class based on a base class), software reuse is greatly strengthened.

Posted By :-Cplusplusprogramming
Designed By Blogger Templates | Templatelib & Distributed By Blogspot Templates