(Or more things I should have learned in college)
One of the things that always tripped me up when I was working on open-source projects in High School was seeing what looked to me to be very strange formatting of code. It would be a jumble of parentheses and curly-braces, and it wouldn't make sense to me. Worse yet, I couldn't find a pattern to try to associate this formatting with. So I just skipped it and modified what I knew.
In College, I took a programming language course where we explored the more "exotic" languages. We got to lisp and lambda functions and once I learned about those, I had all the knowledge needed to understand the weird syntax.
It wasn't until I got into android programming that I saw funny looking code again.and then it all made sense. Here's an example:
searchBtn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
...
}
});
This threw me for a loop -- method calls are usually in the form of
object.method(arg1, arg2, ...);
Why was there a new in there?
What's with all the curly braces?
Why wasn't the method call finished before all this new junk was put in?
Well, While I was pondering these things, it all just sort of clicked. It was an Anonymous Class.
What are Anonymous Classes?
Anonymous classes are classes that have no explicit name. As a result they are only used once.
Why Would you use one?
Because you're lazy er...because there are cases where you only need a class only to satisfy a parameter of a function. These are most useful for
callbacks. Doing GUI programming, or interfacing with some type of input device, you'll see them often.
How to interpret/use one
Well lets start off with the example above. Lets look at it's
method signature:
void setOnClickListener(View.OnClickListener l) ;
That's pretty straightforward, it's a function that takes one argument of type OnClickListener.
Lets look at the
OnClickListener class. It's an interface. That means that you can't call a instance of that class, it can only be implemented in a class which defines all it's abstract methods. In this case, setOnClickListerner needs an instance of a OnClickListener class so that it knows what to do when clicked. Here's what you can't do:
OnClickListener bob = new OnClickListener();
That won't compile because it has an abstract method, onClick(View v), which needs to be defined. So we can write a class that implements the OnClickListener
class anOnClickListernerForTheStartButtonOnTheMainActivity implements View.OnClickListener {
onClick(View v)
{
...
}
}
//In another file
anOnClickListernerForTheStartButtonOnTheMainActivity bob = new anOnClickListernerForTheStartButtonOnTheMainActivity();
searchBtn.setOnClickListener(bob);
But that gets cumbersome, so we do as the first example above does and use anonymous classes.
Hopefully this helps someone else understand the beauty of Anonymous Classes
