java - जावा में सी#'var' कीवर्ड के बराबर क्या है?




keyword (13)

सी # में var कीवर्ड का एक उपयोग निहित प्रकार की घोषणा है। Var के लिए जावा समकक्ष वाक्यविन्यास क्या है?


Answers

मैंने IntelliJ के लिए एक प्लगइन पकाया है - एक तरह से - आपको var में var देता है। यह एक हैक है, इसलिए सामान्य अस्वीकरण लागू होते हैं, लेकिन यदि आप अपने जावा विकास के लिए इंटेलिजे का उपयोग करते हैं और इसे आजमा सकते हैं, तो यह https://bitbucket.org/balpha/varsity


मुझे पता है कि यह पुराना है, लेकिन क्यों एक var वर्ग नहीं बनाते हैं और विभिन्न प्रकार के साथ रचनाकार बनाते हैं और किस रचनाकारों को बुलाया जाता है, इस पर निर्भर करता है कि आप विभिन्न प्रकार के साथ 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 में इसका उपयोग करने का प्रयास करते समय बचने के लिए Here एक गड़बड़ी है। ऐसा लगता है कि ऑटो पूर्णता और सब कुछ शामिल है। जब तक "गैर-हैकी" समाधान नहीं होता है (उदाहरण के लिए openjdk.java.net/jeps/286 ), यह अभी आपका सबसे अच्छा शर्त हो सकता है।

ध्यान दें कि lombok.config किया गया है, साथ ही lombok.config को संशोधित या बनाने के बिना।


जावा 10 के रूप में, समतुल्य है ... var


वहां कोई नहीं है। हां, आपको पूर्ण प्रकार का नाम टाइप करना होगा।

पोस्ट करने के 6 साल बाद संपादित करें, नीचे से कुछ टिप्पणियां एकत्र करने के लिए:

  • कारण सी # में var कीवर्ड है क्योंकि यह उन प्रकारों के लिए संभव है जिनके पास .NET में कोई नाम नहीं है। उदाहरण के लिए:

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

    इस मामले में, myData को उचित प्रकार देना असंभव होगा। 6 साल पहले, जावा में यह असंभव था (सभी प्रकार के नाम थे, भले ही वे बेहद verbose और unweildy थे)। मुझे नहीं पता कि यह औसत समय में बदल गया है या नहीं।

  • var dynamic के समान नहीं है। var iables अभी भी 100% स्थिर रूप से टाइप किए गए हैं। यह संकलित नहीं होगा:

    var myString = "foo";
    myString = 3;
    
  • जब संदर्भ संदर्भ से स्पष्ट है तो var भी उपयोगी होता है। उदाहरण के लिए:

    var currentUser = User.GetCurrent();
    

    मैं कह सकता हूं कि किसी भी कोड में जिसके लिए मैं ज़िम्मेदार हूं, currentUser User पास 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;
    

आप जावा 10 में, लेकिन केवल स्थानीय चर के लिए और केवल denote- सक्षम प्रकारों के लिए, अर्थात्,

आप ऐसा कर सकते हैं,

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

लेकिन नहीं कर सकता

var anull = null; var aObj = new Object {}; // Anonymous Class

अधिक जानकारी के लिए spec देखें।


यदि आप अपनी परियोजना में लंबोक जोड़ते हैं तो आप इसके वैल कीवर्ड का उपयोग कर सकते हैं।

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


एक साधारण समाधान (मान लीजिए कि आप एक सभ्य आईडीई का उपयोग कर रहे हैं) बस हर जगह 'int' टाइप करना है और फिर इसे आपके लिए टाइप सेट करने के लिए मिलता है।

मैंने वास्तव में 'var' नामक एक वर्ग को जोड़ा है, इसलिए मुझे कुछ अलग टाइप करने की आवश्यकता नहीं है।

कोड अभी भी वर्बोज़ है, लेकिन कम से कम आपको इसे टाइप करने की ज़रूरत नहीं है!


सामान्य रूप से आप किसी भी प्रकार के लिए ऑब्जेक्ट क्लास का उपयोग कर सकते हैं, लेकिन आपने बाद में कास्टिंग टाइप किया है!

जैसे: -

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

इसे जेडीके 10 में समर्थित किया जाएगा। प्रारंभिक पहुंच निर्माण में इसे क्रिया में देखना भी संभव है।

openjdk.java.net/jeps/286 :

आरंभिक के साथ स्थानीय चर की घोषणाओं के प्रकार टाइप अनुमान बढ़ाने के लिए जावा भाषा को बढ़ाएं।

तो अब लिखने के बजाय:

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

तुम लिखो:

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

टिप्पणियाँ:

  • var अब एक आरक्षित प्रकार का नाम है
  • स्थिर स्थिरता के लिए जावा अभी भी प्रतिबद्धता है!
  • इसका उपयोग स्थानीय परिवर्तनीय घोषणाओं में ही किया जा सकता है

यदि आप इसे अपने स्थानीय सिस्टम पर जावा इंस्टॉल किए बिना कोशिश करना चाहते हैं, तो मैंने उस पर स्थापित जेडीके 10 के साथ एक डॉकर छवि बनाई है:

$ docker run -it marounbassam/ubuntu-java10 bash
[email protected]:/# 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 ==> []

आप जेटब्रेन द्वारा Kotlin को देख सकते हैं, लेकिन यह वैल है। var नहीं


20 मार्च को जेडीके 10 की रिहाई के साथ, जावा में अब एक अलग आरक्षित प्रकार का नाम शामिल है (नीचे कोई कीवर्ड-नीचे नहीं) जैसा कि openjdk.java.net/jeps/286 में निर्दिष्ट है। स्थानीय चर के लिए, अब जावा 10 या उच्चतर में मान्य है:

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

जावा में var आरक्षित प्रकार का नाम सी # में var कीवर्ड के समान है, जिसमें दोनों अंतर्निहित टाइपिंग (महत्वपूर्ण मतभेदों के लिए नीचे देखें) की अनुमति देते हैं। var में var का उपयोग केवल निम्नलिखित संदर्भों में अंतर्निहित प्रकार अनुमान के लिए किया जा सकता है (जैसा कि जेईपी 286: लक्ष्य में उल्लिखित है):

  • प्रारंभिक के साथ स्थानीय चर
  • बढ़ाए गए लूप में इंडेक्स
  • एक पारंपरिक फॉर-लूप में घोषित स्थानीय

इसलिए var फ़ील्ड, रिटर्न प्रकार, क्लास नाम, या इंटरफ़ेस नामों के लिए उपयोग नहीं किया जा सकता है। openjdk.java.net/jeps/286 (ब्रायन गोएट्ज़ द्वारा लिखित) में बताए गए अनुसार, स्थानीय चर घोषित करने और परिभाषित करते समय लंबे प्रकार के नामों को शामिल करने की आवश्यकता को दूर करना इसका तर्क है:

हम जावा कोड लिखने से जुड़े समारोह को कम करके डेवलपर अनुभव में सुधार करना चाहते हैं, जबकि स्थिर प्रकार की सुरक्षा के लिए जावा की वचनबद्धता को बनाए रखते हुए, डेवलपर्स को स्थानीय चर प्रकारों की अक्सर अनावश्यक अभिव्यक्ति घोषणा को दूर करने की अनुमति देकर।

जावा में var Scoping

यह ध्यान दिया जाना चाहिए कि var जावा में कोई कीवर्ड नहीं है, बल्कि एक आरक्षित प्रकार का नाम है। जैसा कि जेईपी 286 से उद्धृत किया गया है:

पहचानकर्ता var एक कीवर्ड नहीं है; इसके बजाय यह एक आरक्षित प्रकार का नाम है। इसका अर्थ यह है कि एक चर, विधि, या पैकेज नाम के रूप में var का उपयोग करने वाला कोड प्रभावित नहीं होगा; कोड जो क्लास या इंटरफ़ेस नाम के रूप में var का उपयोग करता है प्रभावित होगा (लेकिन ये नाम अभ्यास में दुर्लभ हैं, क्योंकि वे सामान्य नामकरण सम्मेलनों का उल्लंघन करते हैं)।

ध्यान दें कि चूंकि var एक आरक्षित प्रकार का नाम है और कोई कीवर्ड नहीं है, फिर भी इसका उपयोग पैकेज नामों, विधि नामों और परिवर्तनीय नामों (इसके नए प्रकार-हस्तक्षेप भूमिका के साथ) के लिए भी किया जा सकता है। उदाहरण के लिए, जावा में var के वैध उपयोग के सभी उदाहरण निम्नलिखित हैं:

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

जैसा कि जेईपी 286 से उद्धृत किया गया है:

यह उपचार स्थानीय चर के लिए प्रारंभिक, प्रतिबंधित फॉर-लूप में इंडेक्स, और परंपरागत फॉर-लूप में घोषित स्थानीय लोगों के लिए प्रतिबंधित होगा; यह विधि औपचारिक, कन्स्ट्रक्टर फॉर्मल्स, विधि रिटर्न प्रकार, फ़ील्ड, कैच फॉर्मल्स, या किसी अन्य प्रकार की परिवर्तनीय घोषणा के लिए उपलब्ध नहीं होगा।

जावा और सी # में var बीच मतभेद

यह सी # और जावा में var बीच एक उल्लेखनीय अंतर है जिसमें निम्नलिखित शामिल हैं: var को C # में टाइप नाम के रूप में उपयोग किया जा सकता है लेकिन जावा में क्लास नाम या इंटरफ़ेस नाम के रूप में उपयोग नहीं किया जा सकता है। सी # दस्तावेज के अनुसार (लागू रूप से टाइप किए गए स्थानीय चर) :

यदि var नाम का एक प्रकार गुंजाइश में है, तो var कीवर्ड उस प्रकार के नाम को हल करेगा और एक स्पष्ट रूप से टाइप की गई स्थानीय चर घोषणा के हिस्से के रूप में नहीं माना जाएगा।

सी # में एक प्रकार के नाम के रूप में var का उपयोग करने की क्षमता कुछ जटिलता बनाती है और कुछ जटिल रिज़ॉल्यूशन नियम प्रस्तुत करती है, जिन्हें क्लास या इंटरफ़ेस नाम के रूप में var को अस्वीकार करके जावा में var से बचा जाता है। सी # में var प्रकार के नामों की जटिलताओं के बारे में जानकारी के लिए, प्रतिबंधों को स्पष्ट रूप से टाइप की गई चरम घोषणाओं पर लागू करें । जावा में 'var के लिए स्कोपिंग निर्णय के पीछे तर्क के बारे में अधिक जानकारी के लिए, जेईपी 286 देखें : स्कोपिंग विकल्प


यह उदाहरण कोड है जिसे मैंने आपके लिए इस अवधारणा को समझने के लिए लिखा है:

var foo = 5; 
bar = 2;     
fooba = 3;

// Execute an anonymous function
(function() {    
    bar = 100;             //overwrites global scope bar
    var foo = 4;           //a new foo variable is created in this' function's scope
    var fooba = 900;       //same as above
    document.write(foo);   //prints 4
    document.write(bar);   //prints 100
    document.write(fooba); //prints 900
})();

document.write('<br/>');
document.write('<br/>');
document.write(foo);       //prints 5
document.write(bar);       //prints 100
document.write(fooba);     //prints 3




java keyword var