Let's go back to fun facts activity and use this new method.

First, we need to instantiate a fact book object.

We'll do it similarly to how we created a new OnClickListener down here or

a new random object in the fact book class.

We'll use this new fact book object to do the work of getting us a random fact

when the button is clicked.

We could create it here, in the OnClick method.

But if we do that,

a new fact book object would be created every time we tap on the button.

That doesn't seem very efficient.

What if our object was huge, with thousands of facts to choose from?

On each tap,

we'd be wasting tons of processing time, just in recreating the fact book.

Instead, let's create it just once, as a field, or member variable.

Up here before the onCreate method, but after we define our class,

let's add some space, and type private FactBook, with a capital F.

And then let's name it factBook.

Which if we type a lowercase f, Android Studio will recommend for

us, and finally, a semicolon.

Notice we're using the class we just created as the data type for

this variable.

We're also using the private keyword because we only want this variable

to be available inside this class.

No other codes outside our activities need to know about it.

Next we need to initialize it.

Before the semi colon type equals new F and

use the auto complete to finish it.

Auto complete even adds the parenthesis to the end.

This creates a new FactBook object using the default constructor, but wait, we

didn't have a constructor to our FactBook class, and luckily we don't need to.

If we don't provide our own constructor,

Java will automatically create one behind the scenes.

So even if we don't add a constructor to our class,

we can always create new objects from that class by using the default constructor.

New, then the class name, and then an empty set of parentheses.

Back in the on-click method, lets get a random fact from our fact book object and

store it in a variable named fact.

Type String, fact, and

set it equal to factBook.cool.

Our get fact method is right at the top of auto complete.

But where did the rest of these methods come from, the ones we didn't write?

In java every single class either directly or indirectly extends the object class.

Even though we didn't use the extends keyword when writing our FactBook class,

it still extends the object class by default.

So these other methods come from the object class.

Let's hit Enter, then add a semicolon, and we're done.

Now let's take a quick review of our code.

We create our activity and give it the layout we'd like it to display.

Then we initialize our view variables to the views in the layout

by using their ids.

Then we create an onClickListener for our button and when the button is tapped

we use our FactBook object to get a random fact and update the factTextView.

Finally, we attach our on click listener to our button.

This looks pretty good, but let's take one more pass at our fact book class.

First, we see one of the main problems with using comments.

We ideally what to write a code that is easy to understand with

out additional comments.

Comments tend to be forgotten about after they are first written and

can end up not making any sense.

Like this one, let's delete it.

All right, there's one more thing we should change here.

Can you guess what it is?

One of the properties of our fact book is all of the facts it contains.

So this facts array should really be a property, field or

member variable of our fact book and not a local variable of the getFact method.

Let's cut the facts declaration from the getFact method, And then paste it up here.

Next we're going to test the app.

But first, just for fun, I'm going to show you another way we could have done this.

You don't have to follow along with this part, but you're more than welcome to.

I'm going to use Cmd or Ctrl+Z to undo all the way back to here.

Then I'll right-click on the facts variable, and select refactor.

But instead of picking rename I'm going to choose extract, and then field.

Then I'll choose where to initialize this new field, I'll pick field declaration,

which will put it at the top of the class, and then hit enter.

And then we go,

Android studio automatically factored our local variable to a field.

It even deduced that our facts variable can be declared as final

because we never make any changes to it.

Its functionality equivalent to what we had before.

But just to make it look exactly the same I'll delete the final keyword and

this optional new string bit.

And finally I'll cut and paste our comment to be above our new field.

There are tons of helpful tricks like this in Android Studio.

And they get even faster when you start using the keyboard shortcuts.

Last but not least, we're getting a couple of warnings from Android Studio.

Each of them is just letting us know that we can use a stricter access modifier.

And luckily, we can fix both of these just by using Alt+Enter.

But enough about that, we'll have more time for tips and

tricks once we get the basics down.

For now, let's run our app to test it.

Remember, the goal of refactoring is to make changes to the code

without changing the behavior of the app.

So it should work exactly the same as before.

Great work.