🤑 Join the Treehouse affiliate program and earn 25% commission!

Join our Live Career-Building Workshop: Launch Your Tech-Adjacent Career! ⭐ Register here!

🌟 Dreaming of a bright future? 🎓 Ask about the Treehouse Scholarship program! 🚀

Curious which AI tools Treehouse developers love? ⚙️ Check them out!

🫡 Treehouse for Military offers discounts to Veterans, service members and their families!

Preview

Start a free Courses trial
to watch this video

Sign up for Treehouse

Introduction to Reflection

11:40 with Chris Ramacciotti

We take one more sidestep during this course, this time to what's called reflection. Reflection is a programming technique that allows us to examine (and even modify) the structure of objects at run-time. During this video, we'll practice some basic reflection so that we can utilize these techniques to check for the presence of our @Doc annotation.

Teacher's Notes
Questions?
Video Transcript
Downloads
Workspaces

Using Reflection to Interact with Methods

During this video, we take a brief look at how we can use reflection to examine a class at runtime, getting certain pieces of information about its methods. To see more, check out the official documentation of the Method class.

Using Class<?>

You may have noticed that in the video, I declared a variable with Class<?> as follows:

Class<?> clazz = MathUtils.class;

Whenever you see a pair of angle brackets following a class name in Java, it refers to what's called a generic. Think of a generic as a parameter, except that its value must be specified as a type, and must be specified upon declaration and when using a constructor. When a class is defined using a generic (like Class in Java is defined), upon declaration, you can specify the type of class that will pertain to the variable declaration.

Where you may have seen this before is with an ArrayList, for example:

ArrayList<String> names = new ArrayList<String>();

In this case, you are telling the Java compiler that names will hold an ArrayList of String values. Then, when you call names.get(0), for example, the compiler knows that the returned value is a String, and as such you could call String methods on it.

The question mark, as it relates to generics, is called a wildcard. Without any other keywords, the single ? means that the type is any class that extends Object, which is literally any Java class. You'll have limitations in what you can do with the variable itself, since the compiler won't know what type is being used. Give it a shot yourself. In workspaces, try doing the following:

import java.util.ArrayList;

public class TestString {
    public static void main(String[] args) {
        ArrayList<?> names = new ArrayList<String>();
        names.add("Kermit the Frog");
    }
}

Notice the compiler error that occurs when you try to call names.add(...). It's not that the ArrayList that is created and stored into names isn't an ArrayList of Strings, it's just that since you used the question mark when declaring names, the compiler doesn't know that the items will be Strings. Change the question mark to String, and the compiler is happy.

As for the example in the video, out of brevity, I chose to use the question mark. With a few more keystrokes, I could have declared the variable as follows:

Class<MathUtils> clazz = MathUtils.class;

I chose this declaration because it has no impact on what we need to accomplish. As you can see, with an ArrayList, it has a significant impact.

Related Discussions

Have questions about this video? Start a discussion with the community and Treehouse staff.

Sign up

Related Discussions

Have questions about this video? Start a discussion with the community and Treehouse staff.

Sign up

Reflection is a feature in programming languages where by you can 0:00

write code to examine the structure of classes or objects, and 0:04

even modify their structure and behavior. 0:07

Right now we're not interested in modifying structure or behavior. 0:10

We'll focus instead on examining the structure. 0:13

That is, we'll want to write code that cracks the hood of the MathUtils object 0:17

to look at its annotations and method declarations. 0:22

Some refer to this part of reflection as introspection. 0:26

For simplicity, I'll just use the term reflection. 0:29

Let's hop over to the main class and practice some reflection 0:34

techniques that will be helpful in processing our annotations. 0:36

The first thing we'll need to be able to do is utilize the class object itself. 0:39

Let's examine the structure of the MathUtils class by grabbing a reference to 0:44

the class. 0:48

Let's add a comment here saying that we're getting a class objects. 0:52

And I will define it. 0:57

And store into it a reference to the class. 1:03

Now, hey, since we're using the MathUtils class for 1:07

the first time in this Java file, let's be sure to import that. 1:10

Wonderful. 1:18

Notice that I'm not calling this variable class. 1:20

Remember that class is a reserved keyword in Java, and 1:25

in many other programming languages, as well. 1:29

This means that it can't be used as an identifier to name a variable, a method, 1:31

or a class. 1:36

So one of convention is to replace the S's in class with Z's, 1:37

which is what I've done here. 1:42

Now that we have a reference to the class object itself, 1:44

let's look at the MathUtils class's methods. 1:47

You might think to yourself, what do you mean look at the class's methods? 1:51

I could just click over to MathUtils.java and look at them myself. 1:54

And you'd be right, but even though we programmers can 1:58

look at a bunch of code and see everything that is present, the power of programming 2:02

comes from having a computer do the work so that we don't have to. 2:06

What we like to do is write some code that allows our application to get 2:10

the details of an object during run time, this is reflection. 2:12

After all the JVM will be able to do this much faster than we ever could. 2:17

Also, we wouldn't have to plop ourselves in front of the computer while our program 2:22

is examining these objects, but if we really insisted on sticking around 2:26

while it runs we can at least grab a tasty beverage and 2:30

kickback while our program does all the work. 2:33

Let's examine the MathUtils class by taking a peek at its methods. 2:37

We'll start by calling a method on the class object called, quite intuitively, 2:40

GetMethods. 2:44

So here, we'll get all declared methods and 2:48

we will call that method that I just referenced. 2:53

And since we're using the method class for the first time, we better import that, 3:02

as well. 3:07

This will be the starting point from which we can look at various characteristics of 3:14

these methods, such as their modifiers, private, public, static, etc. 3:18

The number of parameters and the return types among other things. 3:22

You can find out what all your options are by checking out the JavaDocs for 3:26

the method class on the Oracle website. 3:29

I put a link to this in the teacher's notes. 3:31

We'll focus here on the ones I just mentioned since they're a particular 3:34

importance to us in this project. 3:38

Let's loop over this array of methods, and 3:40

display each of those pieces of information that I mentioned. 3:42

I'll write a loop now that summarizes what we want to do. 3:47

So here, we'll loop over the methods. 3:51

We use our enhanced for loop, also called a for-each-loop. 3:55

And let me include some comments here that displays what we intend to do. 4:03

We'll display the method name, the parameter count, 4:07

the return type, and the modifiers. 4:14

Let's start with a method name. 4:26

This one is pretty straightforward. 4:28

We'll display a single line, and the method we need to use is called getName. 4:30

So for this, I will display a formatted string with System.out.printf. 4:33

I'll include a placeholder for the actual method name, 4:40

as well as a new line character. 4:43

I'll stick into that placeholder the results of m.getName. 4:45

So that we don't go too far down a potentially error ridden path, 4:53

let's run our code now. 4:57

To do this, I'm first gonna pull up my console so 4:59

I have plenty of room to see the output that my program is generating. 5:02

Okay, we'll clear, we'll compile to the out 5:06

directory with a class path as a source directory, 5:11

and here is the Java file that we want to compile. 5:17

Great! 5:26

All compiles well. 5:27

Let's run this thing! 5:29

Using the Java command, I'll specify the class path as the out directory, and 5:31

then include the fully qualified name that includes the package name of the main 5:35

class. 5:40

Cool! 5:45

Look at all those methods. 5:46

But, wait, I didn't declare all those methods in our MathUtils class. 5:48

You probably already see what's happening in here. 5:54

The methods that are returned when we call getMethods include not only the declared 5:56

methods from the MathUtils class, but also inherited methods. 6:01

Now, if we want to focus on the declared method and 6:06

exclude things like toString and hashCode and getClass, 6:09

we simply call a method that returns only declared methods. 6:13

This one is called, again, intuitively getDeclaredMethods. 6:18

And when we loop over those we'll see only methods that we 6:23

put in the MathUtils class. 6:26

Let's recompile and rerun our code to see the results. 6:29

Clear before I run. 6:37

And there we go. 6:41

There are the five methods that are present in the MathUtils class. 6:42

Next, let's display the number of parameters for each method. 6:47

To accomplish this, we'll use the getParameterCount method which gives you 6:51

exactly what you think it should, the number of parameters. 6:54

I'll use formatted output here again to display the count. 6:57

I'll include a tab character here just for nice formatting. 7:08

I'll say the number of params, and then include a placeholder 7:11

where we will stick the actual parameter count, as well as a newline character. 7:15

Into that placeholder, I will stick m.getParameterCount. 7:20

Capital C. 7:26

Let's run it again and see if our output matches what we expect. 7:30

I'll recompile. 7:36

We'll clear, and we'll run again. 7:39

And there we go, 7:42

the number of parameters is correctly listed under each method name. 7:43

Pretty cool. 7:47

Another piece of information we can get from our methods using reflection is 7:50

the return type. 7:53

Let's display this in a similar fashion. 7:54

So under Display return type, I will display another line of formatted output, 7:58

Which includes, again, a tab character for a nicely formatted output. 8:05

Here's the return type. 8:09

My string placeholder and my new line character. 8:11

And I'll stick into that placeholder the results of getReturnType. 8:17

Let's recompile and rerun, see what we get. 8:25

All compiles well. 8:30

We clear. 8:31

And I'll run again. 8:34

And there we go. 8:35

We get the return types for each one of our methods. 8:36

Now, in the case of return types that are classes, the output contains the fully 8:41

qualified name of the class, which means that it includes the package name. 8:44

For example, here java.lang.Double. 8:48

If you don't want that then you can get what's called the simple name. 8:52

So I'll tack onto this return value here, and 8:55

we'll use .getSimpleName. 8:58

Let's recompile and rerun and see what our results are. 9:03

Recompile, all clear, and rerun. 9:09

Cool, much simpler return types there. 9:13

The last piece of information about each method that we'll examine 9:18

are the modifiers. 9:20

This one's a big trickier than the others because when we call get modifiers in 9:22

the method object, we actually get back an int value. 9:25

Let's stick it into an int variable for now and I'll show you how we can 9:29

convert this int into a string that represents all modifiers as you'd expect. 9:32

So I'll create an int variable called mods and call getModifiers. 9:38

Then, let's see what this output produces. 9:47

System.out.printf, again, 9:49

using my tab character. 9:53

Here's a placeholder for the int modifier. 9:57

We'll save that. 10:05

Now, if we compile and run this program, you'll see those ints. 10:07

Let's do that now. 10:10

There they are. 10:18

Modifiers 9, 9, 10. 10:19

These aren't particularly meaningful to us, but 10:24

if we use a convenience method provided by the modifier class, 10:27

we can get a space separated string representing all modifiers. 10:31

To do this, I'll add a line of code that includes a string variable called 10:36

modString, or modStr as an abbreviation. 10:41

And the modifier class includes a static method called toString that accepts 10:44

a parameter, unlike the standard toString method. 10:48

I'll pass to it the int. 10:52

Now, if I swap out this for 10:54

modString, I should see that modifier string that this static method produces. 10:59

Now, I've just introduced a new class here, of modifier. 11:03

So in order for this to compile, I know I'm gonna have to go up and import that. 11:06

Let's go add that import statement now. 11:10

Import java.lang.reflect.Modifier. 11:13

And with that in place, let's compile our code. 11:18

We'll clear, and rerun. 11:24

There we go. 11:27

We see those modifiers exactly as we would have expected them. 11:28

Having practiced almost all of the reflection we'll need for 11:33

coding the Doc Processor class, let's go there in the next video. 11:36

You need to sign up for Treehouse in order to download course files.

Sign up

You need to sign up for Treehouse in order to set up Workspace

Sign up