Comment puis-je écrire une fonction anonyme en Java?

voici un exemple de classe interne anonyme.

System.out.println(new Object() {
    @Override public String toString() {
        return "Hello world!";
    }
}); // prints "Hello world!"

ce n'est pas très utile comme ça, mais ça montre comment créer une instance d'une classe interne anonyme que extends Object et @Override sa méthode toString() .

voir aussi

• JLS 15.9.5 déclarations de classe anonymes

---

anonyme les classes internes sont très pratiques lorsque vous avez besoin de mettre en œuvre un interface qui peut ne pas être très réutilisable (et donc pas la peine de refactoring à sa propre classe nommée). Un exemple instructif est l'utilisation d'une coutume java.util.Comparator<T> pour le tri.

voici un exemple de la façon dont vous pouvez trier un String[] basé sur String.length() .

import java.util.*;
//...

String[] arr = { "xxx", "cd", "ab", "z" };
Arrays.sort(arr, new Comparator<String>() {
    @Override public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }           
});
System.out.println(Arrays.toString(arr));
// prints "[z, cd, ab, xxx]"

Notez le truc de comparaison par soustraction utilisé ici. Il faut dire que cette la technique est cassée en général: elle n'est applicable que si vous pouvez garantir qu'elle ne débordera pas (c'est le cas des longueurs String ).

voir aussi

• Java Integer: qu'est-ce qu'une comparaison ou une soustraction plus rapide?
  • comparaison par soustraction est cassé en général
• créer un Le Hash trié en Java avec un comparateur personnalisé
• comment les classes anonymes (internes) sont-elles utilisées en Java?

avec l'introduction de l'expression lambda dans Java 8, Vous pouvez maintenant avoir des méthodes anonymes.

dire que j'ai une classe Alpha et je veux filtrer Alpha s sur une condition spécifique. Pour ce faire, vous pouvez utiliser un Predicate<Alpha> . C'est une interface fonctionnelle qui possède une méthode test qui accepte un Alpha et renvoie un boolean .

en supposant que la méthode de filtration possède cette signature:

List<Alpha> filter(Predicate<Alpha> filterPredicate)

avec l'ancienne solution de classe anonyme vous auriez besoin de quelque chose comme:

filter(new Predicate<Alpha>() {
   boolean test(Alpha alpha) {
      return alpha.centauri > 1;
   }
});

avec le Java 8 lambdas vous pouvez faire:

filter(alpha -> alpha.centauri > 1);

pour plus d'informations voir le tutoriel Lambda Expressions

classes internes anonymes implémenter ou étendre l'interface d'un type existant a été fait dans d'autres réponses, bien qu'il soit intéressant de noter que plusieurs méthodes peuvent être implémentées (souvent avec des événements de style Javabéen, par exemple).

une caractéristique peu reconnue est que même si les classes intérieures anonymes n'ont pas de nom, elles ont un type. Les nouvelles méthodes peuvent être ajoutées à l'interface. Ces méthodes ne peuvent être invoquées que dans des cas limités. Principalement directement sur l'expression new elle-même et dans la classe (y compris les initialisateurs d'instance). Il pourrait confondre les débutants, mais il peut être "intéressant" pour la récursivité.

private static String pretty(Node node) {
    return "Node: " + new Object() {
        String print(Node cur) {
            return cur.isTerminal() ?
                cur.name() :
                ("("+print(cur.left())+":"+print(cur.right())+")");
        }
    }.print(node);
}

(Je l'ai écrit à l'origine en utilisant node plutôt que cur dans la méthode print . DITES NON à la capture "implicitement final " locaux? )

Oui si vous utilisez la dernière version de java qui est la version 8. Java8 permet de définir des fonctions anonymes qui étaient impossibles dans les versions précédentes.

permet de prendre exemple de java docs pour savoir comment nous pouvons déclarer les fonctions anonymes, les classes

L'exemple suivant, HelloWorldAnonymousClasses, utilise anonymous classes dans les instructions d'initialisation des variables locales réunion française et réunion espagnole, mais utilise une classe locale pour la initialisation de la variable englishGreeting:

public class HelloWorldAnonymousClasses {

    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }

    public void sayHello() {

        class EnglishGreeting implements HelloWorld {
            String name = "world";
            public void greet() {
                greetSomeone("world");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }

        HelloWorld englishGreeting = new EnglishGreeting();

        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            public void greet() {
                greetSomeone("tout le monde");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };

        HelloWorld spanishGreeting = new HelloWorld() {
            String name = "mundo";
            public void greet() {
                greetSomeone("mundo");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hola, " + name);
            }
        };
        englishGreeting.greet();
        frenchGreeting.greetSomeone("Fred");
        spanishGreeting.greet();
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp =
            new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }            
}

syntaxe des Classes anonymes

"151930920 Considérer" l'instanciation de la frenchGreeting objet:

    HelloWorld frenchGreeting = new HelloWorld() {
        String name = "tout le monde";
        public void greet() {
            greetSomeone("tout le monde");
        }
        public void greetSomeone(String someone) {
            name = someone;
            System.out.println("Salut " + name);
        }
    };

l'expression de classe anonyme se compose de ce qui suit:

• Le new opérateur

• le nom d'une interface à implémenter ou d'une classe à étendre. Dans ce exemple, la classe anonymous implémente l'interface HelloWorld.

• parenthèses qui contiennent les arguments à un constructeur, tout comme un expression de création de classe normale. Remarque: Lorsque vous mettez en place une interface, il n'y a pas de constructeur, si vous utilisez une paire de vide entre parenthèses, comme dans cet exemple.

• un corps, qui est un corps de déclaration de classe. Plus précisément, dans le les déclarations concernant le corps, la méthode sont autorisées, mais pas les déclarations.