Now that we know all about hiding information in Ruby, let's apply our new skills to write a program that can store, update, and display a bank account balance.

Banking on Ruby

We'll start off by creating our `Account` class. First, though, you probably noticed this bit of fanciness in the last exercise:
```rb
    def initialize(name, balance=100)
      @name = name
      @balance = balance
```
What's that `balance=100` doing? It's signifying an **optional parameter**. Ruby is saying that you can pass one *or two* arguments to `initialize`; if you pass two, it uses your `balance` argument to set `@balance`; if you only pass  a `name`, `balance` gets a default value of `100`, and that's what gets stored in `@balance`.

You probably also noticed we used underscores in our `1_000_000` (one million). Ruby allows this, and it makes it easier to read big numbers! Cool, no?

Creating the Account Class

Let's go ahead and create our private methods. (It makes sense to create these first, since our public methods will rely on them.)

Private Affairs

Excellent work! You've got your very own `Account` class and `checking_account` instance, complete with public and private methods.

Go ahead and try to get to your `pin` from outside the class. Not easy, is it?

How could you improve this class? You might:

* Include a `deposit` method that lets users add money to their accounts
* Include error checking that prevents users from overdrawing their accounts
* Create `CheckingAccount`s or `SavingsAccount`s that inherit from `Account`

Well Done!

We're almost there! Now we just need to create an instance of `Account` so we can go about our banking business.

Opening an Account

All right! Now that you know how to control the level of privacy in a Ruby class, we can use that to our advantage when creating objects. In this case, we'll be making an `Account` object with public methods to display balances and transfer funds, but which rely on private methods to make sure the user's PIN (personal identification number) is correct before approving transactions.

**Note**: We're just using banking as an example because it's a nice real-world analogy. This isn't for real banking, so don't use any real banking information!

What You'll Be Building

Well done! Now let's add in our second public method, which will allow us to withdraw money from our account.

The trick to this one is to realize that since `@balance` can only be accessed from inside the class, we'll want to use `@balance -= amount` to decrease the balance by a certain amount.

Making a Withdrawal

Perfect! Now let's tackle the first public method, `display_balance`, which we'll use to display our current account balance.