Qual é o equivalente da palavra-chave C # 'var' em Java?

Um uso da palavra-chave var em C # é uma declaração implícita de tipo. Qual é a sintaxe equivalente a Java para var ?

Não há nenhum. Infelizmente, você precisa digitar o nome completo do tipo.

Edit: 7 anos após o lançamento, a inferência de tipo para variáveis ​​locais (com var) foi adicionada no Java 10.

Editar: 6 anos após a publicação, para coletar alguns dos comentários abaixo:

• O motivo pelo qual C # tem a varpalavra-chave é que é possível ter tipos que não têm nome no .NET. Por exemplo:

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

  Nesse caso, seria impossível atribuir um tipo adequado myData. Há 6 anos, isso era impossível em Java (todos os tipos tinham nomes, mesmo que fossem extremamente detalhados e pouco controlados). Não sei se isso mudou nesse meio tempo.

• varnão é o mesmo que dynamic. varOs dados ainda são 100% digitados estaticamente. Isso não será compilado:

  var myString = "foo";
  myString = 3;

• vartambém é útil quando o tipo é óbvio no contexto. Por exemplo:

  var currentUser = User.GetCurrent();

  Posso dizer que em qualquer código pelo qual sou responsável, currentUserhá uma Userclasse ou classe derivada. Obviamente, se sua implementação de User.GetCurrentretornar um int, talvez isso seja um prejuízo para você.

• Isso não tem nada a ver com isso var, mas se você tiver hierarquias de herança estranhas nas quais sombreia métodos com outros métodos (por exemplo new public void DoAThing()), não esqueça que métodos não virtuais são afetados pelo tipo em que são convertidos.

  Não consigo imaginar um cenário do mundo real em que isso seja indicativo de bom design, mas isso pode não funcionar como o esperado:

  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 indicado, os métodos virtuais não são afetados por isso.

• Não, não há uma maneira não desajeitada de inicializar a varsem uma variável 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

  Nesse caso, faça da maneira antiga:

  object foo6;

Se você adicionar o Lombok ao seu projeto, poderá usar a palavra-chave val .

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

JEP - Proposta de aprimoramento do JDK

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

JEP 286: Inferência de tipo variável local

Autor Brian Goetz

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

Eu criei um plugin para o IntelliJ que, de certa forma, fornece a você varem Java. É um hack, então as isenções de responsabilidade usuais se aplicam, mas se você usa o IntelliJ para o seu desenvolvimento Java e deseja experimentá-lo, é em https://bitbucket.org/balpha/varsity .

Com o lançamento do JDK 10 em 20 de março, o Java agora inclui um varnome de tipo reservado (não uma palavra-chave - veja abaixo), conforme especificado no JEP 286 . Para variáveis ​​locais, o seguinte agora é válido no Java 10 ou superior:

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

O varnome do tipo reservado em Java é quase idêntico à varpalavra - chave em C #, pois ambos permitem digitação implícita (veja abaixo diferenças importantes). varem Java pode ser usado apenas para inferência implícita de tipo nos seguintes contextos (conforme enumerado no JEP 286: Objetivos ):

• variáveis ​​locais com inicializadores
• índices no loop for aprimorado
• locais declarados em um loop for tradicional

Portanto, var não pode ser usado para campos, tipos de retorno, nomes de classe ou nomes de interface. Sua lógica é remover a necessidade de incluir nomes de tipo longos ao declarar e definir variáveis ​​locais, conforme declarado no JEP 286 (de autoria de Brian Goetz):

Procuramos melhorar a experiência do desenvolvedor, reduzindo a cerimônia associada à escrita do código Java, mantendo o compromisso do Java com a segurança de tipo estático, permitindo que os desenvolvedores excluam a declaração manifesta muitas vezes desnecessária dos tipos de variáveis ​​locais.

var Escopo em Java

Note-se que varnão é uma palavra-chave em Java, mas um nome de tipo reservado. Conforme citado no JEP 286:

O identificador var não é uma palavra-chave; em vez disso, é um nome de tipo reservado. Isso significa que o código que usa var como uma variável, método ou nome do pacote não será afetado; o código que usa var como nome de classe ou interface será afetado (mas na prática esses nomes são raros, pois violam as convenções de nomenclatura comuns).

Observe que, como varé um nome de tipo reservado e não uma palavra-chave, ele ainda pode ser usado para nomes de pacotes, nomes de métodos e nomes de variáveis ​​(junto com sua nova função de interferência de tipo). Por exemplo, todos os exemplos a seguir são de usos válidos varem Java:

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

Conforme citado no JEP 286:

Esse tratamento seria restrito a variáveis ​​locais com inicializadores, índices no loop for aprimorado e locais declarados em um loop for tradicional; não estaria disponível para formals de método, formals de construtor, tipos de retorno de método, campos, formals de captura ou qualquer outro tipo de declaração de variável.

Diferenças entre varem Java e C

Essa é uma diferença notável entre varC # e Java: o varpode ser usado como um nome de tipo em C #, mas não pode ser usado como um nome de classe ou de interface em Java. De acordo com a documentação do C # (variáveis ​​locais implicitamente digitadas) :

Se um tipo nomeado varestiver no escopo, a varpalavra - chave será resolvida com esse nome de tipo e não será tratada como parte de uma declaração de variável local digitada implicitamente.

A capacidade de usar varcomo um nome de tipo em C # cria alguma complexidade e introduz algumas regras complexas de resolução, que são evitadas varno Java ao proibir varcomo nome de classe ou interface. Para obter informações sobre as complexidades dos varnomes de tipos em C #, consulte Restrições se aplicam a declarações de variáveis de tipo implícito . Para obter mais informações sobre a lógica por trás da decisão de escopo para `var em Java, consulte JEP 286: Opções de Escopo .

Ele será suportado no JDK 10. É ainda possível vê-lo em ação na compilação de acesso antecipado .

O JEP 286 :

Aprimore a linguagem Java para estender a inferência de tipo para declarações de variáveis ​​locais com inicializadores.

Então agora, em vez de escrever:

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

Você escreve:

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

Notas:

• varagora é um nome de tipo reservado
• Java ainda está comprometido com a digitação estática!
• Só pode ser usado em declarações de variáveis locais

Se você quiser experimentá-lo sem instalar o Java em seu sistema local, criei uma imagem do Docker com o 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 ==> []

Uma solução simples (supondo que você esteja usando um IDE decente) é apenas digitar 'int' em todos os lugares e depois definir o tipo para você.

Na verdade, acabei de adicionar uma classe chamada 'var' para não precisar digitar algo diferente.

O código ainda é muito detalhado, mas pelo menos você não precisa digitá-lo!

Você pode dar uma olhada no Kotlin by JetBrains, mas é val. não var.

O Java 10 obteve inferência de tipo de variável local, agora ele possui varpraticamente o equivalente ao C # one (tanto quanto sei).

Também pode inferir tipos não denotáveis ​​(tipos que não puderam ser nomeados nesse local pelo programador; apesar de que tipos não denotáveis ​​são diferentes). Veja, por exemplo, Truques com varclasses anônimas (que você nunca deve usar no trabalho) .

A única diferença que pude encontrar é que em C #,

Se um tipo chamado var estiver no escopo, a palavra-chave var será resolvida com esse nome de tipo e não será tratada como parte de uma declaração de variável local digitada implicitamente.

No Java 10 varnão é um nome de tipo legal.

A partir de Java 10, o equivalente é ... var.

Eu sei que isso é mais antigo, mas por que não criar uma classe var e criar construtores com tipos diferentes e dependendo de quais construtores são chamados, você obtém var com tipos diferentes. Você pode até criar métodos para converter um tipo em outro.

Lomboksuporta var, mas ainda é classificado 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);

Aqui está uma armadilha a evitar ao tentar usá-lo IntelliJ IDEA. Parece funcionar como esperado, incluindo a conclusão automática e tudo mais. Até que exista uma solução "não-hacky" (por exemplo, devido ao JEP 286: Inferência de tipo de variável local ), essa pode ser sua melhor aposta agora.

Observe que também valé Lomboksuportado sem modificar ou criar um lombok.config.

Você pode, no Java 10, mas apenas para variáveis locais , significando,

Você pode,

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

Mas não pode,

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

Confira as especificações para mais informações.

Em geral, você pode usar a classe Object para qualquer tipo, mas pode fazer a conversão de tipo mais tarde!

por exemplo:-

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

Agora, esse recurso está disponível no Java SE 10. O var estático, com segurança de tipo, finalmente chegou ao mundo java :)

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