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
In this video, we'll review the solution to the first challenge and introduce our second challenge—adding behaviors to the MediaType base class.
Instructions
2nd Challenge
Move the
Loan()andReturn()methods and theLoaneeandOnLoanfields from the Album subclass to the MediaType base class.Add a
GetDisplayText()method to any media type subclass that currently doesn't define that method.-
To test your changes...
- Ensure that you're instantiating an instance of each of your media type subclasses in the Program.cs
Main()method. - Call the
Loan()andReturn()methods on each media type subclass instance. - Call the
GetDisplayText()method (on each media type subclass instance) after calling theLoan()andReturn()methods.
- Ensure that you're instantiating an instance of each of your media type subclasses in the Program.cs
Abstract Members
For more information about abstract classes and class members in C# see the Intermediate C# course in the Treehouse library.
Help
If you get stuck on any of the following topics or simply need a refresher, click on a topic in list below to view the associated video in the C# Objects course.
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
Welcome back, how did you do?
0:00
Don't worry if you weren't able
to complete the entire challenge.
0:02
After reviewing my solution, try again
to complete the parts you didn't finish.
0:05
Let's walk through my solution.
0:10
To start,
I added a MediaType.cs file to my
0:12
project in order to add a MediaType
base class to my program.
0:15
File > New File,
0:19
then MediaType.cs.
0:22
I used the same Treehouse.MediaLibrary
namespace that the other MediaType
0:27
classes use.
0:32
And I stubbed out the class.
0:38
Then I added a public field
named Title of type string.
0:45
I finished my base class by
adding the constructor, public,
0:53
then the name of the class, MediaType.
0:57
Followed by a set of parentheses and
a set of curly braces.
1:00
I added to my constructor a title
parameter of type string.
1:06
And initialized the title
field using that parameter.
1:12
Next I updated my existing MediaType
classes, Album, Book, and Movie,
1:18
to inherit from my new
MediaType base class.
1:23
First, the Album class.
1:26
Just the the right of class name,
add a space, a :, and another space.
1:31
Then the name of the base class,
MediaType.
1:37
Then I updated the Book class,
: MediaType,
1:40
and then the Movie class, : MediaType,
1:47
then to call the base class constructor
from each of the MediaType subclasses,
1:55
I used the base keyword.
2:00
Let's start with the Album subclass.
2:01
Just to the right of the subclass's
constructor parentheses,
2:07
add a : and a call to the base class
constructor using the base keyword.
2:12
Sometimes it can help make the code
a little bit more readable
2:18
by putting the call to the base
class constructor on its own line.
2:22
Be sure to pass in the title parameter
into the base class constructor call.
2:26
If you happen to have a MediaType subclass
that didn't define a Title field,
2:34
you'll need to add a title parameter
to your subclass constructor so
2:39
that you can pass it to
the base class constructor.
2:43
And then I repeated that for
the Book and Movie subclasses.
2:48
To save some typing, I'm gonna copy
this line of code to the clipboard.
2:52
I'll save this file,
then switch to the Book class.
2:56
I'll put my cursor right
at the beginning of line 9,
3:00
right on the opening curly brace for
the constructor method implementation, and
3:03
paste from the clipboard.
3:06
Save the files, and switch to the Movie
class, and do the same thing there.
3:08
And lastly,
I reviewed my MediaType subclasses and
3:14
removed all of the Title field
definitions from those classes.
3:17
Let's start with the Movie class.
3:21
We can remove this line of code.
3:24
And down here in the constructor,
we no longer need to set the Title field.
3:27
That's being handled in our base class.
3:31
Save the file, and switch to the Book
class, and do the same thing.
3:34
We can remove the Title field here and
the Title field initialization here.
3:38
Save the file, and
switch to the Album class.
3:45
Remove the Title field and the Title
field initialization, and save the file.
3:50
After I finished all those changes,
I compiled and ran the program.
3:57
View > Show Console.
4:02
Then mcs *.cs -out:Program.exe
4:08
to name our binary,
4:15
&& mono Program.exe.
4:18
And here's the expected
output in the console,
4:23
which is the same output that we were
receiving before we made these changes.
4:26
Well, at least we know that
we didn't break anything
4:31
by adding the MediaType
base class to our program.
4:34
The MediaType base class and
my Album, Book, and
4:37
Movie subclasses form what's
called a class hierarchy.
4:40
It can take a while to get
comfortable with creating and
4:44
using class hierarchies, so don't worry.
4:46
If any part of this is confusing or
still feels challenging, go back and
4:49
re-watch the videos from stage
three of the C# objects course.
4:54
And keep practicing, you'll get it.
4:58
Now that we've defined our MediaType base
class, let's add some behaviors to it.
5:01
In the previous practice session,
we added behaviors to the Album :
5:05
MediaType sub-type by added
methods to the Album class.
5:09
Ideally, those methods would be
defined in our MediaType base class,
5:13
which would allow each of our MediaType
subclasses to inherit those behaviors.
5:18
Let's review each of the methods to find
in the Album subclass to see if any of
5:23
them are candidates for
moving to the MediaType base class.
5:27
The GetDisplayText method,
as the name suggests,
5:38
is used to get the display text for
the MediaType item.
5:41
Notice that the method accesses
the Title and Artist fields.
5:44
The Title field, which used to
be defined in the Album class,
5:52
now lives in the MediaType base class.
5:56
This code continues to work fine,
5:59
as subclasses can access any non-private
field defined in the base class.
6:01
The Artist field, though,
is still defined in the Album class.
6:06
Unfortunately, this will prevent us
from moving the GetDisplayText method
6:10
to the base class.
6:15
Why is that?
6:16
Well, while it's possible for
6:17
subclasses to access non-private base
class fields, the opposite isn't true.
6:19
Base classes can't access
fields defined in subclasses.
6:25
So if were to move the GetDisplayText
method do the base class,
6:30
our code would no longer compile.
6:34
You might wonder why we wouldn't just
move the Artist field into the base class
6:37
like we did with the Title field.
6:41
While each of our MediaType
subclasses defined a Title field,
6:43
the Artist field is specific to
the Album media item subtype.
6:46
Moving the Artist field to the base class
would make it available to the Book and
6:51
Movie subtypes, which, from
an object-oriented design perspective,
6:55
doesn't feel like the right thing to do.
7:00
For now, let's leave the GetDisplayText
method defined in the Album class.
7:02
In a future course, you'll learn how
another feature of object-oriented
7:07
programming, abstract classes and methods,
can provide a solution to this problem.
7:11
See the teacher's notes for
more information.
7:16
In addition to the GetDisplayText method,
we also added the Loan and Return methods,
7:19
which are used to loan out and
return items from and to our MediaLibrary.
7:25
Notice that the Loan and
Return methods access the Loanee and
7:30
OnLoan fields here, here, and here.
7:34
Unlike the Artist field,
though, the Loanee and
7:40
OnLoan fields aren't specific to
the Album : MediaType subtype.
7:42
Ultimately, we want to be able to loan
out any item from our MediaLibrary,
7:47
regardless of its subtype.
7:51
Given that, we can safely move
the Loan and Return methods,
7:53
along with the Loanee and OnLoan fields,
to the MediaType base class.
7:58
For your second challenge, move the Loan
and Return methods and the Loanee and
8:03
OnLoan fields from the Album subclass
to the MediaType bass class.
8:08
And to help support testing,
add a GetDisplayText method
8:13
to any MediaType subclass that
doesn't currently define that method.
8:16
And lastly, to test your changes, ensure
that you're an instantiating an instance
8:21
of each of your MediaType subclasses
in the program.cs file's main method.
8:26
Call the Loan and Return methods on
each MediaType subclass instance.
8:32
And call the GetDisplayText method
on each MediaType subclass instance
8:37
after calling the Loan and Return methods.
8:43
And that's the second challenge.
8:46
See you in just a bit.
8:48
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