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

Une utilisation du mot clé var en C # est la déclaration de type implicite. Quelle est la syntaxe équivalente Java pour var ?

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

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

Edit: 6 ans après avoir été posté, pour recueillir certains des commentaires ci-dessous:

• La raison pour laquelle C # a le varmot-clé est qu'il est possible d'avoir des types sans nom dans .NET. Par exemple:

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

  Dans ce cas, il serait impossible de donner un type approprié à myData. Il y a 6 ans, cela était impossible en Java (tous les types avaient des noms, même s'ils étaient extrêmement bavards et peu bavards). Je ne sais pas si cela a changé entre-temps.

• varn'est pas le même que dynamic. varLes variables sont toujours 100% typées statiquement. Cela ne compilera pas:

  var myString = "foo";
  myString = 3;

• varest également utile lorsque le type est évident dans le contexte. Par exemple:

  var currentUser = User.GetCurrent();

  Je peux dire que dans n'importe quel code dont je suis responsable, il currentUsercontient une Userclasse ou une classe dérivée. Évidemment, si votre implémentation de User.GetCurrentreturn retourne un int, alors c'est peut-être un inconvénient pour vous.

• Cela n'a rien à voir avec var, mais si vous avez d'étranges hiérarchies d'héritage où vous masquez des méthodes avec d'autres méthodes (par exemple new public void DoAThing()), n'oubliez pas que les méthodes non virtuelles sont affectées par le type sous lequel elles sont converties.

  Je ne peux pas imaginer un scénario du monde réel où cela indique 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 ne sont pas affectées par cela.

• Non, il n'y a aucun moyen non maladroit d'initialiser un varsans 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, faites-le à l'ancienne:

  object foo6;

Si vous ajoutez Lombok à votre projet, vous pouvez utiliser son mot-clé val .

http://projectlombok.org/features/val.html

JEP - Proposition d'amélioration du JDK

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

JEP 286: Inférence de type variable locale

Auteur Brian Goetz

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

J'ai concocté un plugin pour IntelliJ qui - en quelque sorte - vous donne varen Java. C'est un hack, donc les clauses de non-responsabilité habituelles s'appliquent, mais si vous utilisez IntelliJ pour votre développement Java et que vous voulez l'essayer, c'est sur https://bitbucket.org/balpha/varsity .

Avec la sortie de JDK 10 le 20 mars, Java inclut désormais un varnom de type réservé (pas un mot-clé - voir ci-dessous) comme spécifié dans JEP 286 . Pour les variables locales, ce qui suit est maintenant valide dans Java 10 ou supérieur:

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

Le varnom de type réservé en Java est presque identique au varmot - clé en C # dans la mesure où les deux permettent une saisie implicite (voir ci-dessous pour les différences importantes). varen Java ne peut être utilisé pour l'inférence de type implicite que dans les contextes suivants (comme énuméré dans JEP 286: Objectifs ):

• variables locales avec initialiseurs
• index dans la boucle for améliorée
• les habitants déclarés dans une boucle for traditionnelle

Par conséquent, 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é d'inclure des noms de type longs lors de la déclaration et de la définition de variables locales, comme indiqué dans JEP 286 (rédigé par Brian Goetz):

Nous cherchons à améliorer l'expérience des développeurs en réduisant la cérémonie associée à l'écriture de code Java, tout en maintenant l'engagement de Java envers la sécurité des types statiques, en permettant aux développeurs d'éluder la déclaration manifeste souvent inutile des types de variables locales.

var Portée en Java

Il convient de noter qu'il varne s'agit pas d'un mot clé en Java, mais plutôt d'un nom de type réservé. Comme cité dans JEP 286:

L'identifiant var n'est pas un mot-clé; il s'agit plutôt d'un nom de type réservé. Cela signifie que le code qui utilise var comme variable, méthode ou nom de package ne sera pas affecté; le code qui utilise var comme nom de classe ou d'interface sera affecté (mais ces noms sont rares dans la pratique, car ils violent les conventions de dénomination habituelles).

Notez que puisqu'il vars'agit d'un nom de type réservé et non d'un mot-clé, il peut toujours être utilisé pour les noms de package, les noms de méthode et les noms de variable (avec son nouveau rôle d'interférence de type). Par exemple, ce qui suit sont tous des exemples d'utilisations valides de varJava:

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

Comme cité dans JEP 286:

Ce traitement serait limité aux variables locales avec des initialiseurs, des index dans la boucle for améliorée et des sections locales déclarées dans une boucle for traditionnelle; il ne serait pas disponible pour les formals de méthode, les formals de constructeur, les types de retour de méthode, les champs, les formals catch ou tout autre type de déclaration de variable.

Différences entre varJava et C

Il s'agit d'une différence notable entre varC # et Java, notamment: varpeut être utilisé comme nom de type en C # mais ne peut pas être utilisé comme nom de classe ou nom d'interface en Java. Selon la documentation C # (Variables locales implicitement typées) :

Si un type nommé varest dans la portée, le varmot - clé se résoudra en ce nom de type et ne sera pas traité comme faisant partie d'une déclaration de variable locale implicitement typée.

La possibilité d'utiliser varcomme nom de type en C # crée une certaine complexité et introduit des règles de résolution complexes, qui sont évitées par varen Java en interdisant en vartant que nom de classe ou d'interface. Pour plus d'informations sur la complexité des varnoms de type en C #, consultez Restrictions s'appliquent aux déclarations de variable implicitement typées . Pour plus d'informations sur la justification de la décision de délimitation de `var en Java, voir JEP 286: Choix de délimitation .

Il sera pris en charge dans JDK 10. Il est même possible de le voir en action dans la version à accès anticipé .

Le JEP 286 :

Améliorez le langage Java pour étendre l'inférence de type aux déclarations de variables locales avec des initialiseurs.

Alors maintenant, au lieu d'écrire:

List<> list = new ArrayList<String>();
Stream<> stream = myStream();

Vous écrivez:

var list = new ArrayList<String>();
var stream = myStream();

Remarques:

• varest maintenant un nom de type réservé
• Java est toujours attaché à la frappe statique!
• Il ne peut être utilisé que dans les déclarations de variables locales

Si vous voulez l'essayer sans installer Java sur votre système local, j'ai créé une image Docker avec JDK 10 installé dessus:

$ docker run -it marounbassam/ubuntu-java10 bash
root@299d86f1c39a:/# jdk-10/bin/jshell
Mar 30, 2018 9:07:07 PM java.util.prefs.FileSystemPreferences$1 run
INFO: Created user preferences directory.
|  Welcome to JShell -- Version 10
|  For an introduction type: /help intro

jshell> var list = new ArrayList<String>();
list ==> []

Une solution simple (en supposant que vous utilisez un IDE décent) consiste simplement à taper «int» partout, puis à le définir pour vous.

En fait, je viens d'ajouter 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 besoin de le taper!

Vous pouvez jeter un œil à Kotlin by JetBrains, mais c'est val. pas var.

Java 10 a obtenu une inférence de type de variable locale, alors maintenant il a varce qui est à peu près équivalent à celui de C # (pour autant que je sache).

Il peut également déduire des types non dénotables (types qui ne peuvent pas être nommés à cet endroit par le programmeur; bien que les types non dénotables soient différents). Voir par exemple les astuces avec varet les classes anonymes (que vous ne devriez jamais utiliser au travail) .

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

Si un type nommé var est dans la portée, le mot clé var se résoudra en ce nom de type et ne sera pas traité comme faisant partie d'une déclaration de variable locale implicitement typée.

En Java 10 varn'est pas un nom de type légal.

A partir de Java 10, l'équivalent est ... var.

Je sais que c'est plus ancien mais pourquoi ne pas créer une classe var et créer des constructeurs avec différents types et en fonction des constructeurs invoqués, vous obtenez var avec un type différent. Vous pouvez même intégrer des méthodes pour convertir un type en un autre.

Lombokprend en charge var mais il est toujours classé comme expérimental:

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

Voici un piège à éviter lorsque vous essayez de l'utiliser dans IntelliJ IDEA. Il semble fonctionner comme prévu, y compris l'achèvement automatique et tout. Jusqu'à ce qu'il existe une solution "non hacky" (par exemple en raison de JEP 286: Inférence de type variable locale ), cela pourrait être votre meilleur pari en ce moment.

Notez que la valprise en charge par Lombokainsi sans modifier ou créer un fichier lombok.config.

Vous pouvez, dans Java 10, mais uniquement pour les variables locales , ce qui signifie,

Vous pouvez,

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

Mais je ne peux pas,

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

Consultez les spécifications pour plus d'informations.

En général, vous pouvez utiliser la classe Object pour n'importe quel type, mais vous devez effectuer une conversion de type plus tard!

par exemple:-

Object object = 12;
    Object object1 = "Aditya";
    Object object2 = 12.12;

    System.out.println(Integer.parseInt(object.toString()) + 2);

    System.out.println(object1.toString() + " Kumar");
    System.out.println(Double.parseDouble(object2.toString()) + 2.12);

Cette fonctionnalité est désormais disponible dans Java SE 10. Le var statique, sans danger pour les types, est enfin entré dans le monde java :)

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