Encapsulation and Abstraction differences with help of an example in java

Question

I know my question will be nominated to be closed immediately upon publishing, but let me tell you that I had been searching the site for a clear cut difference in terms of an example, in Java. Please don't be in a hurry to close the question.

I've written the following:

public class Bank {
public String name="XXX Bank";
private int noOfCust;

public int getNoOfCust() {
 return getNoOfCusts() + 2;
}
public void setNoOfCust(int noOfCust) {
if(noOfCust > 0)
{
this.noOfCust = noOfCust;
}
}

private int getNoOfCusts()
{
noOfCust = 100;
return noOfCust;
}
}

Here, 'noOfCust is the data being hidden'. I am not exposing the implementation part by introducing private getNoOfCusts(). So I believe this is encapsulation, because I have bundled all the details in a class and have hidden the data too.

Question 1: If this strong encapsulation ? If not, how could I improve it to be strongly encapsulated?

Question 2: Abstraction means complete hiding of the implementation. So what I've done above is abstraction?

I've posted this question out of frustration because I had given the above explanation to an interviewer, who told me, this is not the correct meaning.

P.S: Please answer in terms of above example. I don't want real time examples or assumptions.

Answer 1

Choosing necessary properties and hiding unwanted details is Abstraction. For e.g. Consider Person. Person has eyes, eyeColor, skinColor properties. But if he goes to Bank, then Bank does his Abstraction and does not consider these Person's properties but it selects name, address, phone_number. This is Abstraction. You misunderstood it.

Encapsulation simply means binding object state(properties) and behavior(methods) together. If you are creating class, you are doing encapsulation.

From wiki : In object-oriented programming languages such as C++, Object Pascal, or Java, the concept of abstraction has itself become a declarative statement - using the keywords virtual (in C++) or abstract (in Java). After such a declaration, it is the responsibility of the programmer to implement a class to instantiate the object of the declaration.

Answer 2

• The basic idea behind encapsulation is to hide the internal representation of an object from view outside of the class's definition. This is generally done to protect the internals of a class and provide a systematic way to access them.

• Also, the idea behind having getter/setter combo is to provide a controlled way of accessing the properties of that class. So, for each private property of a class, you would would have public setter() and getter() method.

Taking these two into account, you can very well see why there's a problem with your code in terms of encapsulation. A skeleton class having this concept implemented might be as follows:

public class Bank{
    private int noOfCustomers;
    private String name;


    public String getName(){
        return this.name;
    }

    public void setName(String name){
        this.name = name;
    }

    public int getNoOfCustomers(){
        return this.noOfCustomers;
    }

    public void setNoOfCustomers(int noOfCustomers){
        this.noOfCustomers = noOfCustomers;
    }

    /**
    * This method is to illustrate that it is perfectly valid to have
    * multiple types of setter methods
    */
    public void setNoOfCustomers(String noOfCustomers){
        try{
            this.noOfCustomers = Integer.parseInt(noOfCustomers);
        }catch(Exception exe){
            //Handle exceptions
        }
    }
}

Regarding abstraction: You can think of it as an idea of presenting something in a simplified way, which is either easily comprehensible in terms of usage or more pertinent to the situation. Taking your example, you can think of Bank as an abstraction that can both represent a Federal Bank or a State Member Bank or anything for that matter. You would basically derive specific classes for each of those representations, taking Bank as the parent.

I think you can get a better picture of abstraction if you study what File represents in Java. File in itself is an abstract representation of file and directory pathnames. However, if you study the source codes, you would find that it contains several properties that are private to its design.

Encapsulation, as such can be thought as how well you protect your properties from misuse and abstraction, as such can be thought of how much simplification are you providing to the external user.

Answer 3

Encapsulation: Okay, maybe. You have a very weird implementation, and the caller does not get to see it.

Abstraction: There we need to know what you are actually trying to do. The current interface looks like getter/setter of an integer value. That is not very abstract (and the implementation does not work like that, it does something else). For an abstraction the operation performed (or the object involved) needs to capture something that is not just divorced from the concrete implementation, but also applicable to a wider range of things (that are different, but still similar in that they can be made to belong under the same "abstraction"). Your example is probably just to small for this.

To try to build on the example, maybe you have a piece of code that categorizes businesses by their size. There would be the abstraction of "business" with properties such as number of customers, number of employees, etc. Code using this abstraction would work equally well with banks, pharmacies and grocery stores.

Answer 4

I believe you might be misunderstanding encapsulation and abstraction.

Encapsulation is more clearly explained in terms of a black box. The internals can change whenever necessary, but the public interface remains the same. With that said, your code is partially encapsulated, as you have a private int with a public getter and setter (and a private getter, which I see no purpose in, but that's up to you). However, String name is public and has no getter or setter; it appears you intend it to be a constant, in which case it should be declared as public, static, and final.

Abstraction is the concept of simplifying one idea to a more general, overhead idea. In Java, a class can be made abstract by providing an implementation which provides a general idea but lacks specifics, and it cannot be instantiated. This is achieved through the abstract modifier, which when modifying a class, denotes that the abstract class cannot be instantiated; when modifying a method (which must be in an abstract class), the modifier denotes that the abstract method must be defined in any subclass implementation.

Example of abstraction in Java, where abstraction dictates that Baseball is a Ball:

public abstract class Ball {
    // this class cannot be instantiated
    public abstract double getRadius();

    public double getVolume() {
        return (4.0 / 3) * Math.PI * Math.pow(getRadius(), 3);
    }
}

public class Baseball extends Ball {
    // this class can be instantiated
    @Override
    public double getRadius() {
        return 3.0;
    }
}

Answer 5

Encapsulation in java takes place automatically through objects and methods. You do not need to take care of that . However if you want , you may use different means of concealment to increase your complexity. So, others will be unable to decipher your code. You may use recursive functions and complicated methods and add unnecessary codes. Strong Encapsulation !!