In this modern time, we constantly strive for simplicity. You save time writing "can't" rather than "cannot." Instead of driving cross-country, flying is much faster. Technology has advanced to the point where we can now store large amounts of data on tiny devices. Even though social media has allowed you the convenience of hiding specific posts from the public, it still allows your select followers to view them. The same goes for data.
In Java, we use a process to bind data into one unit called Encapsulation. This process allows us to protect our data while providing access to it when needed. Java offers several features that help you achieve encapsulation, including access modifiers and inner classes. This article will look closely at using these features to protect our data. We'll also see how encapsulation can make your code more maintainable and easier to understand.
Let's get started.
What is Encapsulation in Java?
Encapsulation is a programming technique that restricts access to data and methods in an object, preventing them from being used or changed by outside sources. Encapsulation is common in object-oriented languages like Java. It can protect your data from being directly accessed and manipulated, leading to mistakes.
Encapsulation is necessary because it allows you to control how your data is used. You can specify what methods can access and change your data and what restrictions those methods have. For instance, you may want to allow a method to change your data, but only if certain conditions are met. By specifying these conditions, you can prevent your data from being changed in ways you don't want.
Access Modifiers
In Java, there are four access modifiers: public, private, protected, and default. These modifiers control who can access a particular member of a class.
- The public modifier is the most permissive. A member that is declared public is accessible from anywhere.
- The private modifier is the most restrictive. A member declared private is only accessible from within the same class.
- The protected modifier is similar to the private modifier but with one crucial difference. A member declared protected can be accessed from outside the class, but only by subclasses.
- The default modifier is used when no access modifier is specified. A member declared with the default modifier is accessible from anywhere within the same package.
Generally, it is best to use the most restrictive access modifier that makes sense for a particular member. By using more restrictive access modifiers, you can better protect your data.
Let's say you have a class that represents health records. You'll want to ensure that this class's data is well-protected because it contains sensitive information. In this case, you would use the private modifier for all your class members. This would prevent anyone outside the class from accessing or changing your data.
On the other hand, let's say you have a class that represents restaurants. In this case, you might want to use the public modifier for some of the members in your class because you want other classes to be able to access and use them. It is best to use more restrictive access modifiers unless you have a good reason to use a less restrictive access modifier.
Inner Classes
Another way to achieve encapsulation in Java is by using inner classes. An inner class is a class declared within another class. Inner classes can be either static or non-static.
Static inner classes are similar to top-level classes, accessible from anywhere, and they don't have access to the members of the outer class. Non-static inner classes, on the other hand, have access to the members of the outer class and get declared with one of the four access modifiers (public, private, protected, or default).
Inner classes can achieve encapsulation because they allow you to control how other classes can access your data. Using the health record class example from earlier, you might want to create an inner class representing the blood type for that health record. By making the BloodType class an inner class of the HealthRecord class, you can control how other classes can access the transaction data.
Inner classes are a great way to achieve encapsulation in Java. They allow you to control how your data is used and make your code more maintainable and easier to understand.
Setters and Getters in Java
In Java, every class has a default constructor that takes no arguments. In addition, every class has two special methods: a setter and a getter. The setter sets the value of the member variable, and the getter retrieves the value of the member variable.
The setter and getter methods are automatically generated by Java when you create a class. You don't have to write them yourself. However, you can override these methods if you want to provide your own.
Using setters and getters, we can control who can access our data and what they can do with it. We can also specify what restrictions those methods have.
To create one of these methods, you simply use the keyword "set" or "get" followed by the name of the member variable. Here's how you would create a setter for the age variable:
This sets the age variable to the given integer value.
Likewise, here's how you would create a getter for the age variable:
This returns the current value of the age variable.
Now that we've seen how to create setters and getters, let's look at an example. In the following code, we have a class that represents a person. This class has two member variables: name and age. We've also created setter and getter methods for these member variables.
As you can see, the setter and getter methods are straightforward. The setter method takes an argument of the same type as the member variable. It then sets the member variable to that value. The getter method returns the value of the member variable.
For more details, check out this video about encapsulation in Java:
Java Encapsulation Examples
Now that we've seen what encapsulation is and how they are used, let's take a look at some examples.
Example #1:
You have a class that represents a bank account. This class has two members: an account number and a balance. You want to ensure that the data in this class is well-protected, so you decide to use the private modifier for both members.
Here's what your class would look like:
In this example, the BankAccount class has two private members: accountNumber and balance. The class also has two public methods (getters and setters) that access these members.
Example #2:
Let's say you have a class that represents a shape. This class has two members: a width and a height. You want other classes to be able to access and use these members, so you decide to use the public modifier for both of them.
Here's what your class would look like:
In this example, the Shape class has two public members: width and height. The class also has a constructor that initializes these members and a method (getArea) that calculates the shape area.
How can encapsulation improve your code?
Encapsulation is a powerful tool that protects the data in your classes. It is one of the four key principles of object-oriented programming. Using encapsulation within your program improves maintainability, flexibility, and privacy. Anything that can be changed and is more likely to change in the future is a candidate for Encapsulation. If you have not started encapsulating classes, you should consider doing so.
