[MUSIC]

>> So when we delivered our minimum viable project, or MVP, for the karaoke project,

there was another story that didn't quite make the cut and

it got left in the backlog.

It was this.

As a KJ I should know which singer requested the song so

that I can call them up to the stage.

Well as it turns out, after some usage most KJs are dying for that feature.

What happens is this.

They keep calling the song and no one comes up because they either forgot or

they are not paying attention.

So let's see if we can add this feature request to our app real quick.

>> A song request is definitely a model right?

So let's navigate over there.

And, in the model package we'll right click, and say New, Java Class.

And let's call it SongRequest.

Cool.

This is some default setting.

I'm gonna get rid of it.

Okay. So, let's see.

We know we want a couple of things.

Right? We wanna have a private

String lets call it mSingerName.

We want a singer and let's go ahead and pop the song in there so private

song and mSong.

Now remember, it was in the same package as a song so we didn't need to import it.

So I want to explore something now called code generation.

So we wanna have a constructor, right?

The good new is is that it can create one for us.

Because remember, what we want it to do is we want it to pass in the singer name and

the song when you get created.

Let's go ahead and we'll go up to Code.

Then we'll choose generate.

Yeah, we're gonna generate a constructor.

We want it to do both of those, right?

We want it to do both those things.

Okay.

Whoops.

Okay, so almost.

The problem is that the parameters here are following our naming structure,

where we put the member variables in at the front, right.

Remember, that's just a coding style that we're doing and

each project that you work on might adhere to different styles.

Well the cool thing is that your editor knows that,

we just need to tell it our style.

So I am going to go ahead and I am going to Cmd+Z this, get rid of that and

let's go under File, Other Settings, Default Settings.

And if we go under Editor, Code Style, Java and Code Generation.

Here's the naming stuff.

Whenever we have a field, we're gonna prefix it with an M.

Okay, that's really all you have to do.

Say Apply.

Let's go take a look and see if that worked.

So now if we come over here, the generating code thing,

I don't know if you saw it, it was Cmd+N.

So I'm gonna generate a constructor and we're gonna use both of those.

Blam, there it is.

So, setting that up.

Song got moved down there.

Let's move him back up to where he was.

There we go.

Okay.

So now the boring part of adding getters and setters.

Did you see that in the list?

We can do that too.

We don't need to do that anymore.

Let's choose getter and setter and let's make them for both.

You'll note here that there's templates.

We're gonna leave them.

That's fine.

Look at that.

We didn't have to write all that code.

What else is in that generate thing?

Let's see.

To string, that's something handy.

So we will generate to string for both of those, yeah?

We're going to both of those.

Okay well that's one way to do it.

Well look, it remembered to do the override for us, which we learned.

The override annotation.

And if we wanted to change this to make our own template, we could, right?

So let's go ahead and I'm gonna undo that, and we will again, GenerateToString.

Up here there's these templates and we had talked about that a little bit.

So there's different options that you could do.

You can also make a new one, if you wanted to.

If you want to come here you can add a new template.

Okay, and if you really feel like nerding out that's something that you can do.

To make it read however you want to,

to be the default it will automatically generate the same looking to string.

The cool thing is when you save this it will be saved into the project file so

everybody else can use the same to string format.

I think we're fine with the final string concatenation.

Or lets.

Yeah, I think that's fine.

Okay.

Great.

Okay, so one thing that we didn't talk about before is equals.

And you can actually override the equals method and

this pretty much should be done on every class that we create that we plan to use,

especially ones that we use in the collections.

Now one reason that I didn't show you how to do this in the last course

is because it's much easier to have the IDE do it for you.

Ready let's do it and then we'll chat about it.

Okay? So, I'm gonna do,

again, Cmd+N and I'm gonna generate the equals and hashCode.

And let's just use the IntelliJ Default.

And there's a couple of options here.

I don't think we should use getters.

We should use the private methods and we will go over this in the future.

Yeah, so we want both of these and we want both of these in the hash code.

And the non null fields.

Let's not create one of these without nulls.

So, those are non nulls.

Okay, so remember that using double equals on objects just means

that they point to the same object in memory.

So what we really want to write here is we want to determine what equality means.

In this case, if the same person asks for

the same song, I mean that's pretty much equal, right?

It's sameish.

So things like hash maps and hash sets use a thing called the hash code.

We talked about this a little bit.

And under the covers, it stores things sensibly.

So it returns a uniquieish integer, that follows the same logic that equals.

So therefore, if you overwrite equals or hash code, you should override them both.

So lets both of those on the page.

So basically, this generated code just checks to see

if things are equal in memory.

Right, if they are the exact same object, than of course they're equal.

And then otherwise it just goes ahead and does the casting that we had done before,

and then it upcalls equals.

And oh, look here.

It's upcalling equals on song.

So, you know what we should probably do,

we should probably go write the equals for song.

So let's go over there to song.

So I wanna show you another option.

So we could do Cmd+O.

And this is basically doing searchable, but this is only for classes.

So if you have a whole bunch of classes, this is kind of handy.

Cmd+O is right in your module as well.

So in the song, let's just go ahead and let's generate equals and hashCode.

And we'll do the same thing, intelliJ default.

All those fields are valid right?

It's gonna be equal.

Yeah, all of those are true in the hash code and anybody could create one of these

songs and it's possible that they could put a null value in there, right?

The absence of that, so I am going to go ahead and leave those as null.

Okay, so it's generated those for us as well.

So the hashCode always looks a little bit strange.

One thing that might look a little bit weird to you and

is a little bit new is this thing called a ternary operator.

So the way that this works is if this is true then this happens.

It returns whatever the result is, if this is true.

Otherwise, it returns whatever this is.

Okay, so, pretty cute, right?

I mean, sometimes it's the most clear way to express things,

but often, it proves less readable.

You're bound to run into them, so I'm glad that you got to see them, but

I just wanted to let you know about ternary operators.

I'll put a link in the teacher's notes.

Cool.

So now we have our generated code over here.

I think we're ready to use it.

>> I know, I know I owe you like five more dunk tank balls for

making you type all that stuff before.

But how much do you appreciate it now?

Right?

There's a couple more code generation tricks that we'll encounter in the next

couple of videos.

Remember, everything is customizable, so you can make generated code adhere to

whatever your team determines to be the best practice.

So, let's get this feature implemented.

We're gonna need to do a little refactoring to get there, but

the ID is gonna help us.