Qual è l'equivalente della parola chiave C # 'var' in Java?

Un uso della parola chiave var in C # è la dichiarazione di tipo implicito. Qual è la sintassi equivalente Java per var ?

Non c'è nessuno. Purtroppo, devi digitare il nome completo del tipo.

Modifica: 7 anni dopo essere stato pubblicato, l'inferenza del tipo per le variabili locali (con var) è stata aggiunta in Java 10.

Modifica: 6 anni dopo la pubblicazione, per raccogliere alcuni dei commenti dal basso:

• Il motivo per cui C # ha la varparola chiave è perché è possibile avere tipi senza nome in .NET. Per esempio:

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

  In questo caso, sarebbe impossibile dare un tipo adeguato a myData. 6 anni fa, questo era impossibile in Java (tutti i tipi avevano nomi, anche se erano estremamente dettagliati e irti). Non so se questo sia cambiato nel frattempo.

• varnon è lo stesso di dynamic. varI numeri sono ancora digitati staticamente al 100%. Questo non compilerà:

  var myString = "foo";
  myString = 3;

• varè utile anche quando il tipo è evidente dal contesto. Per esempio:

  var currentUser = User.GetCurrent();

  Posso dire che in qualsiasi codice di cui sono responsabile, currentUser contiene una Userclasse derivata o. Ovviamente, se la tua implementazione di User.GetCurrentreturn an int, allora forse questo è un danno per te.

• Questo non ha nulla a che fare con var, ma se si hanno strane gerarchie ereditarie in cui si ombreggiano i metodi con altri metodi (ad esempio new public void DoAThing()), non dimenticare che i metodi non virtuali sono influenzati dal Tipo in cui vengono espressi.

  Non riesco a immaginare uno scenario del mondo reale in cui questo sia indicativo di un buon design, ma potrebbe non funzionare come previsto:

  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

  Come indicato, i metodi virtuali non sono interessati da questo.

• No, non esiste un modo non semplice per inizializzare un varsenza una variabile effettiva.

  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

  In questo caso, fallo alla vecchia maniera:

  object foo6;

Se aggiungi Lombok al tuo progetto puoi usare la sua parola chiave val .

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

JEP - Proposta di miglioramento JDK

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

JEP 286: Inferenza di tipo variabile locale

Autore Brian Goetz

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

Ho preparato un plugin per IntelliJ che, in un certo senso, ti dà varin Java. È un trucco, quindi si applicano le solite dichiarazioni di non responsabilità, ma se usi IntelliJ per il tuo sviluppo Java e vuoi provarlo, è su https://bitbucket.org/balpha/varsity .

Con il rilascio di JDK 10 il 20 marzo, Java ora include un varnome di tipo riservato (non una parola chiave, vedere di seguito) come specificato in JEP 286 . Per le variabili locali, ora è valido in Java 10 o versioni successive:

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

Il varnome del tipo riservato in Java è quasi identico alla varparola chiave in C # in quanto entrambi consentono una digitazione implicita (vedi sotto per differenze importanti). varin Java può essere utilizzato solo per l'inferenza di tipo implicito nei seguenti contesti (come elencato in JEP 286: Obiettivi ):

• variabili locali con inizializzatori
• indici nel for-loop avanzato
• gente del posto dichiarata in un tradizionale for-loop

Pertanto var non può essere utilizzato per campi, tipi restituiti, nomi di classe o nomi di interfaccia. La sua logica è quella di eliminare la necessità di includere nomi di tipo lunghi quando si dichiarano e si definiscono variabili locali, come affermato in JEP 286 (scritto da Brian Goetz):

Cerchiamo di migliorare l'esperienza degli sviluppatori riducendo la cerimonia associata alla scrittura del codice Java, pur mantenendo l'impegno di Java per la sicurezza dei tipi statici, consentendo agli sviluppatori di eludere la dichiarazione manifest spesso non necessaria di tipi di variabili locali.

var Scoping in Java

Va notato che varnon è una parola chiave in Java, ma piuttosto un nome di tipo riservato. Come citato da JEP 286:

L'identificatore var non è una parola chiave; invece è un nome di tipo riservato. Ciò significa che il codice che utilizza var come variabile, metodo o nome del pacchetto non sarà interessato; il codice che utilizza var come nome della classe o dell'interfaccia sarà interessato (ma questi nomi sono rari in pratica, poiché violano le convenzioni di denominazione normali).

Si noti che poiché varè un nome di tipo riservato e non una parola chiave, può ancora essere utilizzato per nomi di pacchetti, nomi di metodi e nomi di variabili (insieme al nuovo ruolo di interferenza del tipo). Ad esempio, i seguenti sono tutti esempi di usi validi di varin Java:

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

Come citato da JEP 286:

Questo trattamento sarebbe limitato alle variabili locali con inizializzatori, indici nel for-loop avanzato e locali dichiarati in un for-loop tradizionale; non sarebbe disponibile per formali di metodi, formali di costruttori, tipi di restituzione di metodi, campi, formali di cattura o qualsiasi altro tipo di dichiarazione variabile.

Differenze tra varJava e C.

Questa è una notevole differenza tra varin C # e Java include quanto segue: varpuò essere usato come nome di tipo in C # ma non può essere usato come nome di classe o nome di interfaccia in Java. Secondo la documentazione C # (Variabili locali tipizzate implicitamente) :

Se un tipo denominato varrientra nell'ambito, la varparola chiave si risolverà in quel nome di tipo e non verrà trattata come parte di una dichiarazione di variabile locale tipizzata in modo implicito.

La possibilità di utilizzare varcome nome di tipo in C # crea una certa complessità e introduce alcune regole di risoluzione complesse, che vengono evitate varin Java impedendo varcome nome di classe o di interfaccia. Per informazioni sulla complessità dei varnomi dei tipi in C #, vedere Le restrizioni si applicano alle dichiarazioni di variabili tipizzate in modo implicito . Per ulteriori informazioni sulla logica alla base della decisione di scoping per `var in Java, vedere JEP 286: Scelte di scoping .

Sarà supportato in JDK 10. È anche possibile vederlo in azione nella build di accesso anticipato .

Il JEP 286 :

Migliora il linguaggio Java per estendere l'inferenza del tipo alle dichiarazioni delle variabili locali con gli inizializzatori.

Quindi ora invece di scrivere:

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

Scrivi:

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

Appunti:

• var è ora a nome di tipo riservato
• Java è fermo impegnato nella tipizzazione statica!
• Può essere utilizzato solo nelle dichiarazioni delle variabili locali

Se vuoi provarlo senza installare Java sul tuo sistema locale, ho creato un'immagine Docker con JDK 10 installato su di esso:

$ 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 soluzione semplice (supponendo che tu stia utilizzando un IDE decente) è semplicemente digitare 'int' ovunque e quindi farlo impostare per te.

In realtà ho appena aggiunto una classe chiamata 'var', quindi non devo digitare qualcosa di diverso.

Il codice è ancora troppo dettagliato, ma almeno non devi scriverlo!

Puoi dare un'occhiata a Kotlin di JetBrains, ma è val. non var.

Java 10 ha ottenuto l'inferenza del tipo di variabile locale, quindi ora ha var praticamente l'equivalente di C # one (per quanto ne so).

Può anche inferire tipi non denotabili (tipi che non possono essere nominati in quel posto dal programmatore; anche se quali tipi non sono denotabili è diverso). Vedi ad esempio Trucchi con vare classi anonime (che non dovresti mai usare al lavoro) .

L'unica differenza che ho trovato è che in C #,

Se un tipo denominato var è nell'ambito, la parola chiave var si risolverà in quel nome di tipo e non verrà trattata come parte di una dichiarazione di variabile locale tipizzata in modo implicito.

In Java 10 varnon è un nome di tipo legale.

Come di Java 10, l'equivalente è ... var.

So che questo è più vecchio, ma perché non creare una classe var e creare costruttori con tipi diversi e in base a quali costruttori viene invocato si ottiene var con tipo diverso. Potresti persino creare metodi per convertire un tipo in un altro.

Lomboksupporta var ma è ancora classificato come sperimentale:

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

Ecco una trappola da evitare quando si tenta di utilizzarlo IntelliJ IDEA. Sembra funzionare come previsto sebbene includa il completamento automatico e tutto. Fino a quando non esiste una soluzione "non confusa" (ad es. Dovuta a JEP 286: Inferenza di tipo variabile locale ), questa potrebbe essere la soluzione migliore in questo momento.

Si noti che valè anche il supporto Lomboksenza modificare o creare un lombok.config.

Puoi, in Java 10, ma solo per Local variabili , che significa,

Puoi,

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

Ma non posso

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

Controlla le specifiche per maggiori informazioni.

In generale puoi usare la classe Object per qualsiasi tipo, ma devi eseguire il cast del tipo in seguito!

per esempio:-

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

Questa funzione è ora disponibile in Java SE 10. Il var statico e sicuro è finalmente arrivato nel mondo java :)

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