Encapsulation concept

I have 开发者_Python百科problem with concept and implementation of encapsulation.

Can someone explain it to me?

Encapsulation is a moderately easy concept once you realise it (probably) comes from the same base word as capsule.

It's simply a containment of information.

Encapsulation means that a class publishes only what is needed for others to use it, and no more. This is called information hiding and it means classes can totally change their internals without having an effect on any of their users.

In other words, a dictionary class can begin life as a simple array and progress to a binary tree of words then even maybe to some database access functions, all without changing the interface to it.

In an object oriented world, objects hold both their data and the methods used to manipulate data and that is the pinnacle of encapsulation. One way this is done is to make sure each object knows which functions to call to manipulate its data, and ensure the correct ones are called.

As an example, here's a class for maintaining integer lists in my mythical, but strangely Python-like and therefore hopefully easy to understand, language:

class intlist:
    private int val[10]    # Slots for storing numbers.
    private bool used[10]  # Whether slot is used or not.

    public constructor:
        # Mark all slots unused.

        for i in 0..9:
            used[i] = false

    public function add(int v) throws out-of-memory:
         # Check each slot.

        for i in 0..9:
            # If unused, store value, mark used, return.

            if not used[i]:
                used[i] = true
                val[i] = v
                return

        # No free slots, so throw exception.

        throw out-of-memory

    public function del(int v) throws bad-value:
         # Check each slot.

        for i in 0..9:
            # If slot used and contains value.

            if used[i] and val[i] == v:
                # Mark unused and return.

                used[i] = false
                return

        # Value not found in any used slot, throw exception.

        throw bad-value

    public function has(int v):
         # Check each slot.

        for i in 0..9:
            # If slot used and contains value.

            if used[i] and val[i] == v:
                return true

        # Value not found in any used slot.

        return false

Now the only information published here are the constructor and three functions for adding, deleting, and checking for values (including what exceptions can be thrown).

Callers need know nothing about the internal data structures being used (val and used), or the properties of the functions beyond their "signatures" (the content of the "function" lines).

Because everything else is encapsulated, it can changed it at will without breaking the code that uses it.

I could, for example, do any of the following:

• make the arrays longer;
• store the data sorted, or in a binary tree instead of an array to make it faster.
• change the used array into a count array (initialised to zero) so that many occurrences of a single number use just the one slot, increasing the quantity of numbers that can be stored where there are duplicates.
• store the numbers in a database, located on a ZX-80 retro-computer located in outback Australia, and powered by methane produced from kangaroo droppings (though you may notice a latency change).

Basically, as long as the published API doesn't change, we am free to do whatever we want. In fact, we can also add things to the API without breaking other code, I just can't delete or change anything that users already rely on.

You should note that encapsulation isn't something new with object orientation. It's been around for ages, even in C by ensuring that information is hidden within a module (usually a source file or group thereof with private headers).

In fact, the stdio.h FILE* stuff is a good example of this. You don't care what's actually behind the pointer since all the functions which use it know how to do their stuff.

link text

I always explain it to people is think of yourself as an object. Other people can see your height, they can see if your smiling, but your inner thoughts, maybe the reason while your smiling, only you know.

Encapsulation is more than just defining accessor and mutator methods for a class. It is broader concept of object-oriented programming that consists in minimizing the interdependence between classes and it is typically implemented through information hiding.

The beauty of encapsulation is the power of changing things without affecting its users.

In a object-oriented programming language like Java, you achieve encapsulation by hiding details using the accessibility modifiers (public, protected, private, plus no modifier which implies package private). With these levels of accessibility you control the level of encapsulation, the less restrictive the level, the more expensive change is when it happens and the more coupled the class is with other dependent classes (i.e. user classes, subclasses).

Therefore, the goal is not to hide the data itself, but the implementation details on how this data is manipulated.

The idea is to provide a public interface through which you gain access to this data. You can later change the internal representation of the data without compromising the public interface of the class. On the contrary, by exposing the data itself, you compromise encapsulation, and therefore, the capacity of changing the way you manipulate the data without affecting its users. You create a dependency with the data itself, and not with the public interface of the class. You would be creating a perfect cocktail for trouble when "change" finally finds you.

There are several reasons why you might want to encapsulate access to your fields. Joshua Bloch in his book Effective Java, in Item 14: Minimize the accessibility of classes and members, mentions several compelling reasons, which I quote here:

You can limit the values that can be stored in a field (i.e. gender must be F or M). You can take actions when the field is modified (trigger event, validate, etc). You can provide thread safety by synchronizing the method. You can switch to a new data representation (i.e. calculated fields, different data type) However, encapsulation is more than hiding fields. In Java you can hide entire classes, by this, hiding the implementation details of an entire API. Think, for example, in the method Arrays.asList(). It returns a List implementation, but you do no care which implementation, as long as it satisfies the List interface, right?. The implementation can be changed in the future without affecting the users of the method.

The Beauty of Encapsulation

Now, in my opinion, to really understand encapsulation, one must first understand abstraction.

Think, for example, in the level of abstraction in the concept of a car. A car is complex in its internal implementation. They have several subsystem, like a transmission system, a break system, a fuel system, etc.

However, we have simplified its abstraction, and we interact with all cars in the world through the public interface of their abstraction. We know that all cars have a steering wheel through which we control direction, they have a pedal that when you press it you accelerate the car and control speed, and another one that when you press it you make it stop, and you have a gear stick that let you control if you go forward or backwards. These features constitute the public interface of the car abstraction. In the morning you can drive a sedan and then get out of it and drive an SUV in the afternoon as if it was the same thing.

However, few of us know the details of how all these features are implemented under the hood. Think of the time when cars did not have a hydraulics directional system. One day, the car manufactures invented it, and they decide it to put it in cars from there on. Still, this did not change the way in which users where interacting with them. At most, users experienced an improvement in the use of the directional system. A change like this was possible because the internal implementation of a car is encapsulated. Changes can be safely done without affecting its public interface.

Now, think that car manufactures decided to put the fuel cap below the car, and not in one of its sides. You go and buy one of these new cars, and when you run out of gas you go to the gas station, and you do not find the fuel cap. Suddenly you realize is below the car, but you cannot reach it with the gas pump hose. Now, we have broken the public interface contract, and therefore, the entire world breaks, it falls apart because things are not working the way it was expected. A change like this would cost millions. We would need to change all gas pumps in the world. When we break encapsulation we have to pay a price.

So, as you can see, the goal of encapsulation is to minimize interdependence and facilitate change. You maximize encapsulation by minimizing the exposure of implementation details. The state of a class should only be accessed through its public interface.

I really recommend you to read a paper by Alan Snyder called Encapsulation and Inheritance in Object-Oriented programming Languages. This link points to the original paper on ACM, but I am pretty sure you will be able to find a PDF copy through Google.

Encapsulation - wrapping of data in single unit. also we can say hiding the information of essential details. example You have a mobile phone.... there it some interface which helps u to interact with cell phone and u can uses the services of mobile phone. But the actually working in cell phone is hide. u don't know how it works internally.

hide/bind something : eg: a capsule (which we consume when v r ill)hide/bind some powder form in itself,, means that capsule encapsulate the powder contained it.

Binding of data and behavior i.e functionality of an object in a secured and controlled manner.

or the best example of encapsulation is a CLASS because a class hides class variables/functions from outside d class..

Encapsulation: Wrapping up data member and method together into a single unit (i.e. Class) is called Encapsulation.

Eg: we can consider a capsule. Encapsulation means hiding the internal details of an object, i.e. how an object does something. Here capsule is a single Unit contain many things. But we cant see what is there in side capsule.

This is the technique used to protect information about an object from other objects. Like variable we can set as private and property as Public. When we access the property then we validate and set it.

We can go through some other examples. Our Laptop. We can use Laptop but what operations are happening inside that we are not knowing. But we can use that. Same like mobile, TV etc.

We can conclude that a group of related properties, methods, and other members are treated as a single unit or object.An encapsulated object is often called an abstract data type.

There are several other ways that an encapsulation can be used, as an example we can take the usage of an interface. The interface can be used to hide the information of an implemented class.

//Declare as Private

   private string _LegName;

// Property Set as public

public string LegName
 {
  get
  {
    return _LegName;
  }
  set
  {
    _LegName=value;
  }

 public class LegMain
 {
   public static int Main(string[] args)
   {
    Leg L= new Leg();
    d.LegName="Right Leg";
    Console.WriteLine("The Legis :{0}",d.LegName);return 0;
   }  
  }

Note: Encapsulation provides a way to protect data from accidental corruption.

Thank you

Encapsulation means hiding the data. In other words a class only exposes those properties or information which is authorized to be seen. Consider the below exapmle where a certain property called ConfidentialMessage is accesible only to the Admin role. This property is made private and is returned through another method which checks the role of an user and return the message only for admin.

    public class Message
    {
        public Message()
        {
            ConfidentialMessage = "I am Nemo";
        }
        private string ConfidentialMessage { get; set; }
        public string GetMessage(string name)
        {
            string message = string.Empty;
            if (name == "Admin")
            {
                message = this.ConfidentialMessage;
            }
            return message;
        }
    }      

Putting definition of encapsulate

enclose in a capsule, from en- "make, put in" + capsule + -ate .

now capsule meaning is box, case

In real life example if you put things on desk open then it is accessible to anyone but if you put in case then it is accessible with the key of case to open. Same way in class if you create a variable then it accessible whenever you create object of that class.But if you create function to access the variable then you have created case and function is key to access the variable.

So in programming language we are creating wrapper of the data by using getter and setter and making it private variable.

Encapsulation is a capsule, consider it to be a class enclosing or hiding fields, properties and functions.

Please check below url encapsulation is simplified with simple programming example.

http://itsforlavanya.blogspot.com/2020/08/encapsulation.html?m=1