जवाबों:
नहीं, जावा उपयोगकर्ता द्वारा परिभाषित ऑपरेटर को ओवरलोडिंग का समर्थन नहीं करता है। जावा का एकमात्र पहलू जो "कस्टम" ऑपरेटर ओवरलोडिंग के करीब आता है, स्ट्रिंग्स के लिए + का संचालन होता है, जिसके परिणामस्वरूप या तो स्थिरांक का समय-समय पर समापन होता है या StringBuilder / StadBuffer का उपयोग करके निष्पादन-समय का निष्कर्ष होता है। आप अपने स्वयं के ऑपरेटरों को परिभाषित नहीं कर सकते हैं जो हालांकि उसी तरह से कार्य करते हैं।
जावा जैसी (और JVM- आधारित) भाषा के लिए जो ओवरलोडिंग के लिए ऑपरेटर का समर्थन करती है , आप कोटलिन या ग्रूवी को देख सकते हैं । वैकल्पिक रूप से, आपको जावा कंपाइलर प्लगइन समाधान के साथ भाग्य मिल सकता है ।
BigIntegerजावा में उपयोग करता है, तो समान BigInteger# कोड # ऑपरेटरों का उपयोग करके देखें। मैं नहीं देखता कि प्रतिनिधि ओओपी सिद्धांतों को कैसे तोड़ते हैं - आपको अपनी आपत्तियों की तुलना में बहुत अधिक सटीक होने की आवश्यकता है। मुझे पता नहीं है कि जावा डिजाइनरों ने विभिन्न विशेषताओं को क्यों शामिल नहीं किया, लेकिन मुझे संदेह है कि संसाधन दबाव और भाषा को छोटा और अपेक्षाकृत सरल रखने की इच्छा है।
m0एक के रूप में Matrixऔर v0, v1, v2, v3, और v4के रूप में Vectorहै, बस की तुलना में कितना समय आप पर ले जाता है सही ढंग से निम्नलिखित गणितीय अभिव्यक्ति की व्याख्या m0.transpose().mult(v0.add(v1.mult(v2)).cross(v3)).sub(v4);। ऑपरेटर को ओवरलोडिंग के लिए समर्थन शामिल किया गया था, इसे लिखा जा सकता था m0.transpose() * (v0 + v1 * v2).cross(v3) - v4;।
+स्ट्रिंग्स के लिए अतिभारित होने वाले सभी लोगों के अलावा , -फ्लोटिंग पॉइंट और पूर्णांक संचालन दोनों के लिए भी अतिभारित किया जाता है, जैसा कि हैं *और /।
[संपादित करें]
%फ्लोटिंग पॉइंट के लिए भी अतिभारित है, जो C या C ++ पृष्ठभूमि वाले लोगों के लिए थोड़ा आश्चर्यचकित करने वाला हो सकता है।
जावा ऑपरेटर को ओवरलोडिंग की अनुमति नहीं देता है। पसंदीदा तरीका यह है कि आप कार्रवाई करने के लिए अपनी कक्षा में एक विधि को परिभाषित करें: a.add(b)इसके बजाय a + b। आप अन्य बिट्स का एक सारांश देख सकते हैं, जो जावा सी से बाहर की भाषाओं की तरह है: सी और सी ++ से हटाई गई विशेषताएँ
आप इसे स्वयं नहीं कर सकते क्योंकि जावा ऑपरेटर ओवरलोडिंग की अनुमति नहीं देता है।
एक अपवाद के साथ , हालांकि। + और + = स्ट्रिंग वस्तुओं के लिए अतिभारित हैं।
&, |और ^के लिए ओवरलोड कर रहे हैं booleanऔर अभिन्न प्रकार के। और वास्तव में, अंकगणितीय और संबंधपरक ऑपरेटर विभिन्न संख्यात्मक प्रकारों के लिए अतिभारित होते हैं। (बेशक, ओवरलोड्स के शब्दार्थ बहुत करीब हैं ...)
जैसा कि कई अन्य लोगों ने उत्तर दिया है: जावा उपयोगकर्ता परिभाषित ऑपरेटर ओवरलोडिंग का समर्थन नहीं करता है।
शायद यह ऑफ-टॉपिक है, लेकिन मैं कुछ चीजों पर टिप्पणी करना चाहता हूं जो मैंने कुछ उत्तरों में पढ़ी हैं।
पठनीयता के बारे में।
की तुलना करें:
दुबारा देखो!
कौन सा अधिक पठनीय है?
एक प्रोग्रामिंग भाषा जो उपयोगकर्ता-परिभाषित प्रकारों के निर्माण की अनुमति देती है, उन्हें उसी तरह से कार्य करने की अनुमति देनी चाहिए जैसे अंतर्निहित प्रकार (या आदिम प्रकार)।
इसलिए जावा जेनेरिक प्रोग्रामिंग के एक मूल सिद्धांत को तोड़ता है:
हमें उपयोगकर्ता-परिभाषित प्रकारों की वस्तुओं के साथ अंतर्निहित प्रकारों की वस्तुओं को बदलने में सक्षम होना चाहिए।
(आप सोच रहे होंगे: "क्या उसने 'निर्मित की वस्तुएँ' कहा था?" हाँ, यहाँ देखें ।)
स्ट्रिंग संघनन के बारे में:
गणितज्ञ सेट पर कम्यूटेटिव ऑपरेशन के लिए प्रतीक + का उपयोग करते हैं।
तो हम यह सुनिश्चित कर सकते हैं कि ए + बी = बी + ए।
स्ट्रिंग का संघनन (अधिकांश प्रोग्रामिंग भाषाओं में) इस सामान्य गणितीय संकेतन का सम्मान नहीं करता है।
a := "hello"; b := "world"; c := (a + b = b + a);
या जावा में:
String a = "hello"; String b = "world"; boolean c = (a + b).equals(b + a);
अतिरिक्त:
ध्यान दें कि जावा समानता और पहचान कैसे भ्रमित होती है। == (समानता) प्रतीक का अर्थ है:
ए। आदिम प्रकारों के लिए समानता।
ख। उपयोगकर्ता-परिभाषित प्रकारों के लिए पहचान-जांच, इसलिए, हम समानता के लिए फ़ंक्शन बराबर () का उपयोग करने के लिए मजबूर हैं ।
लेकिन ... ऑपरेटर ओवरलोडिंग के साथ इसका क्या करना है?
यदि भाषा ऑपरेटर को ओवरलोडिंग की अनुमति देती है, तो उपयोगकर्ता समानता ऑपरेटर को उचित अर्थ दे सकता है।
==का उपयोग जावा में समानता के लिए किया जाता है, जैसे कि C और C ++ में। इससे ऑपरेटर के ओवरलोडिंग से कोई लेना-देना नहीं है।
एक जावा ऑपरेटर ओवरलोडिंग का प्रयास कर सकता है । इसकी अपनी सीमाएं हैं, लेकिन यह कोशिश करने लायक है कि क्या आप वास्तव में ऑपरेटर ओवरलोडिंग का उपयोग करना चाहते हैं।
बस अपने Java कोड के साथ Xtend का उपयोग करें। यह ऑपरेटर ओवरलोडिंग का समर्थन करता है:
package com.example;
@SuppressWarnings("all")
public class Test {
protected int wrapped;
public Test(final int value) {
this.wrapped = value;
}
public int operator_plus(final Test e2) {
return (this.wrapped + e2.wrapped);
}
}
package com.example
class Test2 {
new() {
val t1 = new Test(3)
val t2 = new Test(5)
val t3 = t1 + t2
}
}आधिकारिक वेबसाइट पर, प्रत्येक ऑपरेटर के लिए लागू करने के तरीकों की एक सूची है!
या, आप जावा ग्रूवी बना सकते हैं और जो आप चाहते हैं उसे प्राप्त करने के लिए इन कार्यों को ओवरलोड कर सकते हैं
//plus() => for the + operator
//multiply() => for the * operator
//leftShift() = for the << operator
// ... and so on ...
class Fish {
def leftShift(Fish fish) {
print "You just << (left shifted) some fish "
}
}
def fish = new Fish()
def fish2 = new Fish()
fish << fish2कौन ग्रूवी होना / उपयोग नहीं करना चाहता है? : डी
नहीं, आप जावा में उसी तरह संकलित सरोवर जार का उपयोग नहीं कर सकते। यह अभी भी जावा के लिए एक संकलक त्रुटि है।
C ++ के विपरीत, जावा उपयोगकर्ता परिभाषित ऑपरेटर ओवरलोडिंग का समर्थन नहीं करता है। ओवरलोडिंग आंतरिक रूप से जावा में की जाती है।
हम +उदाहरण के लिए (प्लस) ले सकते हैं :
int a = 2 + 4;
string = "hello" + "world";यहां, प्लस दो पूर्णांक संख्याओं को जोड़ता है और दो तारों को मिलाता है। इसलिए हम कह सकते हैं कि जावा आंतरिक ऑपरेटर को ओवरलोडिंग का समर्थन करता है लेकिन उपयोगकर्ता परिभाषित नहीं है।