| It is common in Java programming to encounter situations 
              where you need to create an object but don't need to bother giving 
              it an explicit name. For example, to obtain the size of a panel 
              you can use statements like these:   Dimension 
              d = getSize();int width  = d.width;
 int height = d.height;
 where a Dimension 
              object is returned from a method and then used to obtain the width 
              and height values. But why bother creating a variable for this since 
              it will never be used again and will only take up memory space. 
              Instead, you could replace that code with this:   int 
              width  = getSize().width;int height = getSize().height;
 where the compiler keeps track of the Dimension 
              object from which you obtain the width and height. You can in fact cascade several such calls, using 
              the object returned in the left method to call the next method on 
              the right:    a 
              = getA().methodB().aMethodC().variableX; This anonymity eliminates a lot unnecessary 
              named objects and makes it more readable.  With the inner classes 
              we can take this to another level by creating and instantiating 
              a class without bothering to give it a name. In the code below an 
              instance of the ActionListener 
              class is created in the argument of the addActionListener 
              method:  
              
                 
                  | ..public 
                      class AnOuterClass extends 
                      Applet
 {
 Button fBt = new 
                      Button("OK");
 public AnOuterClass 
                      ()
 {
 int 
                      i = 0;
 fBt.addActionListener
 ( // The 
                      argument is the object created by the following:
 
 new 
                      ActionListener () // 
                      no name given to this object
 {
 public 
                      void actionPerformed (ActionEvent 
                      e) {
 i++;
 System.out.println 
                      ("Pressed "+i+" times");
 }
 }
 
 );
 add(fBt);
 }
 } // class 
                      AnOuterClass
 |    Here in one step we created an implementation of the 
               ActionListener 
              interface and created an instance of it for use by the button. Now the compiler will create a class file name AnOuterClass$1.class 
              where a number, in this case "1", is used to identify 
              the class files for anonymous inner classes.    Latest update: Nov. 3, 2004 |