As we build programs with code that can be stored in multiple files, it becomes more and more important to be able to restrict access to certain attributes or methods, protecting them from being accessed outside of the class. This helps us maintain the data integrity of anything stored in our classes, and also prevents us from making intended mistakes by accidentally changing values that we shouldn’t change or calling methods that we shouldn’t call.
Right now, we have two options that we can use:
private. Anything that is marked
public can be accessed outside of this class, while things that are marked
private can only be accessed by code within the class.
In our UML diagram, we can denote public attributes and methods by placing a plus
+ symbol in front of them. Likewise, we can denote private items using a minus
In code, it is as simple as placing the
public keyword in front of all public items with the plus symbol in the UML diagram.
private keyword in front of items that should be private, as shown by the minus symbols in the UML diagram.
There we go! It is a very simple change to make, but it has very important consequences.
Let’s look at an example. On the left, we have the Security class we just updated. On the right, we’ll add some code to a
main() method in another class. First, we can create a new instance of the Security class. This is allowed because we marked the constructor in Security with the
public keyword. If it was marked
private, we would not be able to instantiate the class.
Next, we can try to print the value of the
name attribute. This is also allowed, since the
name attribute in Security is marked
public. Similarly, we are also allowed to call the
count() method since it is public.
What if we try to access the
secret attribute? In this case, since it is marked
private in the Security class, the compiler will throw an error, preventing us from even compiling this code. The same thing will happen if we try to call the
As we can see, using the
private keywords is a very useful way to protect data and methods in our classes from being accessed when they shouldn’t be. In a later video, we’ll see how we can create some special methods to allow read-only or write-only access to certain attributes.