Encapsulation:
Encapsulation is the mechanism
that binds together code and the data it manipulates, and keeps both safe from
outside interference and misuse. One way to think about encapsulation is as a
protective wrapper that prevents the code and data from being arbitrarily
accessed by other code defined outside the wrapper. Access to the code and data
inside the wrapper is tightly controlled through a well-defined interface. To
relate this to the real world, consider the automatic transmission on an
automobile.
It encapsulates hundreds of bits
of information about your engine, such as how much you are accelerating, the
pitch of the surface you are on, and the position of the shift lever. You, as
the user, have only one method of affecting this complex encapsulation: by
moving the gear-shift lever. You can’t affect the transmission by using the
turn signal or windshield wipers, for example. Thus, the gear-shift lever is a
well-defined (indeed, unique) interface to the transmission. Further, what
occurs inside the transmission does not affect objects outside the
transmission. For example, shifting gears does not turn
on the headlights! Because an
automatic transmission is encapsulated, dozens of car manufacturers can
implement one in any way they please. However, from the driver’s point of view,
they all work the same. This same idea can be applied to programming. The power
of encapsulated code is that everyone knows how to access it and thus can use
it regardless of the implementation details—and without fear of unexpected side
effects.
In Java the basis of
encapsulation is the class. Although the class will be examined in great detail
later in this book, the following brief discussion will be helpful now. A class
defines the structure and behavior (data and code) that will be shared by a set
of objects. Each object of a given class contains the structure and behavior
defined by the class, as if it were stamped out by a mold in the shape of the
class. For this reason, objects are sometimes referred to as instances of a
class. Thus, a class is a logical construct; an
object has physical reality.
When you create a class, you will
specify the code and data that constitute that class. Collectively, these
elements are called members of the class. Specifically, the data defined by the
class are referred to as member variables or instance variables. The code that
operates on that data is referred to as member methods or just methods. (If you
are familiar with C/C++, it may help to know that what a Java programmer calls
a method, a C/C++ programmer calls a function.) In properly written Java
programs, the methods define how the member variables can be used. This means
that the behavior and interface of a class are defined by the methods that
operate on its instance data.
Since the purpose of a class is
to encapsulate complexity, there are mechanisms for hiding the complexity of
the implementation inside the class. Each method or variable in a class may be
marked private or public. The public interface of a class represents everything
that external users of the class need to know, or may know. The private methods
and data can only be accessed by code that is a member of the class. Therefore,
any other code that is not a member of the class cannot access a private method
or variable. Since the private members of a class may only be accessed by other
parts of your program through the class’ public methods, you can ensure that no
improper actions take place. Of course, this means that the public interface
should be carefully designed not to expose too much of the inner workings of a
class .
Superb article. Thanks for sharing
ReplyDeleteJava training in Pune