Comment sont Anonymes intérieur des classes Java?

Par une "classe anonyme", je le prends à vous dire anonyme intérieur de la classe.

Anonyme intérieur de la classe peut être utile lors de la prise d'une instance d'un objet à une certaine "extras" tels que le remplacement des méthodes, sans avoir à réellement sous-classe d'une classe.

J'ai tendance à l'utiliser comme un raccourci pour attacher un écouteur d'événement:

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        //do something
    }
});

À l'aide de cette méthode rend la programmation un peu plus rapidement, comme je n'ai pas besoin de faire un supplémentaire de classe qui implémente ActionListener -- je peux instancier un anonyme intérieur de la classe sans en faire réellement une classe à part.

Je n'utilise cette technique pour "rapide et sale", les tâches où le fait de créer une classe entière se sent inutile. Le fait d'avoir plusieurs anonymes classes internes qui font exactement la même chose devrait être remaniée à une classe, que ce soit un intérieur de classe ou dans une classe à part.

Anonyme intérieur de la classe est utilisé dans le scénario suivant:

1.)De remplacement(Sous-classement) ,Lors de la définition de la classe n'est pas utilisable, sauf cas actuel:

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

2.)Pour la mise en œuvre d'une interface,Lors de la mise en œuvre de l'interface est requise uniquement pour les cas en cours:

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

3.)Argument Défini Anonyme intérieure:

 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");
       } 
     });
   } 
 } 

Ils sont couramment utilisés comme détaillé forme de rappel.

Je suppose que vous pourriez dire qu'ils sont un avantage par rapport à ne pas en avoir, et d'avoir à créer une classe nommée à chaque fois, mais des concepts similaires sont mis en œuvre beaucoup mieux dans d'autres langues (comme des fermetures ou des blocs)

Voici un swing exemple

myButton.addActionListener(new ActionListener(){
    public void actionPerformed(ActionEvent e) {
        //do stuff here...
    }
});

Bien qu'il soit encore messily verbeux, c'est beaucoup mieux que de vous forcer à définir une classe nommée pour tous les jeter auditeur comme ceci (bien en fonction de la situation et de la réutilisation, qui peut encore être la meilleure approche)

Lignes directrices pour la Classe Anonyme.

1. Classe anonyme est déclarée et initialisée simultanément.

2. Anonyme classe doit étendre ou de mettre en œuvre une et une seule classe ou de l'interface resp.

3. Comme anonymouse classe n'a pas de nom, il peut être utilisé qu'une seule fois.

par exemple:

button.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent arg0) {
        //TODO Auto-generated method stub

    }
});

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();

C'est aussi l'un des exemple pour anonyme intérieure type à l'aide de fil

Un intérieur de la classe est associé à une instance de l'extérieur de la classe et il y a deux types: classe Locale et La classe anonyme. Une classe anonyme nous permet de déclarer et instancier une classe en même temps, rend donc le code concis. Nous les utilisons lorsque nous avons besoin d'un local de classe qu'une seule fois, car ils n'ont pas un nom.

Prenons l'exemple de doc où nous avons une Person classe:

public class Person {

    public enum Sex {
        MALE, FEMALE
    }

    String name;
    LocalDate birthday;
    Sex gender;
    String emailAddress;

    public int getAge() {
        //...
    }

    public void printPerson() {
        //...
    }
}

et nous avons une méthode pour imprimer les membres qui correspondent à des critères de recherche comme:

public static void printPersons(
    List<Person> roster, CheckPerson tester) {
    for (Person p : roster) {
        if (tester.test(p)) {
            p.printPerson();
        }
    }
}

où CheckPerson est une interface comme:

interface CheckPerson {
    boolean test(Person p);
}

Maintenant, nous pouvons faire usage de l'anonymat de la classe qui implémente cette interface pour spécifier des critères de recherche comme:

printPersons(
    roster,
    new CheckPerson() {
        public boolean test(Person p) {
            return p.getGender() == Person.Sex.MALE
                && p.getAge() >= 18
                && p.getAge() <= 25;
        }
    }
);

Ici, l'interface est très simple et la syntaxe de la classe anonyme semble difficile et incertaine.

Java 8 a introduit un terme Interface Fonctionnelle qui est une interface avec une seule méthode abstraite, par conséquent, nous pouvons dire CheckPerson est une interface fonctionnelle. Nous pouvons faire usage de Expression Lambda qui nous permet de passer de la fonction comme argument d'une méthode comme:

printPersons(
                roster,
                (Person p) -> p.getGender() == Person.Sex.MALE
                        && p.getAge() >= 18
                        && p.getAge() <= 25
        );

Nous pouvons utiliser une interface fonctionnelle Predicate en place de l'interface CheckPerson, ce qui contribuera à réduire la quantité de code nécessaire.

L'un des principaux de l'utilisation de l'anonymat de classes dans la classe de finalisation, qui a appelé finaliseur tuteur. Dans le monde Java à l'aide de la finaliser méthodes doit être évitée jusqu'à ce que vous avez vraiment besoin d'eux. Vous devez vous rappeler que lorsque vous remplacez la méthode finalize pour les sous-classes, vous devez toujours appeler super.finalize() ainsi, parce que la méthode finalize de la super-classe de ne pas invoquer automatiquement et vous pouvez avoir des problèmes avec des fuites de mémoire.

si l'on considère le fait mentionné ci-dessus, vous pouvez simplement utiliser l'anonyme classes comme:

public class HeavyClass{
    private final Object finalizerGuardian = new Object() {
        @Override
        protected void finalize() throws Throwable{
            //Finalize outer HeavyClass object
        }
    };
}

À l'aide de cette technique, vous soulagé de vous-même et vos autres développeurs de call super.finalize() sur chaque sous-classe de la HeavyClass qui doit finaliser la méthode.

Semble que personne n'a mentionné ici, mais vous pouvez également utiliser la classe anonyme pour tenir argument de type générique (qui normalement perdus en raison du type d'effacement):

public abstract class TypeHolder<T> {
    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;
    }
}

Si vous allez instancier cette classe de manière anonyme

TypeHolder<List<String>, Map<Ineger, Long>> holder = 
    new TypeHolder<List<String>, Map<Ineger, Long>>() {};

puis ces holder instance contient des non-erasured définition de type transmis.

D'utilisation

Ce qui est très pratique pour la construction de validateurs/deserializators. Aussi, vous pouvez créer une instance de type générique, de réflexion, de (donc si jamais vous voulais faire new T() dans paramétrées, tapez - vous êtes les bienvenus!).

Inconvénients/Limites

1. Vous devriez passer en paramètre générique explicitement. Ne pas le faire va conduire à de paramètre de type de perte
2. Chaque instanciation vous coûtera supplémentaire de classe doit être généré par le compilateur, ce qui conduit à classpath de la pollution/jar ballonnements

Un Anonyme Intérieur de la Classe est utilisé pour créer un objet qui ne sera jamais référencé à nouveau. Il n'a pas de nom et est déclarée et créés dans la même instruction.
Ce est utilisé lorsque vous utilisez normalement un objet variable. Vous remplacez la variable avec le new mot-clé, un appel à un constructeur et la définition de la classe à l'intérieur de { et }.

Lors de l'écriture d'un Programme multi-threadé en Java, il serait normalement ressembler à ceci

ThreadClass task = new ThreadClass();
Thread runner = new Thread(task);
runner.start();

La ThreadClass utilisé ici serait défini par l'utilisateur. Cette classe permettra de mettre en œuvre la Runnable interface qui est nécessaire pour créer des threads. Dans le ThreadClass la run() méthode (seule méthode dans Runnable) doit être mis en œuvre aussi bien.
Il est clair que se débarrasser de ThreadClass serait plus efficace et c'est exactement pourquoi les Anonymous Inner Classes existent.

Regardez le code suivant

Thread runner = new Thread(new Runnable() {
    public void run() {
        //Thread does it's work here
    }
});
runner.start();

Ce code remplace la référence faite à task dans le plus haut exemple. Plutôt que d'avoir une catégorie distincte, de l'Anonyme Intérieur de la Classe à l'intérieur de la Thread() constructeur renvoie un sans nom d'objet qui implémente l' Runnable interface et remplace la run() méthode. La méthode run() serait inclure des énoncés à l'intérieur que de faire le travail requis par le thread.

De répondre à la question de savoir si les Classes internes Anonymes est l'un des avantages de Java, je dois dire que je ne suis pas tout à fait sûr que je ne suis pas familier avec de nombreux langages de programmation en ce moment. Mais ce que je peux dire, c'est qu'il est certainement plus rapide et plus facile la méthode de codage.

Références: Sams Teach Yourself Java en 21 Jours Septième Édition