Java'daki C # 'var' anahtar kelimesinin eşdeğeri nedir?

C # içinde var anahtar sözcüğünün bir kullanımı örtük tür bildirimidir. İçin Java eşdeğer sözdizimi nedir var ?

Hiç yok. Ne yazık ki, tam tip adını yazmanız gerekiyor.

Düzenleme: Gönderildikten 7 yıl sonra var, Java 10'da yerel değişkenler için (ile ) tür çıkarımı eklendi.

Düzenleme: Gönderildikten 6 yıl sonra, aşağıdan bazı yorumları toplamak için:

• C # varanahtar sözcüğüne sahip olmasının nedeni , .NET'te adı olmayan Türlere sahip olmanızdır. Örneğin:

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

  Bu durumda, uygun bir tip vermek imkansız olacaktır myData. 6 yıl önce, Java'da bu imkansızdı (son derece ayrıntılı ve tuhaf olsalar bile, tüm Türlerin isimleri vardı). Bunun bu arada değişip değişmediğini bilmiyorum.

• varile aynı değildir dynamic. variable'lar hala% 100 statik olarak yazılmıştır. Bu derlenmeyecektir:

  var myString = "foo";
  myString = 3;
  

• vartür bağlamdan açık olduğunda da kullanışlıdır. Örneğin:

  var currentUser = User.GetCurrent();

  Sorumlu olduğum herhangi bir kodda, currentUseriçinde bir Userveya türetilmiş sınıf olduğunu söyleyebilirim. Açıkçası, eğer User.GetCurrentbir int dönüşü uygulama , o zaman belki bu sizin için zararlıdır.

• Bunun bir ilgisi yok var, ancak yöntemleri diğer yöntemlerle (örn. new public void DoAThing()) Gölgelediğiniz garip kalıtım hiyerarşileriniz varsa , sanal olmayan yöntemlerin, kullanıldıkları Türden etkilendiğini unutmayın.

  Bunun iyi bir tasarımın göstergesi olduğu gerçek bir dünya senaryosu hayal edemiyorum, ancak bu beklediğiniz gibi çalışmayabilir:

  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
  

  Belirtildiği gibi, sanal yöntemler bundan etkilenmez.

• Hayır, vargerçek değişken olmadan başlatmak için beceriksiz bir yol yoktur .

  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
  

  Bu durumda, sadece eski moda bir şekilde yapın:

  object foo6;

Projenize Lombok eklerseniz, val anahtar sözcüğünü kullanabilirsiniz .

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

JEP - JDK Geliştirme-Teklif

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

JEP 286: Yerel Değişken Türü Çıkarım

Yazar Brian Goetz

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

IntelliJ için bir şekilde - varJava ile size bir eklenti hazırladım . Bu bir hack, bu yüzden olağan feragatnameler geçerlidir, ancak Java geliştirmeniz için IntelliJ kullanıyorsanız ve denemek istiyorsanız, https://bitbucket.org/balpha/varsity adresindedir .

JDK 10'un 20 Mart'ta piyasaya sürülmesiyle, Java artık JEP 286'davar belirtildiği gibi ayrılmış bir tür adı (anahtar kelime değil - aşağıya bakın) içerir . Yerel değişkenler için Java 10 veya sonraki sürümlerde şu anda geçerlidir:

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

varJava ayrılmış tür adı neredeyse aynıdır varhem örtük tiplemesi için (önemli farklar için aşağıya bakınız) izin vermesini de C # anahtar kelime. varJava'da yalnızca aşağıdaki bağlamlarda ( JEP 286: Hedeflerde numaralandırıldığı gibi) örtük tür çıkarımı için kullanılabilir :

• başlatıcılı yerel değişkenler
• gelişmiş for döngüsündeki dizinler
• yerel bir for-döngüsü ilan

Bu nedenle var olamaz alanlar, dönüş türleri, sınıf adları veya arayüz adları için kullanılabilir. Gerekçesi, JEP 286'da (Brian Goetz tarafından yazılan) belirtildiği gibi, yerel değişkenleri bildirirken ve tanımlarken uzun tip adlarının dahil edilmesi ihtiyacını ortadan kaldırmaktır :

Java kodunun yazılmasıyla ilişkili töreni azaltarak, Java'nın statik tip güvenliğe olan bağlılığını koruyarak, geliştiricilerin yerel değişken türlerinin genellikle gereksiz bildirimlerini kullanmasına izin vererek geliştirici deneyimini geliştirmeye çalışıyoruz.

var Java'da kapsam belirleme

varJava'da bir anahtar kelime değil, ayrılmış bir tür adı olduğuna dikkat edilmelidir . JEP 286'dan alıntılandığı gibi:

Var tanımlayıcısı bir anahtar kelime değildir; bunun yerine ayrılmış bir tür adıdır. Bu, değişken, yöntem veya paket adı olarak var kullanan kodun etkilenmeyeceği anlamına gelir; sınıf veya arabirim adı olarak var kullanan kod etkilenir (ancak bu adlar alışılmış adlandırma kurallarını ihlal ettikleri için uygulamada nadirdir).

varAnahtar sözcük değil, ayrılmış bir tür adı olduğundan , paket adları, yöntem adları ve değişken adları için de kullanılabilir (yeni tür parazit rolüyle birlikte). Örneğin, aşağıdakiler varJava'nın geçerli kullanımlarına ilişkin örneklerdir :

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

JEP 286'dan alıntılandığı gibi:

Bu tedavi, başlatıcılarla yerel değişkenlerle, gelişmiş for-loop'taki indekslerle ve geleneksel for-loop'ta beyan edilen yerellerle sınırlı olacaktır; yöntem formları, yapıcı formları, yöntem döndürme türleri, alanlar, yakalama formları veya başka herhangi bir değişken bildirimi için kullanılamaz.

varJava & C Arasındaki Farklar

Bu varC # ve Java arasındaki önemli bir fark aşağıdakileri içerir: varC # 'da bir tür adı olarak kullanılabilir, ancak Java'da bir sınıf adı veya arabirim adı olarak kullanılamaz. Göre C # belgelerine (Dolaylı olarak Yazılan Yerel Değişkenler) :

Adlandırılmış bir tür varkapsamdaysa, varanahtar kelime bu tür adına çözümlenir ve örtük olarak yazılan bir yerel değişken bildiriminin parçası olarak değerlendirilmez.

varC # 'da bir tür adı olarak kullanılabilmesi , bazı karmaşıklıklar yaratır ve varJava'da varbir sınıf veya arabirim adı olarak izin vermeyerek kaçınılması gereken bazı karmaşık çözünürlük kurallarını getirir . varC # 'da tür adlarının karmaşıklığı hakkında bilgi için , bkz. Kısıtlanmış türdeki değişken bildirimleri için kısıtlamalar geçerlidir . `Var in Java için kapsam belirleme kararının ardındaki mantık hakkında daha fazla bilgi için, bkz. JEP 286: Kapsam Belirleme Seçenekleri .

JDK 10'da desteklenecek. Erken erişim derlemesinde çalışırken görmek bile mümkün .

JEP 286 :

Başlatıcılarla yerel değişkenlerin bildirimlerine yazılan çıkarımları genişletmek için Java Dili'ni geliştirin.

Şimdi yazmak yerine:

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

Sen yaz:

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

Notlar:

• varşimdi ayrılmış bir tür adı
• Java hala statik yazım taahhüdüdür!
• Yalnızca yerel değişken bildirimlerinde kullanılabilir

Yerel sisteminize Java'yı yüklemeden denemek istiyorsanız, üzerinde JDK 10 yüklü bir Docker görüntüsü oluşturdum :

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

Basit bir çözüm (iyi bir IDE kullandığınızı varsayarsak), sadece her yere 'int' yazmanız ve ardından türü sizin için ayarlamanızdır.

Aslında 'var' adında bir sınıf ekledim, bu yüzden farklı bir şey yazmak zorunda değilim.

Kod hala çok ayrıntılı, ama en azından yazmak zorunda değilsiniz!

Kotlin'e JetBrains'ten bakabilirsiniz , ama val. var değil.

Java 10 yerel değişken tipi çıkarım elde etti, bu yüzden şimdi varC # bir (ben bildiğim kadarıyla) hemen hemen eşdeğer vardır.

Ayrıca, kınamayan türleri de çıkarabilir (programcı tarafından o yerde adlandırılamayan türler ; ancak hangi türlerin kınanamaz olduğu farklıdır). Örneğin bkz . İş yerinde asla kullanmamanız gereken hileler varve anonim sınıflar .

Bulabildiğim tek fark C # 'da,

Var adlı bir tür kapsamdaysa, var anahtar sözcüğü bu tür adına çözümlenir ve örtük olarak yazılan yerel değişken bildiriminin bir parçası olarak değerlendirilmez.

Java 10'da varyasal bir tür adı yoktur.

Java 10 itibariyle eşdeğerdir ... var.

Bu eski olduğunu biliyorum ama neden bir var sınıf oluşturmak ve farklı türleri ile yapıcılar oluşturmak ve hangi yapıcıların çağrıldığına bağlı olarak farklı türü ile var olsun. Bir türü diğerine dönüştürmek için yöntemler de oluşturabilirsiniz.

Lombokvar destekler ancak hala deneysel olarak sınıflandırılır:

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

İşte onu kullanmaya çalışırken kaçınmak için bir tuzak IntelliJ IDEA. Otomatik tamamlama ve her şey dahil olmak üzere beklendiği gibi çalışıyor gibi görünüyor. "Kesintisiz" bir çözüm olana kadar (örneğin, JEP 286: Yerel Değişken Türü Çıkarım nedeniyle ), bu şu anda en iyi bahsiniz olabilir.

Bir değişiklik yapmadan veya oluşturmadan da valdestek olduğunu unutmayın .Lomboklombok.config

Java 10'da, ancak yalnızca Yerel değişkenler için ,

Yapabilirsin,

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

Ama yapamam,

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

Daha fazla bilgi için teknik özelliklere göz atın .

Genel olarak herhangi bir tür için Object sınıfını kullanabilirsiniz, ancak daha sonra tür dökümünü yapmalısınız!

Örneğin:-

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

Bu özellik artık Java SE 10'da mevcut. Statik, güvenli tipli var nihayet java dünyasına dönüştü :)

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