@override एनोटेशन

Question

मैं @Override एनोटेशन डाल करने के लिए जब मैं एक इंटरफ़ेस को लागू (एक अमूर्त वर्ग पर हावी नहीं) की जरूरत है?

और @Override एनोटेशन क्या हासिल होता है?

Answer 1

जावा 5 में, आपको जावा 6 में इंटरफ़ेस से प्राप्त विधि को लागू करते समय @Override नहीं जोड़ना चाहिए, आपको (या आपको एक कंपाइलर चेतावनी मिलनी चाहिए) चाहिए।

@Override दावा करता है कि किसी विधि को कुछ ओवरराइड करने का इरादा है, और यह संकलक आपको सूचित करने का कारण बनता है, उदाहरण के लिए, क्योंकि यह ओवरराइडिंग विधि का नाम बदल दिया गया है।

Answer 2

यह अपने संकलन टूट जाता है अगर आप कहते हैं कि जब आप वास्तव में नहीं था कि आप कुछ ओवरराइड।

आप एक @Override टैग डाल नहीं है, लेकिन संकलक आप कुछ भी हावी नहीं था के अनुसार, आप एक मूक बग के बारे में आप नहीं जानते है। @ ओवरराइड टैग के साथ, आप इसके बारे में जानते हैं, और आप इसके बारे में अभी जानते हैं, बाद में नहीं।

आप को @Override एनोटेशन डालने के लिए की आवश्यकता नहीं है। लेकिन मैं हर बार ऐसा करने की सिफारिश करता हूं।

Answer 3

@override मूल रूप से संकलक को यह जांचने के लिए मजबूर करता है कि आप वास्तव में मौजूदा बेस-क्लास विधि को ओवरराइड कर रहे हैं, न कि केवल (गलती से) एक नई विधि बना रहे हैं।

Answer 4

@Override एनोटेशन संकलक उस तत्व एक तत्व एक सुपर क्लास में घोषित ओवरराइड करने के लिए है सूचित।

यह आवश्यक नहीं है, लेकिन यह एक संकलन त्रुटि उत्पन्न होगा यदि इस विधि का वास्तव में सही ढंग एक सुपर क्लास में एक विधि हावी नहीं होता।

Answer 5

हमेशा @Override का उपयोग करना अच्छा अभ्यास है, क्योंकि यह आपको कुछ अन्यथा दुर्भाग्यपूर्ण बगों को पकड़ने में मदद कर सकता है। यह कोड स्पष्टता भी बढ़ाता है। उदाहरण के लिए, उदाहरण के प्रभावी जावा में दी गई, अध्याय 6, मद # 36 की जाँच:

// Can you spot the bug? - Page 176 
package org.effectivejava.examples.chapter06.item36; 

import java.util.HashSet; 
import java.util.Set; 

public class Bigram { 
    private final char first; 
    private final char second; 

    public Bigram(char first, char second) { 
     this.first = first; 
     this.second = second; 
    } 

    public boolean equals(Bigram b) { 
     return b.first == first && b.second == second; 
    } 

    public int hashCode() { 
     return 31 * first + second; 
    } 

    public static void main(String[] args) { 
     Set<Bigram> s = new HashSet<Bigram>(); 
     for (int i = 0; i < 10; i++) 
      for (char ch = 'a'; ch <= 'z'; ch++) 
       s.add(new Bigram(ch, ch)); 
     System.out.println(s.size()); 
    } 
} 

इस विधि पहली नजर में ठीक लग सकता है लेकिन यह वास्तव में बहुत टूटा हुआ है! प्रोग्रामर equals(Object o) के अनुबंध का पालन नहीं करता है, इसके बजाय equals(Bigram b) लागू करता है, जो equals() पर निर्भर होने वाली चीज़ों को करने पर कॉल किया जाएगा; यानी Bigram के Map में उदाहरण डालें। इसलिए, यह भ्रमित, सूक्ष्म गलत व्यवहार का कारण बन जाएगा जो ट्रैक करना मुश्किल होगा, जबकि अगर प्रोग्रामर ने पहले ही @Override का उपयोग किया था, तो कंपाइलर तुरंत उन्हें समस्या के बारे में सतर्क कर देता।

Answer 6

नहीं, जावा इंटरफ़ेस को लागू करते समय @ ओवरराइड एनोटेशन डालने के लिए बाध्य नहीं करता है। आप आमतौर पर इंटरफ़ेस में घोषित विधियों को ओवरराइड कर सकते हैं जैसा कि हम आम तौर पर करते हैं। लेकिन, इंटरफ़ेस के तरीकों को ओवरराइड करते समय या अमूर्त वर्ग समेत किसी भी अभिभावक वर्ग के दौरान @ ओवरराइड एनोटेशन का उपयोग करने के लिए यह एक अच्छा अभ्यास है। क्यों? क्योंकि यह हमें संकलन में एक विधि को ओवरराइड करने में किसी भी समस्या की पहचान करने में मदद करता है।

उदाहरण के लिए: http://java-dive.blogspot.in/

class Ball{ 
     public void bounce(){ 
     } 
     } 

//////////////////////Override without @Override///////////////////////////// 

    public class FootBall{ 
    public void bounce(String s){ 
    } 
    } 

//this will compile however new FootBall().bounce(); will call parent method. 

//////////////////////Override with @Override///////////////////////////// 

    public class FootBall{ 
    @Override 
    public void bounce(String s){ 
    } 
    } 

//This will not compile as the parent class doent have any method with signature bounce(String s)