How are Anonymous inner classes used in Java

Question

What is the use of anonymous classes in Java  Can we say that usage of anonymous class is one of the advantages of Java

User · Answer

Anonymous inner class is used in following scenario:

1.)For Overriding(Sub classing) ,When class definition is not usable except current case:

class A{
   public void methodA() {
      System.out.println("methodA");
    }
}
class B{
    A a = new A() {
     public void methodA() {
        System.out.println("anonymous methodA");
     }
   };
}

2.)For implementing an interface,When implemention of interface is required only for current case:

interface interfaceA{
   public void methodA();
}
class B{
   interfaceA a = new interfaceA() {
     public void methodA() {
        System.out.println("anonymous methodA implementer");
     }
   };
}

3.)Argument Defined Anonymous inner class:

 interface Foo {
   void methodFoo();
 }
 class B{
  void do(Foo f) { }
}

class A{
   void methodA() {
     B b = new B();
     b.do(new Foo() {
       public void methodFoo() {
         System.out.println("methodFoo");
       } 
     });
   } 
 }

User · Answer

Anonymous inner class can be beneficial while giving different implementations for different objects  But should be used very sparingly as it creates problem for program readability

User · Answer

Anonymous inner class can be beneficial while giving different implementations for different objects  But should be used very sparingly as it creates problem for program readability

User · Answer

Anonymous inner class is used in following scenario:

1.)For Overriding(Sub classing) ,When class definition is not usable except current case:

class A{
   public void methodA() {
      System.out.println("methodA");
    }
}
class B{
    A a = new A() {
     public void methodA() {
        System.out.println("anonymous methodA");
     }
   };
}

2.)For implementing an interface,When implemention of interface is required only for current case:

interface interfaceA{
   public void methodA();
}
class B{
   interfaceA a = new interfaceA() {
     public void methodA() {
        System.out.println("anonymous methodA implementer");
     }
   };
}

3.)Argument Defined Anonymous inner class:

 interface Foo {
   void methodFoo();
 }
 class B{
  void do(Foo f) { }
}

class A{
   void methodA() {
     B b = new B();
     b.do(new Foo() {
       public void methodFoo() {
         System.out.println("methodFoo");
       } 
     });
   } 
 }

User · Answer

Anonymous inner classes are effectively closures  so they can be used to emulate lambda expressions or  delegates   For example  take this interface   public interface F lt A  B gt       B f A a       You can use this anonymously to create a first-class function in Java  Let s say you have the following method that returns the first number larger than i in the given list  or i if no number is larger   public static int larger final List lt Integer gt  ns  final int i      for  Integer n   ns       if  n  gt  i          return n    return i      And then you have another method that returns the first number smaller than i in the given list  or i if no number is smaller   public static int smaller final List lt Integer gt  ns  final int i       for  Integer n   ns        if  n  lt  i           return n     return i      These methods are almost identical  Using the first-class function type F  we can rewrite these into one method as follows   public static  lt T gt  T firstMatch final List lt T gt  ts  final F lt T  Boolean gt  f  T z       for  T t   ts        if  f f t            return t     return z      You can use an anonymous class to use the firstMatch method   F lt Integer  Boolean gt  greaterThanTen   new F lt Integer  Boolean gt       Boolean f final Integer n          return n  gt  10          int moreThanMyFingersCanCount   firstMatch xs  greaterThanTen  x     This is a really contrived example  but its easy to see that being able to pass functions around as if they were values is a pretty useful feature  See  Can Your Programming Language Do This  by Joel himself   A nice library for programming Java in this style  Functional Java

User · Answer

new Thread             public void run                 try                   Thread sleep 300                 catch  InterruptedException e                    System out println  Exception message      e getMessage                     System out println  Exception cause      e getCause                                   start      This is also one of the example for anonymous inner type using thread

User · Answer

Yes  anonymous inner classes is definitely one of the advantages of Java   With an anonymous inner class you have access to final and member variables of the surrounding class  and that comes in handy in listeners etc   But a major advantage is that the inner class code  which is  at least should be  tightly coupled to the surrounding class method block  has a specific context  the surrounding class  method  and block

User · Answer

The best way to optimize code  also  We can use for an overriding method of a class or interface     import java util Scanner  abstract class AnonymousInner       abstract void sum       class AnonymousInnerMain       public static void main String   k           Scanner sn   new Scanner System in           System out println  Enter two vlaues                int a  Integer parseInt sn nextLine                 int b  Integer parseInt sn nextLine              AnonymousInner ac   new AnonymousInner                void sum                    int c  a b                  System out println  Sum of two number is    c                                    ac sum

User · Answer

new Thread             public void run                 try                   Thread sleep 300                 catch  InterruptedException e                    System out println  Exception message      e getMessage                     System out println  Exception cause      e getCause                                   start      This is also one of the example for anonymous inner type using thread

User · Answer

By an  anonymous class   I take it you mean anonymous inner class   An anonymous inner class can come useful when making an instance of an object with certain  extras  such as overriding methods  without having to actually subclass a class   I tend to use it as a shortcut for attaching an event listener   button addActionListener new ActionListener          Override     public void actionPerformed ActionEvent e               do something             Using this method makes coding a little bit quicker  as I don t need to make an extra class that implements ActionListener -- I can just instantiate an anonymous inner class without actually making a separate class   I only use this technique for  quick and dirty  tasks where making an entire class feels unnecessary  Having multiple anonymous inner classes that do exactly the same thing should be refactored to an actual class  be it an inner class or a separate class

User · Answer

You use it in situations where you need to create a class for a specific purpose inside another function  e g   as a listener  as a runnable  to spawn a thread   etc   The idea is that you call them from inside the code of a function so you never refer to them elsewhere  so you don t need to name them  The compiler just enumerates them   They are essentially syntactic sugar  and should generally be moved elsewhere as they grow bigger   I m not sure if it is one of the advantages of Java  though if you do use them  and we all frequently use them  unfortunately   then you could argue that they are one

User · Answer

You use it in situations where you need to create a class for a specific purpose inside another function  e g   as a listener  as a runnable  to spawn a thread   etc   The idea is that you call them from inside the code of a function so you never refer to them elsewhere  so you don t need to name them  The compiler just enumerates them   They are essentially syntactic sugar  and should generally be moved elsewhere as they grow bigger   I m not sure if it is one of the advantages of Java  though if you do use them  and we all frequently use them  unfortunately   then you could argue that they are one

User · Answer

They re commonly used as a verbose form of callback   I suppose you could say they re an advantage compared to not having them  and having to create a named class every time  but similar concepts are implemented much better in other languages  as closures or blocks   Here s a swing example  myButton addActionListener new ActionListener        public void actionPerformed ActionEvent e               do stuff here                Although it s still messily verbose  it s a lot better than forcing you to define a named class for every throw away listener like this  although depending on the situation and reuse  that may still be the better approach

User · Answer

Yes  anonymous inner classes is definitely one of the advantages of Java   With an anonymous inner class you have access to final and member variables of the surrounding class  and that comes in handy in listeners etc   But a major advantage is that the inner class code  which is  at least should be  tightly coupled to the surrounding class method block  has a specific context  the surrounding class  method  and block

User · Answer

By an  anonymous class   I take it you mean anonymous inner class   An anonymous inner class can come useful when making an instance of an object with certain  extras  such as overriding methods  without having to actually subclass a class   I tend to use it as a shortcut for attaching an event listener   button addActionListener new ActionListener          Override     public void actionPerformed ActionEvent e               do something             Using this method makes coding a little bit quicker  as I don t need to make an extra class that implements ActionListener -- I can just instantiate an anonymous inner class without actually making a separate class   I only use this technique for  quick and dirty  tasks where making an entire class feels unnecessary  Having multiple anonymous inner classes that do exactly the same thing should be refactored to an actual class  be it an inner class or a separate class

User · Answer

Yes  anonymous inner classes is definitely one of the advantages of Java   With an anonymous inner class you have access to final and member variables of the surrounding class  and that comes in handy in listeners etc   But a major advantage is that the inner class code  which is  at least should be  tightly coupled to the surrounding class method block  has a specific context  the surrounding class  method  and block

User · Answer

By an  anonymous class   I take it you mean anonymous inner class   An anonymous inner class can come useful when making an instance of an object with certain  extras  such as overriding methods  without having to actually subclass a class   I tend to use it as a shortcut for attaching an event listener   button addActionListener new ActionListener          Override     public void actionPerformed ActionEvent e               do something             Using this method makes coding a little bit quicker  as I don t need to make an extra class that implements ActionListener -- I can just instantiate an anonymous inner class without actually making a separate class   I only use this technique for  quick and dirty  tasks where making an entire class feels unnecessary  Having multiple anonymous inner classes that do exactly the same thing should be refactored to an actual class  be it an inner class or a separate class

User · Answer

By an  anonymous class   I take it you mean anonymous inner class   An anonymous inner class can come useful when making an instance of an object with certain  extras  such as overriding methods  without having to actually subclass a class   I tend to use it as a shortcut for attaching an event listener   button addActionListener new ActionListener          Override     public void actionPerformed ActionEvent e               do something             Using this method makes coding a little bit quicker  as I don t need to make an extra class that implements ActionListener -- I can just instantiate an anonymous inner class without actually making a separate class   I only use this technique for  quick and dirty  tasks where making an entire class feels unnecessary  Having multiple anonymous inner classes that do exactly the same thing should be refactored to an actual class  be it an inner class or a separate class

User · Answer

Anonymous inner classes are effectively closures  so they can be used to emulate lambda expressions or  delegates   For example  take this interface   public interface F lt A  B gt       B f A a       You can use this anonymously to create a first-class function in Java  Let s say you have the following method that returns the first number larger than i in the given list  or i if no number is larger   public static int larger final List lt Integer gt  ns  final int i      for  Integer n   ns       if  n  gt  i          return n    return i      And then you have another method that returns the first number smaller than i in the given list  or i if no number is smaller   public static int smaller final List lt Integer gt  ns  final int i       for  Integer n   ns        if  n  lt  i           return n     return i      These methods are almost identical  Using the first-class function type F  we can rewrite these into one method as follows   public static  lt T gt  T firstMatch final List lt T gt  ts  final F lt T  Boolean gt  f  T z       for  T t   ts        if  f f t            return t     return z      You can use an anonymous class to use the firstMatch method   F lt Integer  Boolean gt  greaterThanTen   new F lt Integer  Boolean gt       Boolean f final Integer n          return n  gt  10          int moreThanMyFingersCanCount   firstMatch xs  greaterThanTen  x     This is a really contrived example  but its easy to see that being able to pass functions around as if they were values is a pretty useful feature  See  Can Your Programming Language Do This  by Joel himself   A nice library for programming Java in this style  Functional Java

User · Answer

You can use anonymous class this way  TreeSet treeSetObj   new TreeSet new Comparator         public int compare String i1 String i2                return i2 compareTo i1

User · Answer

Seems nobody mentioned here but you can also use anonymous class to hold generic type argument  which normally lost due to type erasure    public abstract class TypeHolder lt T gt        private final Type type       public TypeReference                you may do do additional sanity checks here         final Type superClass   getClass   getGenericSuperclass            this type     ParameterizedType  superClass  getActualTypeArguments   0              public final Type getType             return this type            If you ll instantiate this class in anonymous way   TypeHolder lt List lt String gt   Map lt Ineger  Long gt  gt  holder        new TypeHolder lt List lt String gt   Map lt Ineger  Long gt  gt          then such holder instance will contain non-erasured definition of passed type    Usage  This is very handy for building validators deserializators  Also you can instantiate generic type with reflection  so if you ever wanted to do new T   in parametrized type - you are welcome     Drawbacks Limitations   You should pass generic parameter explicitly  Failing to do so will lead to type parameter loss Each instantiation will cost you additional class to be generated by compiler which leads to classpath pollution jar bloating

User · Answer

The best way to optimize code  also  We can use for an overriding method of a class or interface     import java util Scanner  abstract class AnonymousInner       abstract void sum       class AnonymousInnerMain       public static void main String   k           Scanner sn   new Scanner System in           System out println  Enter two vlaues                int a  Integer parseInt sn nextLine                 int b  Integer parseInt sn nextLine              AnonymousInner ac   new AnonymousInner                void sum                    int c  a b                  System out println  Sum of two number is    c                                    ac sum

User · Answer

Anonymous inner classes are effectively closures  so they can be used to emulate lambda expressions or  delegates   For example  take this interface   public interface F lt A  B gt       B f A a       You can use this anonymously to create a first-class function in Java  Let s say you have the following method that returns the first number larger than i in the given list  or i if no number is larger   public static int larger final List lt Integer gt  ns  final int i      for  Integer n   ns       if  n  gt  i          return n    return i      And then you have another method that returns the first number smaller than i in the given list  or i if no number is smaller   public static int smaller final List lt Integer gt  ns  final int i       for  Integer n   ns        if  n  lt  i           return n     return i      These methods are almost identical  Using the first-class function type F  we can rewrite these into one method as follows   public static  lt T gt  T firstMatch final List lt T gt  ts  final F lt T  Boolean gt  f  T z       for  T t   ts        if  f f t            return t     return z      You can use an anonymous class to use the firstMatch method   F lt Integer  Boolean gt  greaterThanTen   new F lt Integer  Boolean gt       Boolean f final Integer n          return n  gt  10          int moreThanMyFingersCanCount   firstMatch xs  greaterThanTen  x     This is a really contrived example  but its easy to see that being able to pass functions around as if they were values is a pretty useful feature  See  Can Your Programming Language Do This  by Joel himself   A nice library for programming Java in this style  Functional Java

User · Answer

They re commonly used as a verbose form of callback   I suppose you could say they re an advantage compared to not having them  and having to create a named class every time  but similar concepts are implemented much better in other languages  as closures or blocks   Here s a swing example  myButton addActionListener new ActionListener        public void actionPerformed ActionEvent e               do stuff here                Although it s still messily verbose  it s a lot better than forcing you to define a named class for every throw away listener like this  although depending on the situation and reuse  that may still be the better approach

User · Answer

GuideLines for Anonymous Class    Anonymous class is declared and initialized simultaneously  Anonymous class must extend or implement to one and only one class or interface resp  As anonymouse class has no name  it can be used only once    eg     button addActionListener new ActionListener                 public void actionPerformed ActionEvent arg0               TODO Auto-generated method stub

User · Answer

One of the major usage of anonymous classes in class-finalization which called finalizer guardian  In Java world using the finalize methods should be avoided until you really need them  You have to remember  when you override the finalize method for sub-classes  you should always invoke super finalize   as well  because the finalize method of super class won t invoke automatically and you can have trouble with memory leaks   so considering the fact mentioned above  you can just use the anonymous classes like   public class HeavyClass      private final Object finalizerGuardian   new Object              Override         protected void finalize   throws Throwable                Finalize outer HeavyClass object                      Using this technique you relieved yourself and your other developers to call super finalize   on each sub-class of the HeavyClass which needs finalize method

User · Answer

Anonymous inner classes are effectively closures  so they can be used to emulate lambda expressions or  delegates   For example  take this interface   public interface F lt A  B gt       B f A a       You can use this anonymously to create a first-class function in Java  Let s say you have the following method that returns the first number larger than i in the given list  or i if no number is larger   public static int larger final List lt Integer gt  ns  final int i      for  Integer n   ns       if  n  gt  i          return n    return i      And then you have another method that returns the first number smaller than i in the given list  or i if no number is smaller   public static int smaller final List lt Integer gt  ns  final int i       for  Integer n   ns        if  n  lt  i           return n     return i      These methods are almost identical  Using the first-class function type F  we can rewrite these into one method as follows   public static  lt T gt  T firstMatch final List lt T gt  ts  final F lt T  Boolean gt  f  T z       for  T t   ts        if  f f t            return t     return z      You can use an anonymous class to use the firstMatch method   F lt Integer  Boolean gt  greaterThanTen   new F lt Integer  Boolean gt       Boolean f final Integer n          return n  gt  10          int moreThanMyFingersCanCount   firstMatch xs  greaterThanTen  x     This is a really contrived example  but its easy to see that being able to pass functions around as if they were values is a pretty useful feature  See  Can Your Programming Language Do This  by Joel himself   A nice library for programming Java in this style  Functional Java

User · Answer

You can use anonymous class this way  TreeSet treeSetObj   new TreeSet new Comparator         public int compare String i1 String i2                return i2 compareTo i1

User · Answer

I use them sometimes as a syntax hack for Map instantiation   Map map   new HashMap         put  key    value          vs  Map map   new HashMap    map put  key    value      It saves some redundancy when doing a lot of put statements  However  I have also run into problems doing this when the outer class needs to be serialized via remoting

User · Answer

i use anonymous objects  for calling new Threads    new Thread new Runnable         public void run                you code          start

User · Answer

Seems nobody mentioned here but you can also use anonymous class to hold generic type argument  which normally lost due to type erasure    public abstract class TypeHolder lt T gt        private final Type type       public TypeReference                you may do do additional sanity checks here         final Type superClass   getClass   getGenericSuperclass            this type     ParameterizedType  superClass  getActualTypeArguments   0              public final Type getType             return this type            If you ll instantiate this class in anonymous way   TypeHolder lt List lt String gt   Map lt Ineger  Long gt  gt  holder        new TypeHolder lt List lt String gt   Map lt Ineger  Long gt  gt          then such holder instance will contain non-erasured definition of passed type    Usage  This is very handy for building validators deserializators  Also you can instantiate generic type with reflection  so if you ever wanted to do new T   in parametrized type - you are welcome     Drawbacks Limitations   You should pass generic parameter explicitly  Failing to do so will lead to type parameter loss Each instantiation will cost you additional class to be generated by compiler which leads to classpath pollution jar bloating

User · Answer

I use them sometimes as a syntax hack for Map instantiation   Map map   new HashMap         put  key    value          vs  Map map   new HashMap    map put  key    value      It saves some redundancy when doing a lot of put statements  However  I have also run into problems doing this when the outer class needs to be serialized via remoting

User · Answer

Yes  anonymous inner classes is definitely one of the advantages of Java   With an anonymous inner class you have access to final and member variables of the surrounding class  and that comes in handy in listeners etc   But a major advantage is that the inner class code  which is  at least should be  tightly coupled to the surrounding class method block  has a specific context  the surrounding class  method  and block

User · Answer

An Anonymous Inner Class is used to create an object that will never be referenced again  It has no name and is declared and created in the same statement  This is used where you would normally use an object s variable  You replace the variable with the new keyword  a call to a constructor and the class definition inside   and     When writing a Threaded Program in Java  it would usually look like this  ThreadClass task   new ThreadClass    Thread runner   new Thread task   runner start      The ThreadClass used here would be user defined  This class will implement the Runnable interface which is required for creating threads  In the ThreadClass the run   method  only method in Runnable  needs to be implemented as well   It is clear that getting rid of ThreadClass would be more efficient and that s exactly why Anonymous Inner Classes exist   Look at the following code   Thread runner   new Thread new Runnable         public void run               Thread does it s work here           runner start      This code replaces the reference made to task in the top most example  Rather than having a separate class  the Anonymous Inner Class inside the Thread   constructor returns an unnamed object that implements the Runnable interface and overrides the run   method  The method run   would include statements inside  that do the work required by the thread   Answering the question on whether Anonymous Inner Classes is one of the advantages of Java  I would have to say that I m not quite sure as I am not familiar with many programming languages at the moment  But what I can say is it is definitely a quicker and easier method of coding   References  Sams Teach Yourself Java in 21 Days Seventh Edition

User · Answer

One more advantage  As you know that Java doesn t support multiple inheritance  so if you use  Thread  kinda class as anonymous class then the class still has one space left for any other class to extend

User · Answer

I use them sometimes as a syntax hack for Map instantiation   Map map   new HashMap         put  key    value          vs  Map map   new HashMap    map put  key    value      It saves some redundancy when doing a lot of put statements  However  I have also run into problems doing this when the outer class needs to be serialized via remoting

User · Answer

You use it in situations where you need to create a class for a specific purpose inside another function  e g   as a listener  as a runnable  to spawn a thread   etc   The idea is that you call them from inside the code of a function so you never refer to them elsewhere  so you don t need to name them  The compiler just enumerates them   They are essentially syntactic sugar  and should generally be moved elsewhere as they grow bigger   I m not sure if it is one of the advantages of Java  though if you do use them  and we all frequently use them  unfortunately   then you could argue that they are one

User · Answer

They re commonly used as a verbose form of callback   I suppose you could say they re an advantage compared to not having them  and having to create a named class every time  but similar concepts are implemented much better in other languages  as closures or blocks   Here s a swing example  myButton addActionListener new ActionListener        public void actionPerformed ActionEvent e               do stuff here                Although it s still messily verbose  it s a lot better than forcing you to define a named class for every throw away listener like this  although depending on the situation and reuse  that may still be the better approach

User · Answer

An inner class is associated with an instance of the outer class and there are two special kinds  Local class and Anonymous class  An anonymous class enables us to declare and instantiate a class at same time  hence makes the code concise  We use them when we need a local class only once as they don t have a name   Consider the example from doc where we have a Person class   public class Person        public enum Sex           MALE  FEMALE            String name      LocalDate birthday      Sex gender      String emailAddress       public int getAge                               public void printPerson                              and we have a method to print members that match search criteria as   public static void printPersons      List lt Person gt  roster  CheckPerson tester        for  Person p   roster            if  tester test p                 p printPerson                        where CheckPerson is an interface like   interface CheckPerson       boolean test Person p       Now we can make use of anonymous class which implements this interface to specify search criteria as   printPersons      roster      new CheckPerson             public boolean test Person p                return p getGender      Person Sex MALE                  amp  amp  p getAge    gt   18                  amp  amp  p getAge    lt   25                       Here the interface is very simple and the syntax of anonymous class seems unwieldy and unclear   Java 8 has introduced a term Functional Interface which is an interface with only one abstract method  hence we can say CheckPerson is a functional interface   We can make use of Lambda Expression which allows us to pass the function as method argument as   printPersons                  roster                   Person p  - gt  p getGender      Person Sex MALE                          amp  amp  p getAge    gt   18                          amp  amp  p getAge    lt   25              We can use a standard functional interface Predicate in place of the interface CheckPerson  which will further reduce the amount of code required

User · Answer

You use it in situations where you need to create a class for a specific purpose inside another function  e g   as a listener  as a runnable  to spawn a thread   etc   The idea is that you call them from inside the code of a function so you never refer to them elsewhere  so you don t need to name them  The compiler just enumerates them   They are essentially syntactic sugar  and should generally be moved elsewhere as they grow bigger   I m not sure if it is one of the advantages of Java  though if you do use them  and we all frequently use them  unfortunately   then you could argue that they are one

User · Answer

I use them sometimes as a syntax hack for Map instantiation   Map map   new HashMap         put  key    value          vs  Map map   new HashMap    map put  key    value      It saves some redundancy when doing a lot of put statements  However  I have also run into problems doing this when the outer class needs to be serialized via remoting

User · Answer

i use anonymous objects  for calling new Threads    new Thread new Runnable         public void run                you code          start

User · Answer

They re commonly used as a verbose form of callback   I suppose you could say they re an advantage compared to not having them  and having to create a named class every time  but similar concepts are implemented much better in other languages  as closures or blocks   Here s a swing example  myButton addActionListener new ActionListener        public void actionPerformed ActionEvent e               do stuff here                Although it s still messily verbose  it s a lot better than forcing you to define a named class for every throw away listener like this  although depending on the situation and reuse  that may still be the better approach

User · Answer

One of the major usage of anonymous classes in class-finalization which called finalizer guardian  In Java world using the finalize methods should be avoided until you really need them  You have to remember  when you override the finalize method for sub-classes  you should always invoke super finalize   as well  because the finalize method of super class won t invoke automatically and you can have trouble with memory leaks   so considering the fact mentioned above  you can just use the anonymous classes like   public class HeavyClass      private final Object finalizerGuardian   new Object              Override         protected void finalize   throws Throwable                Finalize outer HeavyClass object                      Using this technique you relieved yourself and your other developers to call super finalize   on each sub-class of the HeavyClass which needs finalize method

User · Answer

One more advantage  As you know that Java doesn t support multiple inheritance  so if you use  Thread  kinda class as anonymous class then the class still has one space left for any other class to extend

User · Answer

GuideLines for Anonymous Class    Anonymous class is declared and initialized simultaneously  Anonymous class must extend or implement to one and only one class or interface resp  As anonymouse class has no name  it can be used only once    eg     button addActionListener new ActionListener                 public void actionPerformed ActionEvent arg0               TODO Auto-generated method stub

User · Answer

An inner class is associated with an instance of the outer class and there are two special kinds  Local class and Anonymous class  An anonymous class enables us to declare and instantiate a class at same time  hence makes the code concise  We use them when we need a local class only once as they don t have a name   Consider the example from doc where we have a Person class   public class Person        public enum Sex           MALE  FEMALE            String name      LocalDate birthday      Sex gender      String emailAddress       public int getAge                               public void printPerson                              and we have a method to print members that match search criteria as   public static void printPersons      List lt Person gt  roster  CheckPerson tester        for  Person p   roster            if  tester test p                 p printPerson                        where CheckPerson is an interface like   interface CheckPerson       boolean test Person p       Now we can make use of anonymous class which implements this interface to specify search criteria as   printPersons      roster      new CheckPerson             public boolean test Person p                return p getGender      Person Sex MALE                  amp  amp  p getAge    gt   18                  amp  amp  p getAge    lt   25                       Here the interface is very simple and the syntax of anonymous class seems unwieldy and unclear   Java 8 has introduced a term Functional Interface which is an interface with only one abstract method  hence we can say CheckPerson is a functional interface   We can make use of Lambda Expression which allows us to pass the function as method argument as   printPersons                  roster                   Person p  - gt  p getGender      Person Sex MALE                          amp  amp  p getAge    gt   18                          amp  amp  p getAge    lt   25              We can use a standard functional interface Predicate in place of the interface CheckPerson  which will further reduce the amount of code required

User · Answer

An Anonymous Inner Class is used to create an object that will never be referenced again  It has no name and is declared and created in the same statement  This is used where you would normally use an object s variable  You replace the variable with the new keyword  a call to a constructor and the class definition inside   and     When writing a Threaded Program in Java  it would usually look like this  ThreadClass task   new ThreadClass    Thread runner   new Thread task   runner start      The ThreadClass used here would be user defined  This class will implement the Runnable interface which is required for creating threads  In the ThreadClass the run   method  only method in Runnable  needs to be implemented as well   It is clear that getting rid of ThreadClass would be more efficient and that s exactly why Anonymous Inner Classes exist   Look at the following code   Thread runner   new Thread new Runnable         public void run               Thread does it s work here           runner start      This code replaces the reference made to task in the top most example  Rather than having a separate class  the Anonymous Inner Class inside the Thread   constructor returns an unnamed object that implements the Runnable interface and overrides the run   method  The method run   would include statements inside  that do the work required by the thread   Answering the question on whether Anonymous Inner Classes is one of the advantages of Java  I would have to say that I m not quite sure as I am not familiar with many programming languages at the moment  But what I can say is it is definitely a quicker and easier method of coding   References  Sams Teach Yourself Java in 21 Days Seventh Edition

[java] How are Anonymous inner classes used in Java?

Examples related to java

Examples related to anonymous-class

Examples related to anonymous-inner-class