English - Inheriting Behavior

920 0:01 - 0:03

Let's go back to the JustJava app for
just a moment.

3410 0:03 - 0:07

Let's look at the MainActivity
class displayMessage method.

7260 0:07 - 0:10

Things are starting to make
a little more sense in here.

9950 0:10 - 0:14

We already recognize that we're creating
a variable called orderSummaryTextView.

14350 0:14 - 0:17

The data type of this
variable was TextView.

17790 0:18 - 0:20

We didn't understand this part yet
though.

20740 0:21 - 0:23

On the next line, we call a method
on this text view object.

24650 0:25 - 0:28

We use the same variable
name as declared up here.

28070 0:28 - 0:32

So we call orderSummaryTextView.setText.

31830 0:32 - 0:34

Then we pass a string as
an input to the method.

35300 0:35 - 0:39

This string message originally
came as an input parameter

38790 0:39 - 0:40

to the display message method.

41720 0:42 - 0:45

Now let's dig in to this part of
the code, which we don't understand yet.

45250 0:45 - 0:48

It looks like findViewById
is a method call, though.

48210 0:48 - 0:54

Because its preceding these parenthesis
with what looks like an input argument.

53530 0:54 - 0:57

But, what's weird is that this method
isn't defined anywhere in this class.

57458 0:57 - 1:02

If I double-click on this name and
then hit command F, or

62355 1:02 - 1:08

control-F if you're on Windows, then
we can try to do a search in this file.

67560 1:08 - 1:11

I only see two occurrences
of findViewById, and

70780 1:11 - 1:13

they're used in similar ways.

72790 1:13 - 1:15

But I don't see any method
that's called findViewById.

76190 1:16 - 1:20

Speaking of which,
earlier in the main activity class,

79640 1:20 - 1:23

we see a call to setContentView,
but if you search for

83450 1:23 - 1:26

this in the file, it's also not
defined in the main activity.

87820 1:28 - 1:30

So, where are these methods defined?

90620 1:31 - 1:34

Well, MainActivity is
actually a pretty short file.

93610 1:34 - 1:35

It's only about 90 lines long,

95150 1:35 - 1:39

but there's actually more to
this class than meets the eye.

98790 1:39 - 1:42

The code says,
extends AppCompatActivity.

102200 1:42 - 1:46

This means that the main
activity is an extension

105710 1:46 - 1:49

of the functionality in
the AppCompatActivity class.

109290 1:49 - 1:53

On your computer if you see action
bar activity here, that's okay,

112790 1:53 - 1:55

that's just an older version of this.

115450 1:55 - 1:59

The latest version that you should
be using is AppCompatActivity.

118770 1:59 - 2:02

And AppCompatActivity gives us
backward compatibility support

122420 2:02 - 2:04

on older Android devices.

124460 2:04 - 2:08

The AppCompatActivity is part
of the Android support library.

127980 2:08 - 2:12

It allows us to use the latest
UI features on Android,

131740 2:12 - 2:15

while still working on
older Android devices.

135420 2:15 - 2:18

By extending
the AppCompatActivity class,

137940 2:18 - 2:21

we're getting all the functionality,
all the state and

140620 2:21 - 2:24

the methods from here within
the MainActivity for free.

144490 2:24 - 2:27

We don't have to copy and
paste any code from here.

146980 2:27 - 2:29

We can just simply extend that class.

150090 2:30 - 2:31

If you're interested,

151020 2:31 - 2:36

you can find out more information on
AppCompatActivity by googling for it.

155880 2:36 - 2:40

Here's the reference doc for
the AppCompatActivity class.

159700 2:40 - 2:42

Since I have the Chrome
extension installed,

161920 2:42 - 2:43

I can view the source as well.

163120 2:43 - 2:48

And this is the code for where
the AppCompatActivity class is defined.

167890 2:48 - 2:50

You can see that there's a lot
of functionality here, but

170360 2:50 - 2:55

the key message is that you don't have
to understand how it's implemented.

174510 2:55 - 2:58

All you need to know is that when
you extend AppCompatActivity,

178350 2:58 - 3:01

you get all of this functionality for
free.

181010 3:01 - 3:04

At a high level you can
visualize it like this.

183580 3:04 - 3:06

This is a class definition for
MainActivity.

185900 3:06 - 3:08

And say you have some
methods defined here.

188000 3:08 - 3:12

When you extend AppCompatActivity
then we can access the state and

192350 3:12 - 3:14

then the methods from AppCompatActivity.

194200 3:14 - 3:18

Now, they're not physically added
to the main activity class, but

197870 3:18 - 3:19

you can imagine that they're there,

199280 3:19 - 3:23

because you can still reference
the state and the methods as well.

202930 3:23 - 3:27

And that's how our code can refer
to things like setContentView or

206540 3:27 - 3:28

findViewById.

207840 3:28 - 3:32

Because we inherited those methods, we
didn't define them in the MainActivity.

212240 3:32 - 3:35

The MainActivity is shown as
a screen on the device, but

215110 3:35 - 3:40

we didn't write the code for that in the
MainActivity, we inherited that as well.

219520 3:40 - 3:43

We don't have the state and the methods
from AppCompatActivity directly

222750 3:43 - 3:47

in the class, but now we know that
they're there and we can refer to them.

226840 3:47 - 3:50

Speaking of inheriting things,
there's good and bad parts about that.

230260 3:50 - 3:53

Sometimes we'll want to
inherit behavior but

232540 3:53 - 3:55

other times we might want
to modify it slightly.

235980 3:56 - 4:00

If you want to change some of
the behavior from this inherited class,

239900 4:00 - 4:02

you can override certain methods.

242230 4:02 - 4:07

You can add this @override text on top
of a method so that the computer knows

247360 4:07 - 4:12

that you don't want the version of
the method from the AppCompatActivity.

252100 4:12 - 4:16

But instead, you want this
version that you've defined here.

255830 4:16 - 4:19

This is a tricky topic, and
it requires a lot of practice.

258620 4:19 - 4:22

But we have seen one example
of overriding a method

261660 4:22 - 4:24

from the AppCompatActivity class.

263640 4:24 - 4:26

And that method is the on create method.

266380 4:26 - 4:31

By overriding the on create method in
the MainActivity, we're specifying our

271170 4:31 - 4:35

own implementation for what should
happen when that method is called.

275380 4:35 - 4:37

Don't worry if you don't
understand this right away.

277180 4:37 - 4:41

I'm just giving you a brief overview
of a bunch of object-oriented

280534 4:41 - 4:42

programming concepts.

282350 4:42 - 4:46

It's absolutely expected that you
would still have lingering questions.

286160 4:46 - 4:49

And still need to read up more
these topics in order to fully

289370 4:49 - 4:51

understands them.

290860 4:51 - 4:54

Another way to visualize the
relationship between the MainActivity

293771 4:54 - 4:58

and the AppCompatActivity classes is
to draw a Class Hierarchy Diagram.

298220 4:58 - 5:01

This is different from
a View Hierarchy Diagram, because

300930 5:01 - 5:05

the View Hierarchy Diagram shows a tree
of views that are shown on a screen.

305340 5:05 - 5:08

The Class Hierarchy Diagram
shows the relationship

307810 5:08 - 5:10

between different Java classes.

309990 5:10 - 5:13

We have AppCompatActivity as superclass.

312860 5:13 - 5:16

Since MainActivity extends
from AppCompatActivity,

315868 5:16 - 5:19

then this is known as the subclass.

318560 5:19 - 5:22

So whenever you see this class
definition whatever you extend is known

322200 5:22 - 5:24

as the superclass.

323970 5:24 - 5:26

This would be the subclass.

325770 5:26 - 5:29

So if you created another activity
called detail activity and

329070 5:29 - 5:32

you extended AppCompatActivity,
this would be the subclass, and

332340 5:32 - 5:33

this would be the superclass.

334720 5:35 - 5:38

Here's another example of
Java class inheritance.

337840 5:38 - 5:41

If you think about it,
the text view, image view, and

340520 5:41 - 5:44

button views all have some
common aspects to them.

344460 5:44 - 5:48

All of these views have a width and
a height on the screen.

348070 5:48 - 5:51

We haven't learned this yet, but
they also have a visibility state.

351330 5:51 - 5:54

So they can all be made invisible or
visible.

354400 5:54 - 5:59

There are a couple of other properties
as well, that are common among them.

358650 5:59 - 6:02

Instead of writing out code for these
properties within the text view class,

362370 6:02 - 6:06

and then copying it over to image view,
and then button class.

365590 6:06 - 6:08

We can do something a little smarter.

367610 6:08 - 6:10

We can create a view class.

369980 6:10 - 6:14

We can extract the common properties
among all of these views and then put

374110 6:14 - 6:20

them inside this view class that way
the code only has to be written once.

379730 6:20 - 6:23

But then how do we make the connection
between the text view class and

382610 6:23 - 6:24

the view class?

384000 6:24 - 6:27

If you're thinking inheritance,
you're correct.

386548 6:27 - 6:30

In the TextView java file we're
going to define the text view class.

390080 6:30 - 6:33

That way we'll inherit all this data and
the methods from the view class.

394270 6:34 - 6:38

Then we won't have to have as
much code in the TextView class

397520 6:38 - 6:42

because part of the functionality is
already written in the view class.

401860 6:42 - 6:44

The same would apply for
the ImageView and

403730 6:44 - 6:47

Button classes,
we don't have to write as much code.

406800 6:47 - 6:50

In these files, we only have to
write about what's different

409690 6:50 - 6:53

about the ImageView
compared to the View class.

413090 6:53 - 6:58

I think of this as specifying a delta,
so the ImageView class only has to

417720 6:58 - 7:02

specify what's different about the
ImageView compared to the View class.

423840 7:04 - 7:07

If we don't want to inherit certain
behavior from the View class,

426960 7:07 - 7:12

we can just specify the updated
behavior within the ImageView class, or

431760 7:12 - 7:13

any of these classes.

434070 7:14 - 7:17

To remind you of the terminology,
in this case,

436680 7:17 - 7:20

TextView would be the subclass,
and View would be the superclass.

441430 7:21 - 7:23

If we go back to the documentation for

443280 7:23 - 7:27

the TextView class,
we actually understand this part now.

447310 7:27 - 7:30

It says TextView extends view.

450000 7:30 - 7:33

Now we know that it means that
we're inheriting the state and

453330 7:33 - 7:35

the methods from the ViewClass.

455280 7:35 - 7:38

And down here is a class
hierarchy diagram.

458330 7:38 - 7:42

It shows that the TextView class
is inheriting from the ViewClass.

463730 7:44 - 7:47

And in turn, the View class
inherits from the Object class.

467650 7:48 - 7:50

If you explore around,
you can find other classes,

470060 7:50 - 7:55

like the EditText class, which actually
extends from the TextView class.

474780 7:55 - 7:58

So it takes the behavior
form the TextView class and

477570 7:58 - 8:00

then adds a little more
specific functionality to it.

481290 8:01 - 8:04

So EditText extends from TextView.

483590 8:04 - 8:07

And TextView extends from View,
and View extends from Object.

486720 8:07 - 8:10

And this is the class hierarchy diagram.

491370 8:11 - 8:14

There's a lot going on, and
you can look at it for hours.

493950 8:14 - 8:17

But let me just show you one thing
on the TextView documentation page.

497010 8:17 - 8:21

I want to show you the method for
SetVisibility.

500820 8:21 - 8:24

Here's the Java method for
SetVisibility within the TextView class.

504350 8:24 - 8:27

This changes whether
the view is visible or not.

508000 8:28 - 8:33

If I click on this method,
it actually brings me to the View class.

513240 8:33 - 8:36

And then it describes
what this method does.

516010 8:36 - 8:40

So you can see that a TextView
object has a set visibility method.

519860 8:40 - 8:44

But it was actually inherited
from the View class.

523659 8:44 - 8:47

So we got this functionality for
free, from the View class.

527470 8:47 - 8:51

Okay, we just covered
a ton of new concepts.

530930 8:51 - 8:56

Normally this would be spread out over
a semester of a computer science course.

536040 8:56 - 8:58

We're going to do a little
bit of practice now and

538260 8:58 - 9:01

hopefully it will start to
connect the dots for you.

541170 9:01 - 9:03

But know that it will
take a lot more time and

543010 9:03 - 9:07

practice until you fully
grasp these concepts.

546610 9:07 - 9:10

Okay, first exercise, I want you
to create another new Android app,

549700 9:10 - 9:12

because we don't want to
mess up the just Java app.

553070 9:13 - 9:15

Once you create the project,
then run the app.

555790 9:16 - 9:19

Once you create your app,
you're going to see a MainActivity file.

558630 9:19 - 9:23

That MainActivity file will
extend from AppCompatActivity.

562530 9:23 - 9:26

In your version of Android Studio,
if the MainActivity extends from

566060 9:26 - 9:29

ActionBarActivity instead,
that's okay too.

568760 9:29 - 9:32

That's just an older version
of AppCompatActivity.

572200 9:32 - 9:36

By removing this method override,
we're going to fall back to

575650 9:36 - 9:40

the way that onCreate method appeared
in the AppCompatActivity class.

580280 9:40 - 9:45

The presence of this method says we want
different behavior in the MainActivity

584540 9:45 - 9:46

for the onCreate.

586230 9:46 - 9:50

So removing it brings us back
to the original behavior in

589540 9:50 - 9:52

the AppCompatActivity class.

592040 9:52 - 9:53

When you run the app,

593380 9:53 - 9:57

what do you notice is different
compared to when you first ran the app?

597250 9:57 - 9:59

Write your answer in this text box.

English subtitles

← Inheriting Behavior

English subtitles

← Inheriting Behavior

Embed video

Share