क्या जावा में कन्स्ट्रक्टर से अमूर्त विधि को कॉल करना ठीक है?

Question

मान लीजिए कि मेरे पास एक सार बेस क्लास है जो रननेबल इंटरफेस लागू करता है।

public abstract class Base implements Runnable { 

    protected int param; 

    public Base(final int param) { 
     System.out.println("Base constructor"); 
     this.param = param; 
     // I'm using this param here 
     new Thread(this).start(); 
     System.out.println("Derivative thread created with param " + param); 
    } 

    @Override 
    abstract public void run(); 
} 

और यहां कुछ व्युत्पन्न वर्गों में से एक है।

public class Derivative extends Base { 

    public Derivative(final int param) { 
     super(param); 
    } 

    @Override 
    public void run() { 
     System.out.println("Derivative is running with param " + param); 
    } 

    public static void main(String[] args) { 
     Derivative thread = new Derivative(1); 
    } 

} 

मुद्दा यह है कि मैं अपने बेस वर्ग के बजाय यह हर बार कॉपी करने की कुछ सामान्य चीजें करते चाहते हैं। वास्तव में, यह ठीक चल रहा है, उत्पादन हमेशा एक ही है:

बेस निर्माता परम के साथ 1 व्युत्पन्न परम 1

साथ चल रहा है लेकिन यह जावा में सुरक्षित है बनाया व्युत्पन्न धागा एक धागा बुला शुरू करने के लिए कन्स्ट्रक्टर में अमूर्त विधि? क्योंकि, सी ++ और सी # में ज्यादातर मामलों में यह असुरक्षित है, जहां तक ​​मुझे पता है। धन्यवाद!

Answer 1

इस कोड को दर्शाता कर सकते हैं तुम क्यों कभी नहीं कॉल एक सार विधि, या किसी अन्य overridable विधि, एक निर्माता से कार्य करना चाहिए:

abstract class Super { 
    Super() { 
     doSubStuff(); 
    } 
    abstract void doSubStuff(); 
} 

class Sub extends Super { 
    String s = "Hello world"; 

    void doSubStuff() { 
     System.out.println(s); 
    } 
} 

public static void main(String[] args) { 
    new Sub(); 
} 

जब चलाने के लिए, यह प्रिंट null। इसका मतलब है कि एक निर्माता में केवल "सुरक्षित" विधियां निजी और/या अंतिम हैं।

दूसरी ओर, आपका कोड वास्तव में एक निर्माता से एक अमूर्त विधि नहीं कहता है। इसके बजाय, आप, प्रसंस्करण के लिए एक और धागा है, जो भी बदतर है करने के लिए एक गैर-आरंभिकृत वस्तु पारित के बाद से धागा आप शुरू कर रहे हैं प्राथमिकता दी जा सकती है और इससे पहले कि आपके Base इसके प्रारंभ खत्म निष्पादित।

Answer 2

एक निर्माता से एक अमूर्त विधि को कॉल करने के लिए यह एक बहुत ही बुरा अभ्यास है। ओवरराइडिंग को रोकने के लिए रचनाकारों से बुलाए जाने वाले तरीके हमेशा निजी या अंतिम होना चाहिए।

एक सवाल here

Answer 3

नहीं

एक अच्छा विचार के बाद से जब चलाने() उत्पन्न होता है, व्युत्पन्न वस्तु प्रारंभ नहीं किया गया है यह लिंक देखें। यदि रन() व्युत्पन्न में किसी भी राज्य पर निर्भर करता है, तो यह असफल हो सकता है।

आपके साधारण मामले में यह काम करता है। लेकिन फिर subclass के लिए कोई बात नहीं है। आप बस

public Base(final int param, Runnable action) { 

    new Thread(action).start(); 

Answer 4

this निर्माता से बाहर पासिंग कहा जाता है "निर्माता से दे this भागने", और कुछ विशेष रूप से गंदा और अजीब कीड़े को जन्म दे सकता है, क्योंकि वस्तु एक असंगत स्थिति में हो सकता है।

यह विशेष रूप से मामला है जब this, एक और धागा में भेजा जाता है इस उदाहरण में है। एक थ्रेड के भीतर बयानों को पुन: व्यवस्थित करने के लिए JVMs के कारण, आप अपरिभाषित व्यवहार/स्थिति उत्पन्न कर सकते हैं।