We are finally to the point of writing our objects,

arguably most important method ever, dispense.

Like I was saying earlier, if we wanted to go overboard,

we could actually make one of these Pez objects.

Nothing's stopping us, right?

You could totally imagine it.

Our new Pez class would define some state, like flavor.

Maybe it could even store the time that it was inserted into the dispenser.

We could determine if it was stale.

When we call the dispense method we're about to write,

we could actually return one of these Pez objects.

Or that's going a little overboard, let's not do that just yet.

Now, I was being a little silly there.

But this is actually a pretty hard thing that you're going to grapple with.

How do you know when to stop building objects,

because like we talked about before, everything can be modeled as an object.

I struggle with this all the time.

A common acronym that you'll probably start hearing a lot is YAGNI.

You ain't gonna need it.

In fact, I keep a sticky on my laptop and

it helps me to remember not to overengineer before you actually need it.

Now there's another one that's pretty common sense, but boy,

do we forget it the more we start programming.

And that's this, KISS.

Keep it simple, smarty pants or something more rude than that.

So, with that said, let's keep it simple and assume that there is only one flavor.

What we'll do is, as long as there is a Pez to be dispensed, we will return true.

Of course, if it is in fact empty, we'll return false.

Sound good?

Let's do this.

Okay, so I have JShell open again and

I wanna show off a couple of cool tricks that we can do with integers.

Okay, so first off we know that we can create one, right?

So we're gonna say, int example = 1.

And if we wanted to just add one to it, we could use the variable itself.

So we can say something like, example = example + 1, right?

So that's gonna return 2.

So, we've set, now example is 2, right?

So, since that's so common, there is a special shorthand for it, and

it looks like this.

So you say example += 1 and basically it's this.

It does exactly this, it's just shorthand for it.

Cool, so that, return 3 and also updated example to be 3.

Okay, finally, because we end up adding one a lot,

there's an even shorter form and it's called incrementing.

And it looks like this.

So we say example++.

Now this one's a little bit dangerous.

It actually returns first and then changes the value.

Because this is what is known as post incrementing.

So if we do this, it's gonna go ahead and it's stored 3 in 5.

Now remember, example was 3.

But if I look at example now, it's 4.

So it actually did example plus one.

But it returned, the expression itself returned what the value used to be,

much like that swap head that we were looking at earlier.

But you can actually do the other side too, you can do pre increment.

So you can say example, ++example.

And that returns 5 and example is 5.

And that does the reverse, right?

It increments and then it returns the value.

Now the dangerous thing about this is that you can use these in a very

complex statement.

Now if you can't do the incrementing on a line by itself,

I highly suggest you don't use these at all.

In other words, I highly recommend that you don't use the value returned from

either the pre or post increment.

As you can probably guess by now, the same works with subtracting.

So I'm gonna clear here and we have, example's 5 so

we say example = example- 1.

We'll see that that example is 4 now, and

you can also do example -=1 and example's now 3.

And then, finally, as the other one is called incrementing, with the pluses,

this is called decrementing.

So we can say example-- and we did it on the other side, so

it's post but now example's actually 2.

Well, decrementing sounds like exactly what we need to do

when we want to dispense.

Again, so the dispense method that we're gonna write should work like this.

Every time that we dispense, we should decrement the Pez count,

as long as there's some left.

And we should let the caller know that we dispensed something, cool.

So, in PezDispenser, let's move this down here.

Let's go ahead and we'll make a new method.

It's going to return a true or false, right?

And it will have it be called dispense, and it won't take anything.

So, we'll store the default value here, we'll say boolean

wasDispensed, and we'll set the default value to false.

Okay, so we know that we can say if it's not empty, right?

So, let's look at this code block.

So if it's not empty we want to decrement the Pez count.

So we do that as such, we say pezCount--, so

that whatever is in there moves down one.

And we're gonna say wasDispensed, we're gonna set that equal to true,

because it was actually.

And then finally, we're going to return what was dispensed.

So it will start out as false, if there's anything in there it will go through.

If it's not it will never come in here and it will just say false and

the number won't go down.

Makes sense?

Okay, so let's flip over to our Example.java.

And I'm going to drop out of the JShell here if we do Ctrl+B.

And I will say clear, all right.

So in Example.java here, let's just go ahead and

empty the whole thing in one sitting.

We're probably all guilty of, I know I am.

So, this should be fairly easy.

All we need to do is just call the dispense method 12 times, right?

Well, that worked, but this sounds like a job for a loop.

We want to keep dispensing as long as we get something back.

So, while there's something dispensed, eat it.

Sound good?

Sounds like a while loop right?

So, just a quick reminder, so we'll say while dispenser.dispense().

Well that's happening, let's just write out chomp I guess, right?

And then finally, if it is actually empty,

which it should be, cuz we're gonna eat them all.

We'll say system.out.println(Ate all the PEZ).

Something's not lining up, look, I forgot a quote here.

There we go.

All right, so this is gonna return true or false.

And as long as it's returning true, it's gonna keep on chomping.

Sound good, let's take a look.

Clear && javac Example.java && java Example.

Here we go, chomp, chomp, chomp, chomp, chomp.

We ate all the Pez, cool.

So we should have 12 there, chomp, chomp, chomp, chomp, chomp, chomp, chomp,

chomp, chomp.

Ate all the Pez, awesome.

Good job, we can now load and dispense our Pez.

We are getting close to completing this model.

Now that we're removing Pez, we should probably get more specific around

the handling of what it means to fill.

In the real world, if we try to load a dispenser that

already has some Pez in there, we'd add Pez until it was is in fact full.

We wouldn't just add the maximum amount available, because that could be

potentially overfilling and wasting the remainder, we don't wanna waste.

Let's practice incrementing and decrementing.