Qu'est-ce qu'une fonction de citoyen de première classe?

un langage qui considère les procédures comme" de première classe " permet de transmettre des fonctions comme n'importe quelle autre valeur .

les langues comme Java 7 (et plus tôt) et C "kind of" ont cette capacité: C permet aux pointeurs de fonction d'être transmis, mais vous ne pouvez pas dynamiquement définir une fonction dans ces langues et passer soudainement que quelque part ailleurs. Java avant la version 8 peut simuler cela dans une certaine mesure avec des classes anonymes, mais il n'a pas techniquement de fonctions de première classe.

d'autre part, C++, D, C#, Visual Basic .NET, Java 8+, et les langages fonctionnels (comme Scheme et Haskell) do vous permettent de passer des fonctions comme des variables. Par exemple, le code ci-dessous retourne une fonction qui ajoute addend à son entrée:

écrit en D:

int delegate(int) makeAdder(int addend) //Returns a function
{
    return delegate int(int x) //Long way
    {
        return x + addend; //Notice that addend came from _outside_ the function
    };

    return (int x) { return x + addend; }; //Short way

    return x => addend + x; //Super-short way, introduced in D 2.058
}

écrit en C#:

Func<int, int> MakeAdder(int addend) //Returns a function
{
    return delegate(int x) //The long way. Note: Return type is implicitly 'int'
    {
        return x + addend;
    };

    return x => x + addend; //Short way: x "goes to" (x + addend); inferred types
}

écrit en C++:

#include <functional>

std::function<int(int)> make_adder(int addend)
{
    return [=](int x)
    {
        return addend + x;
    };
}

écrit en Scala:

def makeAdder(addend: Int) = (x: Int) => addend + x

écrit en Python:

def make_adder(addend):
    def f(x):
        return addend + x
    return f
    # or...
    return lambda x: addend + x

écrit en Erlang:

make_adder(Addend) ->
    fun(X) -> Addend + X end.

écrit en JavaScript:

function makeAdder(addend) {
    return function(x) {
        return addend + x;
    };
}

écrit en JavaScript (ES2015 fonction de la syntaxe de la flèche):

const makeAdder = addend => x => addend + x;

écrit dans le schéma:

(define (makeAdder addend)
  (lambda (x)
    (+ x addend)))

écrit dans Haskell:

makeAdder :: Int -> (Int -> Int)
makeAdder addend = \x -> addend + x

écrit dans Visual Basic 2008:

Function MakeAdder(addend As Integer) As Func(Of Integer, Integer)
    Return Function(x) (x + addend)
End Function

écrit en Swift (à la fois verbeux et à main courte):

func makeAdder(append: Int) -> (x: Int) -> Int {
    return { (x: Int) -> Int in
        return x + append
    };
}

func makeAdder(append: Int) -> (Int) -> Int {
    return {"1519110920" + append};
}

(soit dit en passant, une" lambda " est juste une fonction sans nom. Lambdas ne sont pris en charge que dans les langues qui supportent des fonctions de première classe.)

une fonction de première classe peut être transmise. Un exemple typique est la fonction map. Voici un exemple dans Scala qui place les éléments d'une liste:

val square = (x:Int) => x*x

val squaredList = List(1,2,3,4).map(square _)
//--> List(1,4,9,16)

la fonction carrée est ici un argument à la méthode map, qui l'applique à chaque élément. Si vous voulez faire quelque chose comme ça en Java, vous devez utiliser une méthode encapsulée dans une classe, quelque chose comme:

interface F<A,B>{ B apply(A a); }

static <A,B> List<B> map(List<A> list, F<A,B> f) {
  List<B> result = new ArrayList<B>();
  for(A a:list) result.add(f.apply(a));
  return result;   
}

//we have to "wrap" the squaring operation in a class in order to make it a function
F<Integer,Integer> square = new F<Integer,Integer>(){ 
  Integer apply(Integer a) { return a*a; }
}

List<Integer> ints = Arrays.<Integer>asList(1,2,3,4);
List<Integer> squares = map(ints, square);

en regardant ceci vous pouvez voir que vous pouvez obtenir la même tâche en quelque sorte fait en Java, mais avec plus de frais généraux, et sans la prise en charge "native" par le langage, mais en utilisant une solution de contournement (classes wrapper). Donc Java ne supporte pas les fonctions de première classe, mais peut les "simuler".

si tout va bien Java 8 supportera les fonctions de première classe. Si vous voulez avoir un peu de soutien pour ce maintenant , regardez http://functionaljava.org / ou http://functionalj.sourceforge.net/ , ou regardez la langue Scala.

la définition Wikipédia est assez bonne-c'est une fonction qui peut être transmise comme n'importe quelle autre donnée. Java ne pas les supporte. Les plus proches sont les objets Runnable et Callable .

Non, vous ne pouvez pas attribuer une méthode à une variable ou la passer comme argument à une autre méthode par exemple.

au lieu de cela, vous pouvez utiliser des interfaces pour envelopper le comportement prévu, ou la réflexion pour reify méthodes.

fonctions sont citoyen de première classe signifie que vous pouvez passer fonction n'importe où comme si c'est une variable.

De Scala

def isOdd(in: Int) = in % 2 == 1
val n = (1 to 10).toList
n.filter(isOdd)

see here: isOdd is a function. passed as if it's a variale.

Objects sont des citoyens de première classe en Java. un citoyen de première classe est celui qui peut passer n'importe où. le parallèle est d'un citoyen de première classe du pays sont autorisés presque partout.

Lire:

• quand une caractéristique est-elle considérée comme un "citoyen de première classe" dans un langage/une plateforme de programmation?
• Premier-objet de classe
• de Première classe de la fonction

considérons l'exemple du paradigme de programmation fonctionnelle dans lequel les fonctions sont les citoyens de première classe. Quand nous disons fonctions sont les citoyens de première classe, nous pouvons faire les choses suivantes avec la fonction...

• la fonction peut être affectée à une variable
• fonction peut être stockée dans une structure de données
• fonction peut être transmise comme argument à d'autres fonctions""
• La fonction peut être retournée à partir des fonctions

dans les langages de programmation fonctionnelle, il est possible de faire les choses mentionnées ci-dessus.

maintenant, essayons de répondre à la question, si java supporte les fonctions de citoyens de première classe (ou non).

en java, les méthodes sont équivalentes aux fonctions. Il n'est pas possible à l'une de ces méthodes. Mais tout ce qui précède est possible avec les objets java. Si, objets sont les premiers citoyens de classe en java. Certes, java8 supporte le passage de méthodes (comportement de méthode, pour être précis) à d'autres méthodes utilisant des interfaces fonctionnelles et des expressions lambda. Mais cela ne signifie pas que java fonctionne comme des citoyens de première classe.

la capacité de faire au-dessus de choses telles que le transfert de fonctions, le retour de fonctions à partir de fonctions est très puissant et utile. C'est parce qu'il nous permet de passer à travers le comportement non seulement les données.