[MUSIC]

Welcome back.

We're getting ready to put the final touches on our MVP and

we've only got a few user stories left.

So the next one up is, as a guess or I should be stopped for

making a guess that has already been made, so that I do not waste turns.

Okay, so let's think this through real quick.

So when we pass a guess into our game object if you applyGuess,

we currently just add it to hits or misses.

What we need to do before we do any of that,

is to add a check to see if it's already been guessed.

Which we can do by seeing if it's in hits or misses.

Now if it has been guessed,

we need to let the caller on applyGuess know that they did something wrong.

We should do this at the game object level,

that way any other consumer of our game logic will benefit.

Then how should we let them know do you think?

Well it's exceptional behavior.

Hey, why don't we throw an exception, and

then any caller of that method can handle that.

Let's give it a try.

All right, so let's move this prevent multiple guesses into in progress, and

let's head over to our game class.

So let's take a look here in applyGuess.

So this is probably where we wanna run our check, right?

So before anything happens, let's do it.

We wanna see if what was passed in letter here is either in hits or misses.

So why don't we lean on indexOf.

Now remember, negative one shows that it's not found, so don't try to do this?

Why don't you go try to do this, see if misses has the letter, or

hits has the letter.

Go ahead, possibly.

Okay, here's how I did it.

So if misses.indexOf has the letter,

and again that's not not found.

If it's not not found, if it's found or

hits.indexOf(letter) is not equal to 1.

So again, that pipe means or, so

if either one of those is true, then we'll throw an exception.

I'm gonna go ahead and close my if.

So we'll throw this exception, right?

The argument that they passed in here was not allowed,

this letter argument is not allowed.

It's in the illegal argument, so

that sounds like an illegal argument exception, right?

So again, that's throw and we make a new one of those,

IllegalArgumentException, and it takes a message.

So let's go ahead and say letter has already been guessed.

Awesome, so that should do it.

So now what we need to do,

is we need to see whoever calls this method in any of our code.

We wanna make sure that they're handling this exception that can come out properly.

So in workspaces, what I can do is I come up here and I can say Edit, and

I can choose Find in Files.

Brings up a little search box up here, and I'm gonna try to find applyGuess.

And so what that'll do is it will search through all of our files, and

it found one here in Prompter where we're using it.

Which we know we just wrote this code.

But I wanted to show that example of how to use workspaces to find

where these exceptions might be called.

Okay, so the Prompter is currently returning the result of game.applyGuess.

So we don't want the exception to throw out a here basically.

Let's let's catch this.

So first thing we wanna do is we want to store that in a variable.

So let's go ahead and let's say boolean isHit equals that.

And then we wanna make sure that we still return it right,

cuz the method still wants a boolean.

So we'll say return isHit.

Okay, so now we

need to try to wrap this call to applyGuess in a try catch block.

So let's do that.

So let's make a new try.

Open that up.

I'm gonna go ahead and close that.

And then immediately we'll do a catch, and

we're catching the IllegalArgumentException.

Again you can name this whatever.

I like to name them, iae, IllegalArgumentException, and

we'll close the catch there.

Okay, so let's go ahead, and I wanna move this into the try.

And in here, what we'll do is we will just go ahead and

output the message that we have our hands already.

And we're in the Prompter, so we can prompt here.

And say printIn, and we'll just say that there was an error basically, and

it'll say getMessage, right?

That was that letter that could not be found that we put in.

So now we have a little bit of a problem, and

it might not be too obvious just looking at this.

So, remember how each one of these curly braces opens up a new scope.

Well, let's look at what we're doing in this try scope here.

We're declaring a variable called isHit in this scope.

But then we're attempting to use it in an outer scope here.

So see how this is an outside,

it's in the method scope but it's not in the try scope.

The declaration is happening inside the try scope.

If you tried to compile this, you would get an unknown symbol with an arrow

pointing right here to this isHit when you try to compile it,

which is basically saying, I have no idea what you're talking about.

That's because it's declared here.

So what we need to do, is we need to declare the variable

outside of the try block, so isHit equals false.

And then we can remove this declaration and just set it.

So there's no problem with the inner scope accessing this outer scope

here at the method scope it has access, this is declaring the method scope and

inner scope has access here but it's the other way around that doesn't work, right?

We can't define something in the inner and then how the outer work.

So now let's imagine what would happen.

So if we passed in a t and then we passed in a t again, so it's gonna come in here.

It's gonna call the applyGuess, and applyGuess is gonna throw an exception,

right, cuz it's gonna find that it's been found already.

So it's in hits, so one of these is true.

This one or this one is true, and it's gonna come in here,

it's gonna throw the new exception, and then it's gonna go right into here.

Now it's not gonna return and set this to false.

Even though it already is false.

It's not gonna return here.

It's gonna go pop right into here, and then we're gonna come through.

So let's give this a run.

All right, so let's figure out what we did.

13 errors, that can feel super overwhelming.

Let's see if we can figure out what happened.

So see all of these errors is just because of this one here, unclosed string literal.

So if we go to game.java, line 15.

I forgot a quote, why didn't you say something?

All right, let's try that again.

You probably do, you're probably sitting there yelling at the screen.

Why did you put a quarter?

Okay, so here we go.

So let's guess t.

Then I'm gonna guess t again.

And bam, it says t has already been guessed, did it?

What happens if we guess a capital T?

I'm glad we tested that.

Let's go ahead.

Let's flip it over to our board.

It took it as a different guess, didn't it?

Okay, so this is done, right?

Let's move this one over, and

unfortunately we're gonna do it one step forward, and we're gonna add another one.

So it's your let's add here, let's add a new error or

a BUG as we call them in programming.

Check the teacher's notes to find out the strange reasoning behind that

name for BUG.

But I'm gonna say BUG Uppercase and

lowercase values are treated differently.

And Trello has a nice little feature here when you come in to edit these.

Let's go ahead and set the label, let's make it red so it kinda sticks out,

it's a little louder.

So there we'll see that it's red.

I'm totally glad we checked, that could have been a big problem if people were

guessing uppercase letters, we would have been treating them completely separately.

Let's fix that right after this quick break.