By now you’re probably catching onto what the private keyword does. When a Class’ instance variable or method is marked as private, that means that you can only access those structures from elsewhere inside that same class. Let’s look back at our DogSchool example:
makeADog is trying to directly access Dog‘s .age variable. It’s also trying to use the .speak() method. If those are marked as private in the Dog class, the DogSchool class won’t be able to do that. Other methods within the Dog class would be able to use .age or .speak() (for example, we could use cujo.age within the Dog class), but other classes won’t have access.
Keep Reading: AP Computer Science A Students
At this point, you might be thinking to yourself “Why even bother with any of this? In the last exercise, my code was broken until I flipped some variables and methods to public. Why don’t I just make everything public?”
While those are valid points, sometimes restricting our code is actually useful from a design perspective. This is one of the core ideas behind encapsulation. By making our instance variables (and some methods) private, we encapsulate our code into nice little bundles of logic.
For example, a Bank object doesn’t necessarily need to know the inner workings of a CheckingAccount object. It doesn’t need to know that the money is stored in a field named money, or that interest is added to an account by using a method named .addInterest(). In fact, if it had access to those fields or methods, it’s possible that someone using a Bank object could change things in a CheckingAccount without realizing it. By limiting access by using the private keyword, we are able to segment, or encapsulate, our code into individual units.
Note that we don’t necessarily want to completely block everything from other classes. In the next exercise, we’ll get into when you might want to make methods public — we’ll take a look at getter and setter methods.
Instructions
We’ve changed the variables and methods in CheckingAccount.java back to private. To begin, go to Bank.java and run your code. Let’s confirm that we get errors when a Bank tries to access private data from a CheckingAccount
A Bank couldn’t access a CheckingAccount‘s private structures. Let’s prove to ourselves that CheckingAccount can access its own private fields.
Go to CheckingAccount.java. In the main() method, create a new CheckingAccount named myAccount. You’ll have to use the constructor that takes a String and an int.
Run CheckingAccount.java to create this object.
Let’s confirm that we can access a CheckingAccount‘s private fields since we’re writing in CheckingAccount‘s main() method. Still in CheckingAccount.java, print out myAccount‘s balance.
Let’s also confirm that we can use private methods. Call addFunds() to add 5 dollars to myAccount‘s balance. Then print the balance again to confirm the money was added. Continue to do this work in the main() method of CheckingAccount.java.