Back in our FunFactsActivity class, we've just finish setting it up so

when we tap on our button, this onClick listener detects that tab and

then runs the code we see here between the brackets.

Right now, the app is pretty boring, it just shows this one fact over and

over each time we hit the button.

Let's take a look at this code and

talk about how we can change it to be more exciting.

We start with a string variable named fact, which holds the text of our fact,

but for now it's hardcoded as, Ostriches can run faster than horses.

To make this dynamic,

we need to change the fact variable based on some sort of randomization.

Let's start by setting our fact variable equal to an empty string by deleting

everything between the quotation marks.

We have to leave our fact variable equal to something or

else we'll get an error when we try to set the text.

Then let's add some comments to give us an outline of what we hope to accomplish.

Let's add a line above our fact.

And then say Randomly select the fact.

Then let's add two lines below our fact variable and add a comment that says

Update the screen with our new fact.

And that's all that really is to the heart of our app.

We randomly choose a fact and then we display it to the user.

All right, let's start by creating a new random object named random generator.

Random is a class provided by Java itself that makes it easy for

us to generate all sorts of random numbers.

Let's add a new line up here, and then ty[e val randomGenerator,

and let's set it equal to a new random object by typing Random(),

then use Alt+Enter to import the class.

Then let's create a new val named randomNumber to store the random number

we generate.

And let's set it equal to randomGenerator.nextInt

to set it to a random integer.

Now we're generating a random integer.

But how do we know what range it's going to be in?

What if it's a really high number?

We are only going to have ten facts in our app.

But for right now, let's pretend that we only have three facts to keep it simple.

How can we limit our random number generator to just the three choices?

Luckily, there's another version of the nextInt method that takes in a parameter

to tell it how many numbers to choose from.

Let's go back between the parentheses and type a 3.

Now seems like a good time to stop and

make sure we have things working like we want them to.

Instead of setting our label for

the blank string stored in the fact variable, let's quickly test our

random number generator by setting our fact variable equal to our random number.

And we get an error down here where we update the text view.

If we hover over it, it says, type mismatch.

Our TextView requires us to use a char sequence or

a string when updating the text, but we're passing in an int.

Since we're not specifying a type or a fact variable,

its type will be the same as whatever we set it equal to.

So in this case, by changing it from an emptyString to randomNumber,

we've changed our fact variable from a string to an int.

To change it back to a string, all we need to do is call toString on our random

number variable, .toString.

All right, let's run this and see what happens.

And if we click on our button,

we see that our text view gets updated with different numbers.

Cool, and it looks like the list of numbers starts at zero instead of one.

So we get zero, one, and two instead of one, two, and three.