Struggling with java encapsulation concept
oop - Java encapsulation - Stack Overflow
ELI5: Encapsulation
You can find examples of it even in Android designs, it's just the apps tend to be simpler so class encapsulation is less emphasized. Most of the design principals are less "required" in smaller applications. The principles don't lose their importance per se, you just don't suffer the same degree of consequences if you skip them. The larger a system gets the more important it is that you followed the fundamentals from the beginning.
Encapsulation is a set of implementation specifics over a broader concept.
The main concept is this: don't give outside users of a "thing" (class, method, whatever) access to, control of, or knowledge of the internals of said thing. They should know or have the minimum they need to do their job and find the "thing" useful. (In security the phrase is "principal of least privilege" and while it is different, it follows pretty close logically.)
If I am designing a class, I don't want the outside world (consumer of the class in this context) to know about or have access to my internals, such as:
-
memory -> I can't control my data if I give them access to it
-
adherence to SRP -> (Single Responsibility Principal) - By exposing as little as possible, a small "contract", the object can more easily adhere to SRP. This one is a bit off topic but valuable in class design.
-
implementation details -> I want the abstraction that the class represents to not "leak" its internal implementation details - if I use an array versus some kind of list for storage I don't want the consumer of the class to know about it, instead I expose to them a generic "collection", preferably through an interface. How I store and access the data is my business, how you use what I expose to you is yours.
These design principals are important for a lot of reasons, but to me the most important is the simple fact that things change. The requirements of the system as a whole will change over time and as a result refactoring, extension, and/or modification will be required. The better design a system has, the easier it will be to change and adapt the software to the new conditions. If my abstractions are leaky then when I change the internals of that class I'll also have to go and change all of the consumers of that class. (Not ideal and sometimes that choice will land outside of your control and therefore make it impractical or even impossible to change.)
With respect to security, it follows along the same logic. By not giving them access to my internals I am in control of the changes in state. If I am in control then they can't "hurt" me. Basic GIGO (garbage in, garbage out) -> never trust your user, even when your user may be another developer, even when that other developer may be you.
More on reddit.comEncapsulation in Java
I've watched many videos, asked gpts, read a few docs but still can't get the clarity. What is encapsulation exactly?, Why is it used? I'm just fixed with: to achieve encapsulation you need to make variables private and write getters,setters. But I'm not understanding wts the help we r getting from this? Anyone with the knowledge of setter name can modify the data!! Pls anyone clarify my doubt
Encapsulation is more than just defining accessor and mutator methods for a class. It is a 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 an 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 and 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 on the data itself, and not on 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 types)
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 not 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 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 subsystems, like a transmission system, a brake 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 backward. 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 were 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 manufacturers 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 it's 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.
The way I understand your question is, although we declare variables as private, as those variables can be accessed using getters and setters, they are not private. Therefore, what is the meaning of doing that?
Well, when using getters and setters, you can restrict access to the private variables.
I.e.,
private int x;
public int getInt(String password){
if(password.equals("RealPassword")){
return x;
}
}
And the same for the setters.