ग्रोवी संपत्ति परिभाषा

Question

पहले मैंने सोचा था कि ग्रोवी में एक संपत्ति को स्कॉइंग कीवर्ड को छोड़कर इंगित किया जाता है। दूसरे शब्दों

class Test { 
    def prop = "i am a property" 
    public notProp = "i am not" 
} 

हालांकि देखें तो ऐसा लगता है कि मैं इस बारे में गलत हूँ, क्योंकि निम्न स्क्रिप्ट प्रिंट "गेटर वैल"

class Foo { 
    public bar = "init val" 

    public getBar() { 
    "getter val" 
    } 
} 

println new Foo().bar 

तथ्य यह है कि गेटर जब bar पहुँचा जा सकता है शुरू हो जाती है कि पता चलता है bar एक क्षेत्र के बजाय एक संपत्ति है। तो ग्रोवी में खेतों और संपत्तियों के बीच क्या अंतर है।

धन्यवाद, डॉन

Answer 1

आप एक अंतर यह है कि ग्रूवी में वहाँ नहीं है के लिए देख रहे हैं।

"In Groovy, fields and properties have been merged so that they act and look the same."

Answer 2

सीधे एक क्षेत्र तक पहुँचने के लिए आप एक @ चिह्न के साथ इसे पहले जोड़ें करने के लिए है आदेश में:

assert "getter val" == new Foo().bar 
assert "init val" == new Foo().@bar 

कि new Foo().getBar() काम करता है का संक्षिप्त रूप है, हालांकि bar एक संपत्ति नहीं है, अब भी है मेरे दृष्टिकोण से संक्षिप्त।

इसके विपरीत आप foo.setBar("setter val") पर कॉल नहीं कर सकते हैं, लेकिन यदि आप एक्सेस संशोधक के बिना bar को किसी संपत्ति के रूप में परिभाषित करते हैं तो आप कर सकते हैं।

Answer 3

एक संशोधक का उपयोग वास्तव में एक संपत्ति के निर्माण को दबा देता है। आपको भ्रमित करने वाला क्या है कि . किसी भी संपत्ति मौजूद होने पर फ़ील्ड एक्सेस पर फ़ॉलबैक लग रहा है।

 
$ groovysh 
Groovy Shell (2.1.0, JVM: 1.7.0_21) 
Type 'help' or '\h' for help. 
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 
groovy:000> class A { def a = "foo" }; 
===> true 
groovy:000> new A().getA() 
===> foo 
groovy:000> new A().a 
===> foo 
groovy:000> new A().properties 
===> {class=class A, a=foo} 

लेकिन:

 
groovy:000> class A { public def a = "foo" }; 
===> true 
groovy:000> new A().getA() 
ERROR groovy.lang.MissingMethodException: 
No signature of method: A.getA() is applicable for argument types:() values: [] 
Possible solutions: getAt(java.lang.String), grep(), grep(java.lang.Object), with(groovy.lang.Closure), putAt(java.lang.String, java.lang.Object), wait() 
     at groovysh_evaluate.run (groovysh_evaluate:2) 
     ... 
groovy:000> new A().a 
===> foo 
groovy:000> new A().properties 
===> {class=class A} 

Answer 4

मुझे लगता है कि @Christoph Metzendorf उत्तर सही था ...

सीधे एक क्षेत्र तक पहुँचने के लिए आपके पास एक @ संकेत के साथ यह पहले जोड़ें करने के लिए है आदेश में :

assert "getter val" == new Foo().bar 
assert "init val" == new Foo().@bar 

... लेकिन मैं इसे आपके Foo उदाहरण में जोड़ दूंगा उदाहरण के लिए getBar विधि getBar विधि को ओवरराइड करती है जो आपके लिए जेरोवी उत्पन्न होती है। आप bar तक पहुंचने के लिए उपर्युक्त वाक्यविन्यास का उपयोग कर सकते हैं यदि आप डिफ़ॉल्ट getBar विधि आपके लिए जेनरेट की गई विधि को ओवरराइड करना जारी रखना चाहते हैं, या आप getBar को ओवरराइड नहीं कर सकते हैं, इसलिए getBar पर कोई भी कॉल आपके लिए जेनरेट गेटोवी का उपयोग करेगा।