คำหลัก C # 'var' ใน Java มีอะไรเทียบเท่า

การใช้คำหลักvarใน C # คือการประกาศชนิดโดยนัย ไวยากรณ์เทียบเท่า Java สำหรับvarคืออะไร?

ไม่มีเลย อนิจจาคุณต้องพิมพ์ชื่อเต็ม

แก้ไข: 7 ปีหลังจากการโพสต์, การอนุมานประเภทสำหรับตัวแปรท้องถิ่น (กับvar) ถูกเพิ่มใน Java 10

แก้ไข: 6 ปีหลังจากโพสต์, เพื่อรวบรวมความคิดเห็นจากด้านล่าง:

• เหตุผล C # มีvarคำหลักเนื่องจากเป็นไปได้ที่จะมีประเภทที่ไม่มีชื่อใน. NET เช่น:

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

  myDataในกรณีนี้มันจะเป็นไปไม่ได้ที่จะให้ชนิดที่เหมาะสมในการ 6 ปีที่แล้วสิ่งนี้เป็นไปไม่ได้ใน Java (ทุกประเภทมีชื่อแม้ว่าพวกเขาจะ verbose อย่างมากและไม่สวย) ฉันไม่ทราบว่าสิ่งนี้มีการเปลี่ยนแปลงในเวลาเฉลี่ย

• vardynamicไม่ได้เป็นเช่นเดียวกับ variables ยังคงพิมพ์แบบคงที่ 100% สิ่งนี้จะไม่รวบรวม:

  var myString = "foo";
  myString = 3;

• varก็มีประโยชน์เมื่อประเภทนั้นชัดเจนจากบริบท ตัวอย่างเช่น:

  var currentUser = User.GetCurrent();

  ฉันสามารถพูดได้ว่าในรหัสใด ๆ ที่ฉันรับผิดชอบcurrentUserมีUserหรือได้รับในชั้นเรียน เห็นได้ชัดว่าหากการใช้งานของคุณUser.GetCurrentคืนค่าเป็น int อาจเป็นอันตรายกับคุณ

• สิ่งนี้ไม่มีส่วนเกี่ยวข้องvarแต่ถ้าคุณมีลำดับชั้นการสืบทอดแปลก ๆ ที่คุณเงาวิธีการด้วยวิธีอื่น ๆ (เช่นnew public void DoAThing()) อย่าลืมว่าวิธีการที่ไม่ใช่แบบเสมือนได้รับผลกระทบจากประเภทที่พวกมันถูกโยนเป็น

  ฉันไม่สามารถจินตนาการถึงสถานการณ์ในโลกแห่งความจริงที่สิ่งนี้บ่งบอกถึงการออกแบบที่ดี แต่สิ่งนี้อาจไม่ทำงานอย่างที่คุณคาดไว้:

  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

  ตามที่ระบุไว้วิธีการเสมือนจะไม่ได้รับผลกระทบจากสิ่งนี้

• ไม่ไม่มีวิธีที่ไม่ซุ่มซ่ามในการเริ่มต้นvarโดยไม่มีตัวแปรจริง

  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

  ในกรณีนี้เพียงทำแบบเก่า:

  object foo6;

หากคุณเพิ่มลอมบอกในโครงการของคุณคุณสามารถใช้คำหลักวาล

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

JEP - ข้อเสนอการปรับปรุง JDK

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

JEP 286: การอนุมานประเภทตัวแปรท้องถิ่น

ผู้แต่ง Brian Goetz

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

ฉันได้ปรุงปลั๊กอินสำหรับ IntelliJ แล้ว - ในแบบที่ให้คุณกับvarJava มันสับดังนั้นการสละสิทธิ์ตามปกติใช้ แต่ถ้าคุณใช้ IntelliJ สำหรับการพัฒนา Java ของคุณและต้องการที่จะลองมันออกมามันจะอยู่ที่https://bitbucket.org/balpha/varsity

ด้วยการเปิดตัวของ JDK 10 เมื่อวันที่ 20 มีนาคม, Java ตอนนี้มีvarชื่อประเภทที่สงวนไว้ (ไม่ได้เป็นคำหลักดูด้านล่าง) ตามที่ระบุในJEP 286 สำหรับตัวแปรโลคัลตอนนี้สิ่งต่อไปนี้ใช้ได้ใน Java 10 หรือสูงกว่า:

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

varชื่อประเภทที่สงวนไว้ใน Java เป็นเกือบจะเหมือนกับvarคำหลักใน C # ในการที่ทั้งสองช่วยให้สำหรับการพิมพ์โดยปริยาย (ดูด้านล่างสำหรับความแตกต่างที่สำคัญ) varใน Java สามารถใช้สำหรับการอนุมานประเภทโดยนัยในบริบทต่อไปนี้ (ตามที่ระบุในJEP 286: เป้าหมาย ):

• ตัวแปรโลคัลพร้อมกับ initializers
• ดัชนีใน for-loop ที่ได้รับการปรับปรุง
• ท้องถิ่นประกาศในแบบดั้งเดิมสำหรับวง

ดังนั้นจึงvar ไม่สามารถใช้สำหรับฟิลด์ประเภทส่งคืนชื่อคลาสหรือชื่ออินเทอร์เฟซ เหตุผลของมันคือการลบความจำเป็นในการรวมชื่อชนิดยาวเมื่อประกาศและกำหนดตัวแปรท้องถิ่นตามที่ระบุในJEP 286 (เขียนโดย Brian Goetz):

เราพยายามปรับปรุงประสบการณ์ของนักพัฒนาโดยลดพิธีที่เกี่ยวข้องกับการเขียนโค้ด Java ในขณะที่รักษาความมุ่งมั่นของจาวาในการรักษาความปลอดภัยของสแตติกชนิดต่างๆ

var การกำหนดขอบเขตใน Java

ควรสังเกตว่าvarไม่ใช่คำหลักใน Java แต่เป็นชื่อประเภทที่สงวนไว้ ตามที่ยกมาจาก JEP 286:

var ตัวระบุไม่ใช่คำหลัก แต่เป็นชื่อประเภทที่สงวนไว้ ซึ่งหมายความว่ารหัสที่ใช้ var เป็นตัวแปรวิธีการหรือชื่อแพคเกจจะไม่ได้รับผลกระทบ รหัสที่ใช้ var เป็นคลาสหรือชื่ออินเทอร์เฟซจะได้รับผลกระทบ (แต่ชื่อเหล่านี้หายากในทางปฏิบัติเนื่องจากละเมิดหลักการตั้งชื่อตามปกติ)

โปรดทราบว่าเนื่องจากvarเป็นชื่อประเภทที่สงวนไว้และไม่ใช่คำหลักจึงยังสามารถใช้สำหรับชื่อแพคเกจชื่อเมธอดและชื่อตัวแปร (พร้อมกับบทบาทการรบกวนประเภทใหม่) ตัวอย่างเช่นต่อไปนี้เป็นตัวอย่างทั้งหมดของการใช้งานที่ถูกต้องของvarใน Java:

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

ตามที่ยกมาจาก JEP 286:

การรักษานี้จะถูก จำกัด ให้กับตัวแปรในท้องถิ่นที่มี initializers ดัชนีในการปรับปรุงสำหรับวงและท้องถิ่นที่ประกาศในแบบดั้งเดิมสำหรับวง; มันจะไม่สามารถใช้ได้สำหรับ formals วิธี formals นวกรรมิกชนิดกลับวิธีการเขตข้อมูลจับ formals หรือการประกาศตัวแปรชนิดอื่น ๆ

ความแตกต่างระหว่างvarใน Java & C

นี่คือความแตกต่างที่น่าสังเกตระหว่างvarใน C # และ Java รวมถึงต่อไปนี้: varสามารถใช้เป็นชื่อประเภทใน C # แต่ไม่สามารถใช้เป็นชื่อคลาสหรือชื่ออินเตอร์เฟสใน Java ตามเอกสาร C # (ตัวแปรท้องถิ่นที่พิมพ์โดยนัย) :

หากประเภทที่มีชื่อvarอยู่ในขอบเขตvarคำหลักจะแก้ไขเป็นชื่อประเภทนั้นและจะไม่ถือว่าเป็นส่วนหนึ่งของการประกาศตัวแปรท้องถิ่นที่พิมพ์โดยนัย

ความสามารถในการใช้varเป็นชื่อประเภทใน C # สร้างความซับซ้อนและแนะนำกฎการแก้ปัญหาที่ซับซ้อนซึ่งถูกหลีกเลี่ยงโดยvarใน Java โดยไม่อนุญาตให้varใช้เป็นคลาสหรือชื่ออินเตอร์เฟส สำหรับข้อมูลเกี่ยวกับความซับซ้อนของvarชื่อประเภทใน C #, ดูข้อ จำกัด นำไปใช้โดยปริยายพิมพ์ประกาศตัวแปร สำหรับข้อมูลเพิ่มเติมเกี่ยวกับเหตุผลที่อยู่เบื้องหลังการตัดสินใจกำหนดขอบเขตสำหรับ `var ใน Java ดูJEP 286: กำหนดขอบเขตทางเลือก

มันจะได้รับการสนับสนุนใน JDK 10 มันยังเป็นไปได้ที่จะเห็นมันในการดำเนินการในการสร้างการเข้าถึงก่อน

JEP 286 :

เพิ่มประสิทธิภาพภาษา Java เพื่อขยายการอนุมานประเภทเพื่อประกาศตัวแปรท้องถิ่นด้วย initializers

ดังนั้นตอนนี้แทนที่จะเขียน:

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

ที่คุณเขียน:

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

หมายเหตุ:

• varเป็นชื่อประเภทที่สงวนไว้
• Java ยังคงมุ่งมั่นที่จะพิมพ์คงที่!
• มันสามารถใช้ในการประกาศตัวแปรท้องถิ่น

หากคุณต้องการทดลองใช้งานโดยไม่ต้องติดตั้ง Java ในระบบท้องถิ่นของคุณฉันสร้างอิมเมจ Docker ที่มี JDK 10 ติดตั้งไว้:

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

วิธีแก้ปัญหาอย่างง่าย (สมมติว่าคุณกำลังใช้ IDE ที่เหมาะสม) เพียงพิมพ์ 'int' ทุกที่จากนั้นให้กำหนดประเภทให้คุณ

ฉันเพิ่งเพิ่มคลาสที่เรียกว่า 'var' ดังนั้นฉันจึงไม่ต้องพิมพ์อะไรที่แตกต่างออกไป

รหัสนี้ยังละเอียดเกินไป แต่อย่างน้อยคุณก็ไม่จำเป็นต้องพิมพ์มัน!

คุณสามารถดูKotlinโดย JetBrains แต่มันก็คุ้มค่า ไม่ได้

Java 10 ได้รับการอนุมานประเภทตัวแปรท้องถิ่นดังนั้นตอนนี้ก็มีvarซึ่งเทียบเท่ากับ C # หนึ่ง (เท่าที่ฉันรู้)

นอกจากนี้ยังสามารถสรุปประเภทที่ไม่ใช่ denotable (ประเภทที่ไม่สามารถมีชื่ออยู่ในสถานที่ที่โดยโปรแกรมเมอร์แม้ว่าซึ่งประเภทนี้ไม่ denotable ที่แตกต่างกัน) ดูเช่นเทคนิคกับvarและการเรียนที่ไม่ระบุชื่อ (ที่คุณไม่ควรใช้ในที่ทำงาน)

ข้อแตกต่างอย่างหนึ่งที่ฉันพบคือใน C #

หากประเภท var ชื่ออยู่ในขอบเขตแล้วคำหลัก var จะแก้ไขชื่อประเภทนั้นและจะไม่ถือว่าเป็นส่วนหนึ่งของการประกาศตัวแปรท้องถิ่นพิมพ์โดยนัย

ใน Java 10 varไม่ใช่ชื่อประเภทที่ถูกกฎหมาย

ในฐานะของ Java ที่ 10 เทียบเท่าคือ var...

ฉันรู้ว่านี่เก่ากว่า แต่ทำไมไม่สร้างคลาส var และสร้าง constructor ที่มีประเภทต่าง ๆ และขึ้นอยู่กับว่า constructor ใดที่ถูกเรียกใช้คุณจะได้รับ var ที่มีประเภทแตกต่างกัน คุณสามารถสร้างวิธีการในการแปลงประเภทหนึ่งเป็นประเภทอื่น

Lombokรองรับ varแต่ยังคงจัดเป็นประเภททดลอง:

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

นี่IntelliJ IDEAคืออันตรายที่ควรหลีกเลี่ยงเมื่อพยายามที่จะใช้ใน ดูเหมือนว่าจะทำงานได้ตามที่คาดไว้รวมถึงการทำให้สมบูรณ์อัตโนมัติและทุกอย่าง จนกว่าจะมีวิธีแก้ปัญหา "ไม่แฮ็ก" (เช่นเนื่องจากJEP 286: การอนุมานประเภทตัวแปรท้องถิ่น ) นี่อาจเป็นทางออกที่ดีที่สุดของคุณในตอนนี้

ทราบว่าvalได้รับการสนับสนุนโดยการเป็นอย่างดีโดยไม่ต้องแก้ไขหรือการสร้างLomboklombok.config

คุณสามารถใน Java 10 แต่สำหรับตัวแปรLocalหมายถึง

คุณสามารถ,

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

แต่ไม่สามารถ

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

ตรวจสอบข้อมูลจำเพาะสำหรับข้อมูลเพิ่มเติม

โดยทั่วไปคุณสามารถใช้คลาส Object สำหรับประเภทใดก็ได้ แต่คุณต้องทำการแคสต์ชนิดในภายหลัง!

เช่น:-

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

ตอนนี้ฟีเจอร์นี้มีให้ใน Java SE 10 แล้ว var แบบเซฟตี้ได้ทำให้เป็นโลกของ java ในที่สุด :)

แหล่งที่มา: https://www.oracle.com/corporate/pressrelease/Java-10-032018.html