Heads up! To view this whole video, sign in with your Courses account or enroll in your free 7-day trial. Sign In Enroll
Well done!
You have completed Java Data Structures!
You have completed Java Data Structures!
Preview
Exercise some muscles learned in Java Objects around creating classes and learn about immutability.
Copy/Paste
"Spirit: Stallion of the Cimarron"
"Family"
2002, 5, 24
Resources
Definitions
Constructor - methods that are invoked to create objects from the class blueprint. A class can have many constructors, and every class has a default constructor that takes no parameters.
Deprecated - term used to mark a class or method that you should no longer use, since it has been superseded and may cease to exist in the future.
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, now that we've got our package
all set up, let's fill out that class.
0:01
So let's talk about what
that class should look like.
0:05
It should have a title,
which is just the name of the movie.
0:07
It would be nice to have the genre,
and let's also add the release date.
0:11
Let's make sure that we can set all those
properties when the object is created.
0:15
So we should use a constructor
and set some variables.
0:19
Now, I don't think we should provide a way
to have the object change after it's
0:23
been initialized.
0:26
When an object cannot be changed,
it's often referred to as immutable.
0:27
We want our users to be able
to get the data,
0:32
but aside from creation,
they should not be able to set the data.
0:34
Now, one thing we'll need to
do is import the local date class
0:38
from the java.time package,
just we did in the other import.
0:41
And don't worry, it's
not a find local dates in your area thing.
0:45
It makes working with dates and times
super easy.
0:49
Now, the release date variable type
should be of the type local date.
0:52
I'd to like to ask you
to try to build this out yourself.
0:56
So once again, the fields are title,
genre, and release date.
0:59
A link to the java.time.localdate
documentation is in the teacher's notes.
1:02
Are you ready?
1:08
Okay, so pause me
and give it a go in workspaces,
1:09
then come back and watch how I build it.
1:12
You got this.
1:14
Alright,
1:17
last chance to pause me
before I take off and code this.
1:17
Okay, first things first.
1:21
We're going to create some member
1:23
variables here that shouldn't be exposed
to anyone outside of this class.
1:24
Otherwise, they could be changed.
1:28
Now remember,
we want these to be immutable.
1:30
They should not change.
1:33
So let's declare them private.
1:34
So we'll say private,
and then the data type,
1:36
and then we're going to prefix it again
with m.
1:39
This m prefixing isn't exactly seen often
in newer Java code.
1:42
It's kind of a legacy thing.
1:46
But since we're wanting
1:48
to become familiar with the old
and the new, where it makes sense,
1:48
and since we're not using an IDE,
let's use it here.
1:52
So private string mTitle.
1:55
So the member variable of title
has been created now as part of the class.
1:58
And let's do one of those again for genre.
2:03
And finally, let's do one for release
date.
2:10
We need to import this first,
and we've seen how to do that before.
2:13
So let's come up here and
we'll say import java.time.LocalDate.
2:17
Let's make it of type localDate and name it
2:20
mReleaseDate.
2:29
Okay, so next
we need to declare the constructor.
2:32
We want the creator of a new movie
instance to pass
2:37
in all of the values needed, so let's pass
those to the constructor.
2:40
So again, because it's public, we want
anybody to be able to create one of these.
2:44
So we say public movie,
2:49
the same name as the class
is how the constructor works.
2:51
So public movie,
and we're going to pass in a title.
2:54
We wanted a genre.
2:59
And one of the local dates.
3:04
Great.
3:11
Now in the constructor, we're just going
to initialize each one of these variables.
3:12
And now, because we used this coding style
of prefixing variables with m,
3:16
the member variables are actually easier
to distinguish
3:21
from what was passed in here.
3:23
For example, mTitle.
3:25
I know that this is different
than this title that was passed in here.
3:27
Make sense?
3:30
So then we're going to do
mGenre equals genre,
3:31
and finally,
mReleaseDate equals releaseDate.
3:35
Okay, so now we've got a way
to populate our class with data, but
3:38
we haven't really exposed anything
to the users of our object.
3:42
We should set it up so they can get
the information out of the object.
3:46
Alright, so let's add some getters.
3:49
So we'll make a method
that returns a string,
3:52
and we'll do this for each
one of these member variables that we did.
3:54
It won't take any variables.
3:57
We'll say return mTitle.
3:59
Great.
4:03
Now, by creating
these and not creating the setter,
4:05
we've essentially made it impossible
to change the object.
4:08
And therefore, we've achieved our goal
of making it immutable.
4:11
So we're going to get the genre out,
4:15
and you'll be very glad to know
that in the future, these can be generated
4:17
for you using modern IDEs,
and we'll get to that soon.
4:20
All right, so this is going to return
a local date object.
4:24
All right, and this makes sense, right?
4:28
We don't want these movies to change
because there's
4:30
something that happened in the past
anyway.
4:32
They shouldn't be changed.
4:34
They should be locked in time.
4:35
Right, Georgie?
4:37
Right.
4:39
Okay, now
if we flip back here to example.java,
4:40
we need to update the way that the movie
is being instantiated
4:43
as there are now three required parameters.
So let's add theml
4:47
Let's use the first recommendation
I got. This one came from Laura.
4:50
It's in the teacher's notes below
so you can copy and paste these values too.
4:54
So the title
4:58
argument will be Spirit,
Stallion of the Cimarron.
4:59
Simarron? Kimarron?
5:03
I don't know.
I'll have to watch it and see.
5:05
Google said it's a family western, but
5:08
we'll just stick with one genre
and say family.
5:10
There we go.
5:13
And now we need the release date.
5:15
This one's a little different.
5:16
If in reality, we were making this app
where people could really submit movies,
5:18
and not just us adding them in ourselves
here, we would want to handle the parsing
5:23
of the string date that they provide
into a local date instance.
5:27
That would also come
with needing some error handling
5:31
in case they send something invalid.
5:34
But for now, we're making these ourselves.
5:36
So we'll be careful.
5:38
And we'll create our local date
objects here.
5:39
I should also mention that this
time.localdate was introduced in Java 8.
5:42
Prior to this, Java developers used
the java.util.date and calendar classes.
5:46
I know I'm showing off some legacy
way of doing things here,
5:53
but to be honest, the date class
has been replaced and deprecated
5:56
for long enough that I would hope
people have migrated by now.
6:00
Let's take a quick glance
at the java.util.date documentation.
6:03
You can see here
it's recommending the usage of calendar
6:08
and date format instead.
6:11
And if we scroll down, we'll see a bunch
of deprecated, deprecated, deprecated.
6:14
To be honest,
6:18
date and calendar are clunky
and unintuitive.
6:19
Local date was created for a reason.
6:23
I'll provide links to these
in the teacher's notes below
6:25
if you'd to learn more about them.
6:27
Okay, let's
6:33
check out the documentation
for the local date method named of.
6:34
Let's click on static methods here,
and here we see two of methods.
6:39
I like this one that just takes three integers.
6:46
Let's click on that.
6:48
Okay, so we see first up is the year.
6:53
It says the year to represent from min
year and max year.
6:55
What is that?
6:59
Let's scroll up a bit.
7:00
And here we go
You see min is negative 9999, etc,
7:01
and max is positive 99999.
7:05
Okay, so we're definitely good with our years.
7:10
So let's go back down
and the month is represented by 1
7:12
for January, 12 for December, cool.
7:15
1 through 12, not zero-based
like the old date methods.
7:18
And the day is 1 through 31.
7:22
Awesome.
7:24
Real quick, let's scroll back up.
7:25
They also have this parse method here.
7:28
Let's check that out.
7:30
Obtains an instance of local date
from a text string.
7:31
So this is like I was saying, if people were
submitting this, we'd want to utilize
7:35
this function in our class
and convert it behind the scenes for them.
7:39
But let's just stick
with this of method for now.
7:42
All right, let's import this local date.
7:46
Let's
7:53
Let's create this local date
first above to keep this readable.
7:54
Let's say local date.
7:57
And let's name it spirit date,
8:00
because of the title of the movie
is Spirit, nothing spooky here.
8:02
And let's go equals localDate.of
8:06
and pass in our release date,
which was May 24th, 2002.
8:09
So we'll say 2002, 5, 24.
8:14
Awesome.
8:21
Lastly, let's plug it into our new movie
here as the third argument.
8:22
Cool.
8:29
Let's run
this and make sure everything works out.
8:29
It compiles!
8:38
It still looks pretty ugly here,
but we'll take care of that later.
8:39
Very nice.
8:42
There we go.
8:44
Just riding a bike, right?
8:45
Once you learn, you never forget.
8:47
Though, if it's been
a long time, it's possible
8:49
you might need a little practice
before trying to pop wheelies.
8:51
How did you do?
8:54
If something isn't quite making sense
for you yet,
8:55
I promise there's a moment
where this stuff will just click.
8:57
So now that we have our class all ready,
we should do something about
9:01
being able to display it prettier than it
currently is being displayed.
9:04
And we could go create a display method,
but don't you think it would be better
9:08
if we could somehow fix it?
9:12
So that anytime someone tried to use
the string representation of our class,
9:14
just we just did, it
printed out the correctly legible output?
9:17
Well, the good news is, we can.
9:22
All objects have that superpower.
9:23
And since our movie class is an object,
we can change the way it works
9:26
for our class specifically.
9:29
Let's see how to do that
right after we exercise those bike
9:31
riding muscles one more time.
9:34
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