Quel est l'équivalent du C# 'var' mot-clé dans Java?

Il n'y a aucun. Hélas, vous devez taper le nom complet du type.

Edit: 7 ans après sa mise en place, l'inférence de type pour les variables locales (avec var) a été ajoutée dans Java 10.

Edit: 6 ans après sa mise en place, afin de recueillir certains des commentaires ci-dessous:

• La raison C# a la var mot-clé est parce que c'est possible d'avoir des Types qui n'ont pas de nom .NET. Par exemple:

  var myData = new { a = 1, b = "2" };

  Dans ce cas, il serait impossible de donner un bon type de myData. Il y a 6 ans, c'était impossible en Java (tous les Types avaient des noms, même s'ils ont été extrêmement détaillé et unweildy). Je ne sais pas si cela a changé dans le temps de le dire.

• var n'est pas le même que dynamic. varvariables sont toujours 100% statiquement typé. Ce ne sera pas compiler:

  var myString = "foo";
  myString = 3;

• var est également utile lorsque le type est évident à partir du contexte. Par exemple:

  var currentUser = User.GetCurrent();

  Je peux dire que dans le code que je suis responsable, currentUser a un User ou de la classe dérivée en elle. Évidemment, si votre mise en œuvre de User.GetCurrent retourner un int, alors c'est peut-être un détriment pour vous.

• Cela n'a rien à voir avec var, mais si vous avez bizarre hiérarchies d'héritage où vous l'ombre des méthodes avec d'autres méthodes (par exemple new public void DoAThing()), n'oubliez pas que les non-méthodes virtuelles sont affectés par le Type qu'ils sont exprimés comme.

  Je ne peux pas imaginer un monde réel scénario où cela est révélateur d'une bonne conception, mais cela peut ne pas fonctionner comme prévu:

  class Foo {
      public void Non() {}
      public virtual void Virt() {}
  }
  
  class Bar : Foo {
      public new void Non() {}
      public override void Virt() {}
  }
  
  class Baz {
      public static Foo GetFoo() {
          return new Bar();
      }
  }
  
  var foo = Baz.GetFoo();
  foo.Non();  //<- Foo.Non, not Bar.Non
  foo.Virt(); //<- Bar.Virt
  
  var bar = (Bar)foo;
  bar.Non();  //<- Bar.Non, not Foo.Non
  bar.Virt(); //<- Still Bar.Virt

  Comme indiqué, les méthodes virtuelles sont pas affectés par cette.

• Non, il n'y a pas de non-être maladroit pour initialiser un var sans une variable réelle.

  var foo1 = "bar";        //good
  var foo2;                //bad, what type?
  var foo3 = null;         //bad, null doesn't have a type
  var foo4 = default(var); //what?
  var foo5 = (object)null; //legal, but go home, you're drunk

  Dans ce cas, il suffit de le faire à l'ancienne:

  object foo6;

JEP - JDK mise en valeur de Proposition

http://openjdk.java.net/jeps/286

JEP 286: Local Variable de l'Inférence de Type

Auteur Brian Goetz

//Goals:
var list = new ArrayList<String>();  //infers ArrayList<String>
var stream = list.stream();          //infers Stream<String>

Avec la version de JDK 10, le 20 Mars, Java inclut maintenant un var réservés nom de type (pas un mot-clé—voir ci-dessous), comme spécifié dans JEP 286. Pour les variables locales, la suite est maintenant valide en Java 10 ou plus:

var map = new HashMap<String, Integer>();

La var réservés nom de type de Java est presque identique à la var mot-clé en C# dans qui permettent à la fois pour le typage implicite (voir ci-dessous les différences). var en Java peut être utilisé uniquement pour les implicites de l'inférence de type dans les contextes suivants (tels qu'énumérés dans JEP 286: Objectifs):

• variables locales avec les initialiseurs
• index dans le renforcement de la boucle for
• habitants a déclaré dans un cadre traditionnel pour boucle

Donc var ne peut pas être utilisé pour les champs, les types de retour, les noms de classe, ou les noms d'interface. Sa raison d'être est de supprimer la nécessité, y compris pour les longs noms de type lors de la déclaration et la définition des variables locales, comme indiqué dans JEP 286 (rédigé par Brian Goetz):

Nous cherchons à améliorer l'expérience du développeur par la réduction de la cérémonie
associées à l'écriture de code Java, tout en maintenant l'engagement de Java
de type statique de la sécurité, en permettant aux développeurs d'éluder l'
souvent inutiles manifeste de déclaration de variable locale types.

var La portée dans Java

Il convient de noter que var n'est pas un mot-clé en Java, mais plutôt réservé un nom de type. Comme cité de PEC 286:

L'identificateur de la var n'est pas un mot-clé; c'est plutôt un type réservés
nom. Cela signifie que le code qui utilise la var comme une variable, une méthode ou une
nom du paquet ne sera pas affectée; le code qui utilise la var en tant que classe ou
nom de l'interface sera affecté (mais ces noms sont rares dans la pratique,
depuis ils violent d'habitude conventions de nommage).

Noter que depuis var réservé de nom de type et pas un mot clé, il peut encore être utilisé pour les noms de paquets, les noms de méthode, et les noms de variables (avec son nouveau type d'interférence rôle). Par exemple, les suivants sont tous des exemples d'utilisations valides de var en Java:

var i = 0;
var var = 1;
for (var i = 0; i < 10; i++) { /* ... */ }
public int var() { return 0; }
package var;

Comme cité de PEC 286:

Ce traitement serait restreint aux variables locales avec
les initialiseurs, les index dans le renforcement de la boucle for, et les habitants déclarés dans
traditionnel pour la boucle; il ne serait pas disponible pour la méthode formals,
constructeur formals, la méthode des types de retour, les champs, les captures formals, ou
tout autre type de déclaration de variable.

Différences Entre var en Java & C#

C'est une différence notable entre var en C# et Java sont les suivants: var peut être utilisé comme un nom de type en C#, mais ne peut pas être utilisé comme un nom de classe ou le nom de l'interface en Java. Selon le C# documentation (Implicitement Tapé Variables Locales):

Si un type nommé var est dans la portée, puis le var mot-clé sera résolu
ce type de nom et ne seront pas traités dans le cadre d'une tapée implicitement
déclaration de variable locale.

La possibilité d'utiliser var comme un nom de type en C# crée une certaine complexité et introduit une sorte de complexe de résolution de règles, qui sont évités par var en Java en interdisant var comme une classe ou une interface de nom. Pour plus d'informations sur les complexités de var noms de type en C#, voir Des Restrictions s'appliquent aux implicitement tapé les déclarations de variables. Pour plus d'informations sur la justification de la détermination de la portée de la décision de la var en Java, voir JEP 286: Portée Choix.

Une solution simple (en supposant que vous utilisez un décent IDE) est de type 'int' partout et obtenir ensuite à définir le type pour vous.

En fait je viens de rajouter une classe appelée 'var' donc je n'ai pas à taper quelque chose de différent.

Le code est encore trop verbeux, mais au moins vous n'avez pas à taper!

Java 10 obtenir la variable locale de l'inférence de type, alors maintenant, il a var qui est à peu près équivalent à la C# (aussi loin que je suis au courant).

Il peut également en déduire la non-denotable types (types qui ne pouvait pas être nommé dans cet endroit par le programmeur; si qui types sont non-denotable est différent, par exemple, Java n'est pas un équivalent en C# les types anonymes).

La seule différence que j'ai pu trouver est qu'en C#,

Si un type nommé var est dans la portée, puis le mot-clé var permettra de résoudre à ce type de nom et ne seront pas traités dans le cadre d'une tapée implicitement déclaration de variable locale.

En Java 10 var n'est pas un nom de type.

Lombok prend en charge var mais il est toujours classé comme expérimentale:

import lombok.experimental.var;

var number = 1; //Inferred type: int
number = 2; //Legal reassign since var is not final
number = "Hi"; //Compilation error since a string cannot be assigned to an int variable
System.out.println(number);

Ici est un piège à éviter lorsque vous essayez de l'utiliser dans IntelliJ IDEA. Il semble fonctionner comme prévu même si, y compris l'auto-complétion et tout et tout. Jusqu'à il y a un "non-hacky" solution (par exemple en raison de JEP 286: Local Variable de l'Inférence de Type), cela pourrait être votre meilleur pari droit maintenant.

Noter que val est support par Lombok ainsi sans modification ou la création d'un lombok.config.

Vous pouvez, en Java 10, mais seulement pour Local variables, de sens, de

Vous pouvez,

var anum = 10; var aString = "Var";

Mais ne peut pas,

var anull = null; //Since the type can't be inferred in this case

Découvrez la spec pour plus d'info.

Cette fonctionnalité est désormais disponible en Java SE 10. La statique, type-safe var a finalement fait dans le monde java 🙂

source: https://www.oracle.com/corporate/pressrelease/Java-10-032018.html