¿Cuál es el equivalente de la palabra clave C # 'var' en Java?

Un uso de la palabra clave var en C # es la declaración de tipo implícita. ¿Cuál es la sintaxis equivalente de Java para var ?

No hay ninguno. Por desgracia, debe escribir el nombre completo del tipo.

Editar: 7 años después de su publicación, varse agregó inferencia de tipo para variables locales (con ) en Java 10.

Editar: 6 años después de ser publicado, para recopilar algunos de los comentarios a continuación:

• La razón por la que C # tiene la varpalabra clave es porque es posible tener Tipos que no tienen nombre en .NET. P.ej:

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

  En este caso, sería imposible darle un tipo apropiado myData. Hace 6 años, esto era imposible en Java (todos los tipos tenían nombres, incluso si eran extremadamente verbosos y poco amables). No sé si esto ha cambiado mientras tanto.

• varNo es lo mismo que dynamic. varLas iables siguen siendo 100% de tipo estático Esto no compilará:

  var myString = "foo";
  myString = 3;
  

• varTambién es útil cuando el tipo es obvio por el contexto. Por ejemplo:

  var currentUser = User.GetCurrent();

  Puedo decir que en cualquier código del que soy responsable, currentUsertiene una Userclase o derivada. Obviamente, si su implementación de User.GetCurrentreturn an int, entonces quizás esto sea en detrimento de usted.

• Esto no tiene nada que ver var, pero si tiene jerarquías de herencia extrañas en las que sombrea métodos con otros métodos (por ejemplo new public void DoAThing()), no olvide que los métodos no virtuales se ven afectados por el Tipo con el que se convierten.

  No puedo imaginar un escenario del mundo real en el que esto sea indicativo de un buen diseño, pero esto puede no funcionar como se espera:

  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
  

  Como se indicó, los métodos virtuales no se ven afectados por esto.

• No, no hay una forma no torpe de inicializar a varsin una variable real.

  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

  En este caso, simplemente hazlo a la antigua usanza:

  object foo6;

Si agrega Lombok a su proyecto, puede usar su palabra clave val .

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

JEP - Propuesta de mejora de JDK

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

JEP 286: Inferencia de tipo variable local

Autor Brian Goetz

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

He preparado un complemento para IntelliJ que, en cierto modo, te ofrece varen Java. Es un truco, por lo que se aplican las exenciones de responsabilidad habituales, pero si usa IntelliJ para su desarrollo de Java y desea probarlo, está en https://bitbucket.org/balpha/varsity .

Con el lanzamiento de JDK 10 el 20 de marzo, Java ahora incluye un varnombre de tipo reservado (no una palabra clave, ver más abajo) como se especifica en JEP 286 . Para las variables locales, lo siguiente ahora es válido en Java 10 o superior:

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

El varnombre de tipo reservado en Java es casi idéntico a la varpalabra clave en C #, ya que ambos permiten la escritura implícita (consulte a continuación las diferencias importantes). varen Java solo se puede usar para la inferencia de tipo implícita en los siguientes contextos (como se enumera en JEP 286: Objetivos ):

• variables locales con inicializadores
• índices en el bucle for mejorado
• locales declarados en un bucle for tradicional

Por var lo tanto , no se puede usar para campos, tipos de retorno, nombres de clase o nombres de interfaz. Su fundamento es eliminar la necesidad de incluir nombres de tipo largos al declarar y definir variables locales, como se indica en JEP 286 (escrito por Brian Goetz):

Buscamos mejorar la experiencia del desarrollador al reducir la ceremonia asociada con la escritura de código Java, al tiempo que se mantiene el compromiso de Java con la seguridad de tipos estáticos, al permitir a los desarrolladores eludir la declaración de manifiesto a menudo innecesaria de los tipos de variables locales.

var Alcance en Java

Cabe señalar que varno es una palabra clave en Java, sino un nombre de tipo reservado. Como se cita de JEP 286:

El identificador var no es una palabra clave; en cambio es un nombre de tipo reservado. Esto significa que el código que usa var como variable, método o nombre del paquete no se verá afectado; el código que usa var como clase o nombre de interfaz se verá afectado (pero estos nombres son raros en la práctica, ya que violan las convenciones de nomenclatura habituales).

Tenga en cuenta que, dado que vares un nombre de tipo reservado y no una palabra clave, todavía se puede usar para nombres de paquetes, nombres de métodos y nombres de variables (junto con su nueva función de interferencia de tipos). Por ejemplo, los siguientes son todos ejemplos de usos válidos de varen Java:

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

Como se cita de JEP 286:

Este tratamiento se restringiría a variables locales con inicializadores, índices en el bucle for mejorado y locales declarados en un bucle for tradicional; no estaría disponible para formales de método, formales de constructor, tipos de retorno de método, campos, formales de captura o cualquier otro tipo de declaración de variable.

Diferencias entre varen Java y C

Esta es una diferencia notable entre varC # y Java que incluye lo siguiente: varse puede usar como nombre de tipo en C # pero no se puede usar como nombre de clase o nombre de interfaz en Java. De acuerdo con la documentación de C # (Variables locales escritas implícitamente) :

Si un tipo llamado varestá dentro del alcance, la varpalabra clave se resolverá con ese nombre de tipo y no se tratará como parte de una declaración de variable local tipada implícitamente.

La capacidad de usar varcomo nombre de tipo en C # crea cierta complejidad e introduce algunas reglas de resolución complejas, que varJava evita al deshabilitar varcomo nombre de clase o interfaz. Para obtener información sobre las complejidades de los varnombres de tipo en C #, consulte Restricciones que se aplican a las declaraciones de variables escritas implícitamente . Para obtener más información sobre la justificación de la decisión de determinación del alcance de `var en Java, consulte JEP 286: Opciones de determinación del alcance .

Se admitirá en JDK 10. Incluso es posible verlo en acción en la compilación de acceso temprano .

El JEP 286 :

Mejore el lenguaje Java para extender la inferencia de tipos a declaraciones de variables locales con inicializadores.

Entonces ahora en lugar de escribir:

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

Usted escribe:

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

Notas:

• varahora es un nombre de tipo reservado
• ¡Java sigue comprometido con la escritura estática!
• Solo se puede usar en declaraciones de variables locales

Si desea probarlo sin instalar Java en su sistema local, creé una imagen Docker con JDK 10 instalado:

$ 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 ==> []

Una solución simple (suponiendo que esté usando un IDE decente) es simplemente escribir 'int' en todas partes y luego configurarlo para usted.

De hecho, acabo de agregar una clase llamada 'var' para no tener que escribir algo diferente.

El código todavía es demasiado detallado, ¡pero al menos no tiene que escribirlo!

Puedes echar un vistazo a Kotlin por JetBrains, pero es val. no var.

Java 10 obtuvo inferencia de tipo de variable local, por lo que ahora tiene lo varque es más o menos equivalente a C # one (que yo sepa).

También puede inferir tipos no denotables (tipos que el programador no pudo nombrar en ese lugar; aunque los tipos que no son denotables son diferentes). Vea, por ejemplo, Trucos con varclases anónimas (que nunca debe usar en el trabajo) .

La única diferencia que pude encontrar es que en C #,

Si un tipo llamado var está dentro del alcance, la palabra clave var se resolverá con ese nombre de tipo y no se tratará como parte de una declaración de variable local tipada implícitamente.

En Java 10 varno es un nombre de tipo legal.

A partir del 10 de Java, el equivalente es ... var.

Sé que esto es más antiguo, pero ¿por qué no crear una clase var y crear constructores con diferentes tipos y dependiendo de qué constructores se invoque, obtienes var con diferentes tipos. Incluso podría incorporar métodos para convertir un tipo a otro.

Lombokadmite var pero todavía está clasificado como experimental:

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

Aquí hay una trampa que debes evitar cuando tratas de usarlo IntelliJ IDEA. Parece funcionar como se esperaba, aunque incluye la finalización automática y todo. Hasta que haya una solución "no hacky" (por ejemplo, debido a JEP 286: Inferencia de tipo variable local ), esta podría ser su mejor opción en este momento.

Tenga en cuenta que también vales compatible Lomboksin modificar o crear a lombok.config.

Puede, en Java 10, pero solo para variables locales , es decir,

Usted puede,

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

Pero no puedo

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

Echa un vistazo a las especificaciones para más información.

En general, puede usar la clase Object para cualquier tipo, ¡pero debe hacer la conversión de tipos más tarde!

p.ej:-

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

Esta característica ahora está disponible en Java SE 10. La var estática y segura de tipos finalmente ha llegado al mundo java :)

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