मैं स्काला पढ़ रहा हूँ और मैं सोच रहा हूँ में "वैल इंट क्षमता" के बजाय ...
क्योंहोने के लिए किसी भी कारण: स्काला
val capacity : Int
val Int capacity.
कोई भी कारण यह विकल्प क्यों बनाया गया था। यदि नहीं, तो मुझे यह घोषित करने के जावा तरीके से दूर जाने के लिए एक अच्छी पसंद की तरह प्रतीत नहीं होता है। जावा से स्कैला को आसान बना दिया होगा (बहुत ज्यादा नहीं, लेकिन थोड़ा सा)
क्योंकि अधिकांश समय आप इंट पार्ट को छोड़ सकते हैं। स्कैला जावा की तुलना में टाइप अनुमान की एक बहुत अच्छी प्रणाली है।
x: टी तर्क और कई प्रोग्रामिंग भाषाओं में प्रकार के लिए मानक नोटेशन है। सी और इसके वंशज, उनमें से जावा के साथ, इससे विचलित हो जाते हैं। लेकिन सी का प्रकार नोटेशन वास्तव में भयानक है (मानचित्र की तरह कुछ मामूली जटिल उच्च ऑर्डर फ़ंक्शन के लिए टाइप लिखने का प्रयास करें)।
इसके अलावा, इस नोटेशन के साथ इस प्रकार को छोड़ना आसान है (जैसा कि Wysawyg पहले से लिखा है), या अभिव्यक्ति के अंदर एक प्रकार जोड़ने के लिए।
यहाँ Wysawyg के बयान के लिए एक उदाहरण है:
val capacity = 2
लेकिन आप आम तौर पर सिर्फ एक val के साथ ऐसा नहीं हो सकता है।
trait Foo {
def capacity = 2 // Allow child classes to override and decide the value later
}
// Force instances of Bar to set the value
class Bar(override val capacity : Int) extends Foo
// Have Bat determine it on the fly
trait Bat extends Foo {
def onlyAThird : Int
override def capacity = onlyAThird * 3
}
स्काला में प्रोग्रामिंग में (मैं एक टिप्पणी के रूप में इस डालने के लिए कोशिश की, लेकिन अफसोस, कोई स्वरूपण।)
आप शाब्दिक स्थिरता के लिए 'def' का उपयोग क्यों करते हैं? आगे: 'def' को आकस्मिक रूप से यहां' डिफ़ॉल्ट 'के रूप में समझाया जा रहा है। –
आह, 'def' मूल्यांकन समय के बारे में है। अगर हमने कहा कि 'वैल क्षमता = 2' आप' बैट 'को फ्लाई पर क्षमता निर्धारित करने वाले फ़ंक्शन के साथ' Foo 'का विस्तार नहीं कर पाए। –
मुझे लगता है कि अब मैं समझता हूं। आप इसे विधि द्वारा ओवरराइड करने के लिए इसे 'डीफ' के रूप में परिभाषित करते हैं।एक वैल केवल एक और वैल द्वारा ओवरराइड करने योग्य होगा। –
मुझे लगता है कि डेनियल ऐसा ही कुछ के बारे में सोचा:
val a = 7
val b: Int = 8
var x = "Foo"
var y: String = "Bar"
def sum (a: Int, b: Int) = a + b
def mul (a: Int, b: Int): Int = a * b
प्रकार अक्सर निष्कर्ष निकाला जा सकता।
मुझे लगता है कि मैंने मार्टिन ओडरस्की द्वारा कहीं भी एक बयान पढ़ा है कि कहीं भी यह निर्णय पठनीयता में सुधार के लिए भी किया गया था। यह निश्चित रूप से मामला है, उदा।
val number : Double = ...
val something : Array[(Seq[String], Map[Seq[String], Double])] = ...
val pattern : String = ...
बार जब आप नाम संदर्भ की खोजने की जरूरत के अधिकांश के साथ
val Double number = ...
val Array[(Seq[String], Map[Seq[String], Double])] something = ...
val String pattern = ...
तुलना/mathods तेजी (नेत्रहीन), नहीं प्रकार के।
यदि आप इस प्रकार के बिना और बिना किसी उदाहरण को जोड़ते हैं तो यह कारण स्पष्ट होगा। –
निर्भर करता है। कभी-कभी जब दाएं हाथ की साइट जटिल होती है (विशेष रूप से जब एपीआई बनाते हैं) तो आपको प्रकारों को एनोटेट करना चाहिए क्योंकि यह संकलन समय पर कई बग पकड़ता है। – Raphael