Malika, there isn't anything really different between the two. In both cases (information hiding and encapsulation) one would use a get/set method to access the variable in question. By 'hiding' the information, the goal is to avoid direct access to the element in the data structure and having to understand the underlying implementation.

result = get_data (variable);

is much more preferable than

result = data_structure.variable;

Why would you do this you ask? Because I can change the underlying implementation of the data - put it in a substructure, or make it access dynamic memory - rather than be statically allocated - with breaking existing get/set code.

Simply and generally put, encapsulation means accessing data through Operations/Methods/Services (though these terms have different meanings).

Information hiding means hiding the implementation of data or functions to the users (pieces of code) and allow them to use/access via an interface to promote loose coupling.

Both of them aim at providing a stable interface for possibly changing implementations of data (structure and access) and functions (logic)

Data Encapsulation : This is an inherent object-Oriented trait of entity modelling. When we model an entity we encapsulate the associated actions/behavior and the data both in a single class. Simply Encapsulation has all to do with modelling , we don't encapsulate with any intent of security or Privacy.

Information hiding : With an ultimate intent to make data secure from intentional / accidental unprivileged access. Information hiding is more a specialization of abstraction.

Regards:

Majid

In very basic terms,

To 'Encapsuate' is to hide the complexities (& therefore information) in a capsule...

In OOP when we create a class, it is in the class that the complexities of attributes and methods are defined, but the user of the class need not be aware of all that is defined in the class.

The user just needs to know the usage. How the class is to be used, how the objects are to be created etc. The user thus may not have access to all components of a class and the data may thus be more secure.

Dear Malika Emam,

Encapsulation is the grouping of related ideas into one unit, While in Hiding

every module in the decomposition is characterized by its knowledge of a design decision which it hides from all others.

My understanding of Parnas' information hiding principle is to hide implementation details behind well-defined interfaces. This usually requires adequate language concepts. Encapsulation is one possible technique that uses object-oriented or modularity concepts to control visibility on classes or modules. According to Betrand Meyer's book "Object-Oriented Software Constructions", both terms are often used synonymously.

Information Hiding: The language should permit modules designed so that (1) the user has all of the information needed to use the module correctly, and nothing more; and (2) the implementor has all of the information needed to implement the module correctly, and nothing more. (Cf. Bruce J. MacLennan’s excellent book on Principles of Programming Languages, 2nd edition, 1986, ISBN 0-03-005163-0)

Encapsulation is just setting this together (e.g. in a class) and controlling the access by external classes, but you could show everything. Information hiding is a design principle, which tries to give the minimal information needed to the outside. This limits the dependencies in the software. Encapsulation is thus a technique that can support information hiding.

hmm...

Thanks to all of U, for Ur's eleboaration.

i would like to share one more reply which I' received, just for other learners like me... :)

Information hiding is hiding from external world and encapsulation is having attributes (properties, data) and function (actions) present inside of that body(class).

Let me try to give one example there is a circuit which performs some particular operation X for example. Circuit has its components a, b, c in one box but d in other box. Circuit can't work without all components i.e a, b, c and d. The connection between box 1 and 2 is of some wireless sort and this makes circuit to give required functionaly X here you can't say that elements of circuit are encapsulated in it self but they are partially inside and partially outside i.e 75% inside cirucit but 25% out of cirucit. If in some other case if you take all elements a, b, c, d inside one box then all elements are encapsulated within that circuit.

Information hiding is simply hiding it elements from external world and that what`s circuit is doing.

Encapsulation is about grouping, bundling and capsuling information inside class. information hiding is just hiding. Not sure how you feel difference of grouping, bundling and capsuling between encapsulation and information hiding.

Encapsualtion relates things together because things encapsulated inside are related for example let me write a class for you

class Matrix

{

private:

int rows;

int cols;

public:

Matrix addMatrix();

Matrix subMatrix();

Matrix transposeMat();

Matrix ApplyBrakes(); //Irrelevant function, looks relevent to vehicle class

};

See this example int rows and cols are attributes and addMatrix........ are functions. They are related to matrix. rows and cols are related to Matrix and functions too are related to Matrix class. For example, Applybrakes functions is relevant to vehicle class so must be there.

I'll try and make this simple.

Encapsulation is the bundling of data and a set of operations for that data into a single entity or box (object/module/unit etc). Good practice would dictate that access to the data by a client should be only through the provided operations. But encapsulation per se, does not stop the client accessing the data directly and impolitely by-passing the provided operations.

Data hiding is a step further, it forces the client to use the operations/methods/messages to access the data.

The definitions of encapsulation and data hiding have become confused and conflated because people tend to think in terms of the particular programming languages they are learning or teaching.

Most current programming languages give a mechanism for encapsulation. But the mechanisms for data hiding tend to differ.

Some programming languages give you data hiding by default (and you have to explicitly expose data). In others, by default, data is exposed and you have to explicitly hide data.

Hope this helps,

Rob

Thanks Mr. Robert Griffiths

I think information hiding and encapsulation are confusing terms since they themselves are in general not well-defined, and they depends even the paradigm, or the features of a particular language.

The wikipedia articles about encapsulation and information hiding are both very clear about this confusion.

So, trying to understand both concepts are near to be a chimera. However, more precise definition can be reached in more closed contexts.

Finally, check this link: http://stackoverflow.com/questions/742341/difference-between-abstraction-and-encapsulation?lq=1

and this one: http://stackoverflow.com/questions/24626/abstraction-vs-information-hiding-vs-encapsulation?lq=1

In OO world information hiding is a kind of philosophy. Encapsulation is the way to achieve this philosophy. One can hide information in many ways , in encapsulation, it gives some specific rule to hide/isolate information.

It's a good practice to hide information in a class. This separates the data and code for misuse or confused with. When the size of the class is very big and have potential reusable methods codes..... encapsulation become a need.

For example, in a class there will be a lot of temporary variables which is not required to be inherited or expose. Only a set of variables, containing the end result needs to be exposed. such instances we can use encapsulation.

In C++ or C# the below code will encapsulate a sampledata variable.

private String SampleData;

public String SampleDataExp

{

get { return SampleData; }

set { SampleData = value; }

}

In the set function, one can use string desensitization or look for special character and raise error messages. internally the class methods can use SampleData. treating it to be a safe variable. Any other code outside the class can only access SampleDataExp.

Encapsulation is the grouping of related ideas into one unit, which can thereafter be referred to by a single name.

Function is the simplest level of encapsulation and abstraction: a designer can refer to it by name as a single entity and even forget the details of the internals and only remember its interface.

Encapsulation in the object oriented world expands on this concept from the subroutine level to the class.

public class Point

{

double GetX();

double GetY();

void SetCartesian(double x, double y);

double GetR();

double GetTheta();

void SetPolar(double r, double theta);

}

In this example, encapsulation is that we have grouped together the related items of Point in one unit and name it by Point (class). But the implementation of methods is completely hidden: the client doesn’t know how these methods work (separate file of methods coding will be made). This is called information hiding.

Thanks Sir (Aarón , Bishwajit & Muhammad Sharif)...no doubt every point gave me more clarification in this confusion..

The Difference Between Encapsulation and Information Hiding

If you ask people familiar with Object Oriented Design which are the most important concepts of the paradigm to them, you will surely hear things likeclasses, inheritance, polymorphism. Some may talk aboutgenericity; somebody may even mention encapsulation orinformation hiding.

In fact, many designers use the words encapsulation and information hiding interchangeably.

Encapsulation

In his book  Fundamental Of Object Oriented Design in UML Meilir Page-Jones gives the following definition for encapsulation:

Encapsulation is the grouping of related ideas into one unit, which can thereafter be referred to by a single name.

Single name is here the key word to get an insight of what encapsulation is about: a subroutine (orfunction as we call it nowadays), for example, is a name that refers to a unit of code. Something that instead of being repeated over and over in the source code is factored out in a single place.

As such the function is the simplest level of encapsulation and abstraction: a designer can refer to it by name as a single entity and even forget the details of the internals and only remember its interface.

Encapsulation in the object oriented world expands on this concept from the subroutine level to the object level: attributes that represents the state of an object and the methods that work on them are packaged into an object type.

Information Hiding

The concept of information hiding is very similar and was first introduced by Parnas in his seminal paper “On the Criteria to Be Used in Decomposing Systems Into Modules” (pdf) almost 40 years ago.

Parnas used the term discussing about which criteria lead to good modularity in structured programming:

every module in the […] decomposition is characterized by its knowledge of a design decision which it hides from all others. Its interface or definition was chosen to reveal as little as possible about its inner workings.

As you see, here also we talk about some separate entity or module which has some responsibility that we need fulfilled, and we are not interested about how it is fulfilled. But the emphasis here is a bit more about hiding the details from other modules (or objects in the OO world).

Information hiding gives the designer the freedom to modify how the responsibility is fulfilled by a module/object. This is especially valuable at points where the design (or even the requirements) are likely to change.

Uncle Bob Helps Explaining the Difference

Maybe one of the best example explaining the difference between encapsulation and information hiding can be found in Uncle Bob’s most recent book Clean Code (even though the author was not talking about these 2 concepts explicitely).

The following type is merely encapsulated: we have created a concept representing a geometrical concept (the point in a 2D space).

public class Point

{

    public double x;

    public double y;

}

The following type, on the other hand, is an example of information hiding applied to the same concept:

public interface Point

{

    double GetX();

    double GetY();

    void SetCartesian(double x, double y);

    double GetR();

    double GetTheta();

    void SetPolar(double r, double theta);

}

In this second example, the actual implementation is completely hidden: the client doesn’t know whether the internal representation of the point is in rectangular or polar coordinates.

If you are curious and want to know more, you can refer to the following wiki for more opinions on the differences (or lack thereof) between encapsulation and information hiding.