Okay.

Let's talk this through a bit.

You probably noticed that none of the stories told us about how our app

should be developed or even on what platform for that matter.

Since so far we've only gone over how to make console based applications

that seems like the obvious platform decision.

However if we do this right.

We should be able to reuse the game code that we write.

Since no matter how we end up playing the game that logic will stay the same.

We'll need to make sure that we separate the prompting and

displaying portion of the code from the game state and behavior.

This approach is called the separation of concerns and we'll touch on it here

lightly, and it will make a lot of sense after we get the code up and running.

But, the idea is this, we're building a console based application and

there is certain code that is needed for that to work.

But the game logic itself like the rules and

how you win, it pretty much stays the same.

By doing the separation, we could in fact end up using that game logic

code in like a desktop app, a mobile app, or even a web application.

So with that in mind let's build our structure out.

Let's build our game and prompter blueprints.

That separation should be enough to get us started.

Okay. So I've created a new workspace for

this part of the course, it has our starter file Hangman.java in it.

So first thing we should do is let's build our prompter class,

it should be pretty straightforward.

So I'm gonna make a new file, I'm gonna call it prompter.java.

Okay, so we wanna have a class.

And it needs to be named the same as the file that it's in, right.

So we're need to call it Prompter.

And let's open up the code block there.

Remember that's enough.

So we'll use this prompter object to do all of the IO or input output.

So we also need to separate out the game logic in it's own file here.

So we'll do new file, game.java.

Okay, and following the similar logic, we'll make a new class called Game and

I'm gonna open it up, and I'm gonna close it right away.

Give us some space and now, one thing that we know for

certain is that this class will need to know the answer to the puzzle, right?

So, let's say it's gonna be a string and answer.

Now, it should be private because that's how we always start things out, right.

We want to be private.

Okay, since a game is not really any good without an answer,

let's force the creation of a game to provide an answer.

We should use a constructor to do that.

So let's make a new public, and

a constructor Again has the same name as the class, so public game.

And we want to have it pass in an answer.

So we'll say string answer.

And then what we'll do is we'll take what was passed in and

set our private answer variable.

And to avoid naming collisions we'll say this.answer = answer.

That way, we know for sure that we're talking about

the instances field versus the argument that was passed in.

Great, that should be enough to define at the separation of concern.

So I'm going to save this, make sure that they're both saved.

I gonna come over to Hangman.

And let's make a brand new instance of our game.

So we'll say the type is game.

The instance of variable name is going to be Game and

we're going to say when you want a new Game.

That's gonna to call the constructor that we have there.

We're gonna pass in the answer.

Let's pass in tree house.

So let's do that.

I'm just gonna go ahead and compile and

make sure that we got all of our syntax correct.

And I just need to press to get in there to hangman.job and what that will do

is because game is in the same folder, it will try to compile all of this.

Well it'll at least compile Game.

Right. So I didn't compile Prompter because we

didn't access prompter yet.

But it did compile game.

So we know that's working.

So there's no errors.

And again, since this game class is in the same folder or package, Hangman

just found the proper class without us needing to specify where to find it.

Our separation of concerns looks great.

We have the prompter class which we used to deal with the IO and

the game class which will maintain the logic.

It's completely separated.

We also have the main executable file Hangman.Java where we'll use

instances of the prompter and the game classes.

Awesome.

All right.

Now that we have our main objects defined let's get to completing those stories.