If you didn't take the time earlier to scan the logic of this class, go ahead and

pause the video now and take a peek.

When you get the gist of it, un-pause and we'll continue.

Everything that needs to be done is documented with a to do comment, so

let's jump right in.

To check if an annotation is present on a class or

a method, the code is quite simple and intuitive.

We'll use the class objects, isAnnotationPresent() method.

So in place of true, I will type clazz.

I'm gonna call this variable clazz, so

it's not confused with class, isAnnotationPresent().

And I'll press Doc.class.

So, I tell the class object exactly what annotation I'm looking for.

Next up is looping over the declared methods of the class object.

We did this while practicing.

So here, instead of looping over an empty array, which I have right here, we'll use

the getDeclaredMethods method to return an array of the classesDeclared methods.

clazz.getDeclaredMethods().

Now, let's get the modifiers the current method.

This is accomplished with the get modifiers method.

Remember, this comes back as an int.

We'll be making more meaningful use of this int in just a moment.

So in place of this string approach that we took in practicing reflection,

we're gonna store this as an int.

int, and I'll call it modifierInt

= method.getModifiers.

Getting the method name was also simple and straightforward.

We use the getName() method.

So in place of null, method.getName().

Now back to those modifiers.

We need to use what's store in modifierInts to check whether or

not the private modifier is present.

We could use the approach we did earlier.

Convert the int to a modifier string and

then check to see if that string contains the word private.

But, there's another method in the Modifier class

that will get us there one step sooner.

It's the isPrivate() method, and it's a static method.

So in place of true I will check to see if the modifier is private and

I'll pass it the modifierInt that I got back from calling getModifiers() up above.

Now of course, I want to check to see if the method is non-private, so I'm going to

negate this boolean value that comes back with the exclamation point.

I also realized that I'd introduced the Modifier class for

the first time in this file.

So let's go to the top and import the modifier class.

Import jaba.lang.reflect.Modifier.

Brilliant, scrolling back down,

next we'll need to check and see if the annotation appears on the method.

Right here, in place of this true,

will also call the isAnnotationPresent() on the method.

So, I'll call method.isAnnotationPresent().

Again, past the .class, so it knows which annotation we're actually looking for.

The next to do is a critical one, and one we haven't practiced yet, but

it's also really easy.

This will be the piece of code that gives us access to the actual element values

on the individually placed annotations.

That is, we'll be able to read the details of a specific annotation.

For example, what description was indeed provided?

Or, how many parameters were actually documented?

What we need to do is fetch the annotation itself as a doc object, so that we can

call the interface methods, or elements, that we defined in the annotation.

To do this, we'll call the methods getAnnotation() method.

method.getAnnotation(), again specifying which

annotation it is that we'd like to get.

The rest of our coding falls into the two methods at the bottom of the class.

getNumMissingParams(), right here, as well as hasReturnDescription(),

the last method at the bottom here.

Let's start with getNumMissingParams().

Our first order of business is comparing the number of parameters to

the number of parameters document.

We'll first put each piece of information into a variable and

then use those values in simple comparison.

So, after these to do comments, I'll create a couple of variables.

The first one I'm gonna call annotedParamCount.

This will be the number of parameters that were documented in the annotation itself.

So, to find that I will say doc.paramas().length.

Remember, the params element that we declared in the annotation is

a string array.

Since it's a string array, we have access to the length property.

Okay, my next variable I'm going to call actualParamCount.

This variable will store the actual number of parameters on the method object.

method.GetParameterCount().

Finally, to compare the two values in place of true,

we'll use those two variable names that we just declared and stored values into.

So if the annotatedParamCount < actualParamCount

Then we must have some missing parameters.

So, how do we calculate that?

Well, that is simply a subtraction problem between those two values.

So, numMissing = actualParamCount- annotatedParamCount.

On to our last method, hasReturnDescription().

For this method, we want to return true in two scenarios.

Either a, the method is a void method, or

b, the method's annotation has a non-empty return val element.

Let's write a boolean expression for just that.

To return true in the first scenario,

I'll check to see if the method's return type is Void.

To do this, I'll call the getReturnType() method on the method object,

getReturnType(), and we'll see if its value equals Void.TYPE.

In the second scenario,

we wanna return true when the annotations returnVal element is empty.

So to check that, we'll say doc.returnVal.isEmpty.

We wanna check for nonempty returnVals, so

again, I'll negate that boolean value with the exclamation point.

At this point we've finished coding the analysis of our annotation.

One of the cool things here, is that there's nothing that we wrote that is

specific to the MathUtils class, which means that we can

use this DocProcessor class to analyze the doc annotation of any class we like.

Let's test all this code by hopping over to the Main class and

calling the DocProcessor's, processor method.

I'll first remove all of our test code that we wrote while we were practicing

reflection.

So I'll call DocProcessor.process and pass it MathUtils.

And we're ready to compile and run.

So back in our console, I'll compile with javac.

Specify the out directory as a placement for our class files, set the class

path as the src directory, and we'll type the file that we wanna compile.

It looks like we have an error here.

Let's check it out and see if we can troubleshoot this.

Looks like I mistyped a variable name in DocProcessor.java on line 109.

Let's hop over there and correct that error and recompile.

Line 109 is right here.

Looks like that should be annotatedParamCount.

I'll correct that, and let's see if that was our only error.

It's saying one error in our compiler results.

So, I'm pretty confident here.

Recompile.

Great, I'm gonna clear.

Give myself a little more room for output.

And let's run this program.

I'll set the class path as the out directory and

let's run com.teamtreehouse.docgen.Main.

Great, it finds both our sufficient and

insufficient documentation on the MathUtils class.

I'll leave fixing the insufficient documentation as an exercise for

you after this video.

Now that we've looked at the basics of annotations,

experimented with the built-in annotations and

even built one of our own, you're ready to encounter them in the wild.

I've linked to some resources in the teacher's notes for

further research, including a few popular libraries that utilize annotations.

Having trouble with a specific library?

Be sure to hit up the forums of those libraries, or

even broader coding forums like StackOverflow.

Chances are,

the answer you're looking for is sitting out there waiting for your visit.

Happy annotating!