Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Preview
Start a free Courses trial
to watch this video
We will set up the initial state of our Game logic here. We will perform the first half of the user story: "As a guesser, I should be able to submit a guess, so that I can play the game."
This video doesn't have any notes.
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
Okay, so let's take a stab at
the first story which is this.
0:00
As a guesser, I should be able to submit
a guess, so that I can play the game.
0:03
Sometimes these beginning
stories are a little silly.
0:09
Now obviously a guesser is gonna guess,
but it needs to be stated so
0:11
that development will happen.
0:15
Okay, so let's think about this a bit.
0:16
Our game object currently
holds what the answer is.
0:19
And now we want to start
having it store what
0:23
guesses have been made
towards that answer.
0:26
So this story is requiring that the game
allows the submission of a guess.
0:28
Sounds like we might need to create
a method that accepts a single letter.
0:34
How about applyGuess.
0:37
So with that guess, we should be
able to tell if that guess is a hit,
0:39
like it's in the answer, or
if it's a miss if it isn't.
0:44
By storing this information
in the game instance,
0:48
others could then apply
guesses from whatever means.
0:50
Let's get it working real quick,
and then it should start clicking.
0:55
Here we go.
Okay,
0:57
so let's move our story into
the In Progress column.
0:59
So first things first,
I want to pop into JShell and
1:04
introduce you to a new primitive data type
that you might have met before, char.
1:07
So the char data type is used to
represent a single character, in fact,
1:12
char is short for a character.
1:17
Use a char as the data type, letter =, and
1:19
here I want you to note that
we're using single quotes.
1:23
Now other languages can use the double
quotes and single quote interchangeably.
1:27
But in Java double is for string literals
and single is for char literals.
1:31
So I've used this analogy
about strings before.
1:39
But I want you to imagine
a string as a group of characters
1:43
strung together like a banner at a party.
1:46
So there are a few ways to check and
1:49
see if a string has a specific
character in its string of characters.
1:51
Here's one that we'll use, so
let's make an example, so let's say,
1:56
string example = "Hello", and
1:59
of course, now pay more attention
though there's double quotes there.
2:04
Okay, and
there are a lots of ways to do this,
2:08
the one that we're going
to use is called indexOf.
2:11
So, we're gonna say, example.indexOf, and
I'm going to look for the character e.
2:14
It tells us that it is at 1.
2:23
Note how it returned one but it really
seems like it should be two, right?
2:25
One, two, I would have assumed that.
2:30
Now, this is because when indexing
in Java and many other languages,
2:32
counting always starts at zero.
2:36
Now, this seems a little bit weird.
2:38
And I will try to cover this quite a bit
cuz I know it's something that people
2:40
struggle with.
2:43
A way that I remember this is,
by thinking of babies ages.
2:44
When babies are born we often
talk about their first year.
2:48
Yet, when we're asked how old they are,
we always answer in months.
2:51
And that's because zero
years old sounds weird.
2:55
How old's your baby?
2:57
Zero years old.
2:58
We don't say that.
2:59
So after their first year we
start saying one year old and
3:00
then we say two year old but
zero just sounds weird, right?
3:03
Well this is true here too,
we often say that the first element, but
3:06
in reality it's really the zeroth index.
3:10
So if we look at example.indexOf and
we push in an H.
3:13
Character is, I'm gonna do Ctrl + L,
so that we're clean.
3:21
So example.indexOf('H') in Hello,
will be the zeroith.
3:25
So what happens when it's not found?
3:33
So if you say example.indexOf, and
3:34
z is definitely not in there, so
what happens when z is not there?
3:37
So as long as the index of the char is
greater or equal to 0, it's in there.
3:45
So you can kind of do that
expression like this.
3:50
So we can say, example.indexOf('o'),
which is in there, right?
3:52
If that's greater or equal to 0,
we know it'll return a true, right?
3:59
And the same is true if it's missing.
4:04
So example indexOf, and we do y,
4:07
we say greater than or equal to 0.
4:10
It's going to tell us that that's false.
4:15
So the other way to check, and
this is kind of more succinct actually,
4:17
if you say, example.indexOf('e'),
is not equal to -1, right?
4:21
Cuz -1 is saying that it's not in there.
4:30
So this is like basically
saying if it's not found.
4:32
It's actually saying
if it's not not found.
4:33
One thing you might not of come across yet
is string concatenation.
4:37
So you can combine strings
using the plus sign,
4:41
kind of like add this word to this word.
4:45
Like so, so if I say,
4:47
example = example + "Wor".
4:51
What's gonna happen it's gonna append
example, just like we saw before.
4:57
You take the variable and
another variable and apply the plus to it.
5:01
And you can also concatenate chars.
5:05
So we'll say example = example + 'l',
the single character l.
5:08
Cool, so there we go.
5:17
And that shortcut that we learned
about adding integers also works.
5:18
So if I say, example += 'd'.
5:21
It's going to add d to example.
5:25
So now example has been changed.
5:28
Cool, so
5:31
armed with that info, let's use it to
solve our user story of applying guesses.
5:32
So we want to be able to accept a guess
and store if it was a hit or a miss.
5:38
So why don't we make that state.
5:43
Since strings can be concatenated and
5:46
checked, why don't we store that
info in strings themselves.
5:48
So let's go to the game logic and
5:52
in here, let's say private,
cuz we always start private, right?
5:55
We're gonna make a new string,
and will store hits.
5:58
And then misses,
that's two separate strings.
6:03
And inside of our game constructor,
we will initialize this.
6:07
So we'll say hits and misses.
6:12
Cool, so now those are initialized and
they're private.
6:19
I'm gonna scroll this down a little bit.
6:23
So now let's add a method that will allow
us to apply a guess towards the answer.
6:25
So let's do this, we know it's public.
6:31
We want people to be able to do a public,
and let's return whether or
6:34
not it was a hit.
6:37
So we'll use a Boolean return value,
right?
6:38
We'll say, you apply the guess
you know if it matched or not.
6:41
And this way consumers of the objects
will know if they got the guess right.
6:44
So we'll call applyGuess.
6:48
And let's see, we wanna take in a letter.
6:51
So let's make that a char letter, right?
6:55
A single letter is what we want.
6:57
So we're gonna start out and
we'll say boolean is it a hit,
6:59
and what we will do is we'll
see if it's in the answer.
7:03
Is answer indexOf(letter) not equal to -1.
7:06
So is the letter in the answer, okay?
7:15
We'll store that in this hit, so we will
say, if it is a hit, this is why camel
7:19
casing is important,
hits += letter, right?
7:24
So, we're gonna concatenate
the letter onto the hits.
7:30
So hits is an empty string originally.
7:32
Here we go.
7:34
This might be the first time that you've
encountered this type of branching,
7:35
it's possible to perform another block
of code when the expression isn't met.
7:39
So in this case, we want to say else here.
7:43
So else is used to describe what
to do if our expression here,
7:47
this is hit, is false, it's not met.
7:51
So, in our case, we are interested in
knowing if it wasn't a hit, right?
7:55
We're gonna say that goes
in the misses string, so.
8:00
Okay, and look, this is closing that block
and this is closing that block, cool.
8:06
And then finally, what we need to
do is we need to return isHit.
8:11
Now do you notice I did
something a little bad here.
8:17
Look, so
this is not the closing brace here.
8:20
We need to close the actual, you need that
method, we need this to close a class.
8:24
So I was missing a brace.
8:31
Very common as we start with more and
more of these braces.
8:33
Okay, so let's go ahead and
let's save this, and
8:36
let's jump in back to jshell here.
8:40
And we're gonna say /open Game.java.
8:42
And we will make a new game, so
we'll say Game game = new Game.
8:46
And we're gonna pass in treehouse.
8:51
Cool, and now,
we can use our applyGuess method.
8:54
So it should let us know
if it's in there or not.
8:58
So let's say game.applyGuess,
so t is in there, right?
9:01
So it's in the puzzle.
9:10
There it is right there
game is in treehouse.
9:11
So let's do it, this should return true.
9:13
Perfect, and
let's try to see what happens if we miss.
9:16
Should return false, right?
9:19
Perfect, the logic portion of
the story is looking great.
9:21
Let's get something using it.
9:24
Great job.
9:27
We have exposed our applyGuess
method in the Game class.
9:28
Now anyone using our game
object can add a guess and
9:31
the object can tell if it
exists in answer or not.
9:34
So let's go take some input from
the console using our prompt object.
9:37
But first let's work out those string and
char muscles.
9:41
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up