Anonymous classes are classes which are not assigned a name by the person programming the class. They are typically used when naming the class is unnecessary, such as when the class is nothing more than a required subset of another higher superclass. The advantage to programming anonymous classes is that they afford the programmer a chance to streamline his or her code, especially in instances where the anonymous classes will fit into multiple superclasses. A major disadvantage is that anonymous classes cannot define constructors or made private, protected, or static, as the lack of a name eliminates these possibilities.
In computer programming, a class is a generalized object which can appear in any number of specific instances. Much like the term "airplane" broadly covers all types of single engine planes, twin engine planes, military aircraft, and passenger craft, a "class" in computing terms is a generic instance of an object. It is nothing but a template which can be filled in as needed to suit the programmers' or the end user's needs. For example, creating a class called "bicycle" would likely include the parameters for a bike; in other words, tire size and type, the number of gears, the specific brand and model of bike, and so on.
Programmers typically use anonymous classes as subsets of superclasses, which are classes constructed from multiple classes of their own. Continuing the previous example with the "bicycle" class, an anonymous sub-class of that could be "tires," containing information about tire size, make, and so on.
The advantage to doing this is that the anonymous class of "tires" could equally well fit into a superclass of "bicycles" or a superclass of "automobiles." By creating it as an anonymous class, the programmer can more easily reuse his work if necessary. This saves time and cost, and makes code far easier to understand.
A disadvantage is that without a name, anonymous classes cannot use the same functionality as named classes. For example, they cannot be deemed private, protected, or restricted classes. Additionally, they cannot utilize constructors, which are subroutines when the class first appears that initializes the class with default parameters. This lack of flexibility is the natural tradeoff for the simplicity of an anonymous class.