एक जावा बिल्डर वर्ग को उपवर्ग करना

Question

दे दो यह डॉ डोब्स लेख , और विशेष रूप से बिल्डर पैटर्न, हम कैसे एक बिल्डर उपवर्गीकरण के मामले निपटेंगे? उदाहरण के कट-डाउन संस्करण को लेना जहां हम जीएमओ लेबलिंग को जोड़ने के लिए उप-वर्ग करना चाहते हैं, एक भोली कार्यान्वयन होगा:

public class NutritionFacts {                                                                                                    

    private final int calories;                                                                                                  

    public static class Builder {                                                                                                
        private int calories = 0;                                                                                                

        public Builder() {}                                                                                                      

        public Builder calories(int val) { calories = val; return this; }                                                                                                                        

        public NutritionFacts build() { return new NutritionFacts(this); }                                                       
    }                                                                                                                            

    protected NutritionFacts(Builder builder) {                                                                                  
        calories = builder.calories;                                                                                             
    }                                                                                                                            
}

उपवर्ग:

public class GMOFacts extends NutritionFacts {                                                                                   

    private final boolean hasGMO;                                                                                                

    public static class Builder extends NutritionFacts.Builder {                                                                 

        private boolean hasGMO = false;                                                                                          

        public Builder() {}                                                                                                      

        public Builder GMO(boolean val) { hasGMO = val; return this; }                                                           

        public GMOFacts build() { return new GMOFacts(this); }                                                                   
    }                                                                                                                            

    protected GMOFacts(Builder builder) {                                                                                        
        super(builder);                                                                                                          
        hasGMO = builder.hasGMO;                                                                                                 
    }                                                                                                                            
}

अब, हम इस तरह कोड लिख सकते हैं:

GMOFacts.Builder b = new GMOFacts.Builder();
b.GMO(true).calories(100);

लेकिन, अगर हमें ऑर्डर गलत मिलता है, तो यह सब विफल हो जाता है:

GMOFacts.Builder b = new GMOFacts.Builder();
b.calories(100).GMO(true);

समस्या निश्चित रूप से है कि NutritionFacts.Builderरिटर्न ए NutritionFacts.Builder, ए नहीं है GMOFacts.Builder, इसलिए हम इस समस्या को कैसे हल करते हैं, या उपयोग करने के लिए एक बेहतर पैटर्न है?

नोट: एक समान प्रश्न का यह उत्तर उन कक्षाओं को प्रदान करता है जो मेरे पास हैं; मेरा प्रश्न यह सुनिश्चित करने की समस्या के बारे में है कि बिल्डर कॉल सही क्रम में हैं।

Comments

मुझे लगता है कि निम्नलिखित लिंक एक अच्छे दृष्टिकोण का वर्णन करता है: egalluzzo.blogspot.co.at/2010/06/…

— stuXnet

लेकिन आप कैसे build()आउटपुट करते हैं b.GMO(true).calories(100)?

— श्रीधर सरनोबत

Answer 1

आप इसे जेनेरिक का उपयोग करके हल कर सकते हैं। मुझे लगता है कि इसे "उत्सुकता से आवर्ती सामान्य पैटर्न" कहा जाता है

बेस क्लास बिल्डर तरीकों के रिटर्न प्रकार को एक सामान्य तर्क बनाएं।

public class NutritionFacts {

    private final int calories;

    public static class Builder<T extends Builder<T>> {

        private int calories = 0;

        public Builder() {}

        public T calories(int val) {
            calories = val;
            return (T) this;
        }

        public NutritionFacts build() { return new NutritionFacts(this); }
    }

    protected NutritionFacts(Builder<?> builder) {
        calories = builder.calories;
    }
}

अब जेनेरिक तर्क के रूप में व्युत्पन्न वर्ग बिल्डर के साथ बेस बिल्डर को इंस्टेंट करें।

public class GMOFacts extends NutritionFacts {

    private final boolean hasGMO;

    public static class Builder extends NutritionFacts.Builder<Builder> {

        private boolean hasGMO = false;

        public Builder() {}

        public Builder GMO(boolean val) {
            hasGMO = val;
            return this;
        }

        public GMOFacts build() { return new GMOFacts(this); }
    }

    protected GMOFacts(Builder builder) {
        super(builder);
        hasGMO = builder.hasGMO;
    }
}

Comments

हम्म, मुझे लगता है कि मुझे (ए) या तो एक नया प्रश्न पोस्ट करना होगा, (बी) के implementsबजाय फिर से नया स्वरूप extends, या (सी) सब कुछ दूर कर देगा। मेरे पास अब एक अजीब संकलन त्रुटि है leafBuilder.leaf().leaf()और leafBuilder.mid().leaf()ठीक है, लेकिन leafBuilder.leaf().mid().leaf()विफल रहता है ...

— केन YN

@gkamal का return (T) this;परिणाम unchecked or unsafe operationsचेतावनी है। यह बचना असंभव है, है ना?

— दिमित्री मिन्कोवस्की

unchecked castचेतावनी को हल करने के लिए , अन्य उत्तरों के बीच सुझाए गए समाधान को देखें: stackoverflow.com/a/34741836/3114959

— Stepan Vavra

ध्यान दें कि Builder<T extends Builder>वास्तव में एक कच्चा माल है - यह होना चाहिए Builder<T extends Builder<T>>।

— बोरिस द स्पाइडर

@ user2957378 के Builderलिए GMOFactsभी सामान्य होना आवश्यक है Builder<B extends Builder<B>> extends NutritionFacts.Builder<Builder>- और यह पैटर्न आवश्यकतानुसार कई स्तरों तक जारी रह सकता है। यदि आप एक गैर-जेनेरिक बिल्डर की घोषणा करते हैं तो आप पैटर्न का विस्तार नहीं कर सकते हैं।

— बोरिस द स्पाइडर

Answer 2

सिर्फ रिकॉर्ड के लिए, छुटकारा पाने के लिए

unchecked or unsafe operations चेतावनी

return (T) this;@dimadima और @Thomas N के कथन के अनुसार, कुछ मामलों में निम्नलिखित समाधान लागू होते हैं।

abstractबिल्डर जो जेनेरिक प्रकार ( T extends Builderइस मामले में) की घोषणा करता है और protected abstract T getThis()सार विधि घोषित करता है उसे निम्नानुसार बनाएं :

public abstract static class Builder<T extends Builder<T>> {

    private int calories = 0;

    public Builder() {}

    /** The solution for the unchecked cast warning. */
    public abstract T getThis();

    public T calories(int val) {
        calories = val;

        // no cast needed
        return getThis();
    }

    public NutritionFacts build() { return new NutritionFacts(this); }
}

अधिक जानकारी के लिए http://www.angelikalanger.com/GenericsFAQ/FAQSections/ProgrammingIdioms.html#FAQ205 देखें।

Comments

क्यों build()विधि यहाँ NutrutionFacts लौटा रही है?

— mvd

@ mvd क्योंकि यह सवाल का जवाब है? उपप्रकारों में, आप इसे इस तरह से ओवरराइड करेंगे जैसेpublic GMOFacts build() { return new GMOFacts(this); }

— चरण वारण

समस्या तब होती है जब हम दूसरा बच्चा जोड़ना चाहते हैं BuilderC extends BuilderBऔर BuilderB extends BuilderAजब BuilderBनहीं हैabstract

— sosite

यह सवाल का जवाब नहीं है, क्योंकि आधार वर्ग अमूर्त नहीं हो सकता है!

— रोलैंड

"उस बिल्डर को अमूर्त बनाएं जो सामान्य प्रकार की घोषणा करता है" - क्या होगा अगर मैं सीधे उस बिल्डर का उपयोग करना चाहता हूं?

— डेज़ी

Answer 3

एक ब्लॉग पोस्ट के आधार पर , इस दृष्टिकोण को सभी गैर-पत्ती वर्गों को अमूर्त करने की आवश्यकता है, और सभी पत्ती कक्षाएं अंतिम होनी चाहिए।

public abstract class TopLevel {
    protected int foo;
    protected TopLevel() {
    }
    protected static abstract class Builder
        <T extends TopLevel, B extends Builder<T, B>> {
        protected T object;
        protected B thisObject;
        protected abstract T createObject();
        protected abstract B thisObject();
        public Builder() {
            object = createObject();
            thisObject = thisObject();
        }
        public B foo(int foo) {
            object.foo = foo;
            return thisObject;
        }
        public T build() {
            return object;
        }
    }
}

फिर, आपके पास कुछ मध्यवर्ती वर्ग हैं जो इस वर्ग और इसके बिल्डर का विस्तार करते हैं, और जितने की आवश्यकता है उतने अधिक:

public abstract class SecondLevel extends TopLevel {
    protected int bar;
    protected static abstract class Builder
        <T extends SecondLevel, B extends Builder<T, B>> extends TopLevel.Builder<T, B> {
        public B bar(int bar) {
            object.bar = bar;
            return thisObject;
        }
    }
}

और, अंत में एक ठोस पत्ता वर्ग जो किसी भी क्रम में अपने माता-पिता के सभी बिल्डर तरीकों को कॉल कर सकता है:

public final class LeafClass extends SecondLevel {
    private int baz;
    public static final class Builder extends SecondLevel.Builder<LeafClass,Builder> {
        protected LeafClass createObject() {
            return new LeafClass();
        }
        protected Builder thisObject() {
            return this;
        }
        public Builder baz(int baz) {
            object.baz = baz;
            return thisObject;
        }
    }
}

फिर, आप पदानुक्रम में किसी भी वर्ग से किसी भी क्रम में विधियों को कॉल कर सकते हैं:

public class Demo {
    LeafClass leaf = new LeafClass.Builder().baz(2).foo(1).bar(3).build();
}

Comments

क्या आप जानते हैं कि पत्ती वर्गों को अंतिम रूप देने की आवश्यकता क्यों है? मुझे लगता है कि मेरी ठोस कक्षाएं उपवर्गीय होंगी, लेकिन कंपाइलर के प्रकार को समझने का कोई तरीका नहीं मिला है B, यह हमेशा आधार वर्ग के रूप में सामने आता है।

— डेविड गैंस्टर

नोट करें कि लीफक्लास में बिल्डर वर्ग उसी <T extends SomeClass, B extends SomeClass.Builder<T,B>> extends SomeClassParent.Builder<T,B>पैटर्न का पालन नहीं करता है जो मध्यस्थ द्वितीयक श्रेणी करता है, इसके बजाय यह विशिष्ट प्रकार की घोषणा करता है। जब तक आप विशिष्ट प्रकारों का उपयोग कर पत्ते को प्राप्त नहीं करते हैं, तब तक आप क्लास नहीं लगा सकते हैं, लेकिन एक बार जब आप ऐसा कर लेते हैं, तो आप इसे आगे नहीं बढ़ा सकते क्योंकि आप विशिष्ट प्रकारों का उपयोग कर रहे हैं और उत्सुकता से पुनरावृत्ति टेम्पलेट पैटर्न को छोड़ दिया है। यह लिंक मदद कर सकता है: angelikalanger.com/GenericsFAQ/FAQSections/…

— Q23

Answer 4

आप इस calories()विधि को भी ओवरराइड कर सकते हैं , और इसे विस्तारित बिल्डर को वापस कर सकते हैं । यह संकलित करता है क्योंकि जावा सहसंयोजक वापसी प्रकारों का समर्थन करता है ।

public class GMOFacts extends NutritionFacts {
    private final boolean hasGMO;
    public static class Builder extends NutritionFacts.Builder {
        private boolean hasGMO = false;
        public Builder() {
        }
        public Builder GMO(boolean val)
        { hasGMO = val; return this; }
        public Builder calories(int val)
        { super.calories(val); return this; }
        public GMOFacts build() {
            return new GMOFacts(this);
        }
    }
    [...]
}

Comments

आह, मुझे नहीं पता था कि, मैं सी ++ पृष्ठभूमि से आता हूं। इस छोटे से उदाहरण के लिए यह एक उपयोगी दृष्टिकोण है, लेकिन एक पूर्ण विकसित वर्ग के साथ सभी तरीकों को दोहराते हुए एक दर्द हो जाता है, और उस पर एक त्रुटि-ग्रस्त दर्द होता है। हालांकि मुझे कुछ नया सिखाने के लिए +1!

— केन वाईएन

यह मुझे लगता है कि यह कुछ भी हल नहीं करता है। माता-पिता को उप-वर्गीकृत करने का कारण (आईएमओ) माता-पिता के तरीकों का उपयोग उन्हें ओवरराइड किए बिना फिर से करना है। यदि बिल्डर साधारण तरीकों को छोड़कर किसी भी वास्तविक लॉजिक के साथ ऑब्जेक्ट को ऑब्जेक्ट मान देते हैं, तो ओवरराइडिंग विधि में पैरेंट विधि को कॉल करने का कोई मूल्य नहीं है।

— डेवलपर ड्यूड

उत्तर प्रश्न में वर्णित समस्या को हल करता है: बिल्डर का उपयोग करने वाला कोड दोनों आदेशों के साथ संकलित करता है। चूंकि एक तरीका संकलित है और दूसरा नहीं है, इसलिए मुझे लगता है कि सभी के बाद कुछ मूल्य होना चाहिए।

— फ्लावियो

Answer 5

Builderपैटर्न के अनुसार कक्षाएं बनाने का एक और तरीका भी है , जो "उत्तराधिकार पर पसंदीदा रचना" के अनुरूप है।

एक इंटरफ़ेस परिभाषित करें, जो मूल वर्ग Builderको विरासत में मिलेगा:

public interface FactsBuilder<T> {

    public T calories(int val);
}

का कार्यान्वयन NutritionFactsलगभग समान है ( Builder'FactsBuilder' इंटरफ़ेस को लागू करने के अलावा ):

public class NutritionFacts {

    private final int calories;

    public static class Builder implements FactsBuilder<Builder> {
        private int calories = 0;

        public Builder() {
        }

        @Override
        public Builder calories(int val) {
            return this;
        }

        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }

    protected NutritionFacts(Builder builder) {
        calories = builder.calories;
    }
}

Builderएक बच्चे के वर्ग के एक ही इंटरफ़ेस (विभिन्न सामान्य कार्यान्वयन को छोड़कर) का विस्तार करना चाहिए:

public static class Builder implements FactsBuilder<Builder> {
    NutritionFacts.Builder baseBuilder;

    private boolean hasGMO = false;

    public Builder() {
        baseBuilder = new NutritionFacts.Builder();
    }

    public Builder GMO(boolean val) {
        hasGMO = val;
        return this;
    }

    public GMOFacts build() {
        return new GMOFacts(this);
    }

    @Override
    public Builder calories(int val) {
        baseBuilder.calories(val);
        return this;
    }
}

ध्यान दें, कि NutritionFacts.Builderअंदर एक क्षेत्र है GMOFacts.Builder(कहा जाता है baseBuilder)। इसी नाम की FactsBuilderइंटरफ़ेस कॉल विधि से लागू baseBuilderविधि:

@Override
public Builder calories(int val) {
    baseBuilder.calories(val);
    return this;
}

के कंस्ट्रक्टर में भी बड़ा बदलाव है GMOFacts(Builder builder)। पैरेंट क्लास कंस्ट्रक्टर को कंस्ट्रक्टर में पहला कॉल उपयुक्त पास करना चाहिए NutritionFacts.Builder:

protected GMOFacts(Builder builder) {
    super(builder.baseBuilder);
    hasGMO = builder.hasGMO;
}

GMOFactsवर्ग का पूर्ण कार्यान्वयन :

public class GMOFacts extends NutritionFacts {

    private final boolean hasGMO;

    public static class Builder implements FactsBuilder<Builder> {
        NutritionFacts.Builder baseBuilder;

        private boolean hasGMO = false;

        public Builder() {
        }

        public Builder GMO(boolean val) {
            hasGMO = val;
            return this;
        }

        public GMOFacts build() {
            return new GMOFacts(this);
        }

        @Override
        public Builder calories(int val) {
            baseBuilder.calories(val);
            return this;
        }
    }

    protected GMOFacts(Builder builder) {
        super(builder.baseBuilder);
        hasGMO = builder.hasGMO;
    }
}

Answer 6

कई बिल्डर उत्तराधिकार का पूर्ण 3 स्तरीय उदाहरण इस तरह दिखेगा :

(बिल्डर के लिए एक कॉपी कंस्ट्रक्टर वाले संस्करण के लिए नीचे दूसरा उदाहरण देखें)

प्रथम स्तर - माता-पिता (संभावित सार)

import lombok.ToString;

@ToString
@SuppressWarnings("unchecked")
public abstract class Class1 {
    protected int f1;

    public static class Builder<C extends Class1, B extends Builder<C, B>> {
        C obj;

        protected Builder(C constructedObj) {
            this.obj = constructedObj;
        }

        B f1(int f1) {
            obj.f1 = f1;
            return (B)this;
        }

        C build() {
            return obj;
        }
    }
}

दूसरा स्तर

import lombok.ToString;

@ToString(callSuper=true)
@SuppressWarnings("unchecked")
public class Class2 extends Class1 {
    protected int f2;

    public static class Builder<C extends Class2, B extends Builder<C, B>> extends Class1.Builder<C, B> {
        public Builder() {
            this((C) new Class2());
        }

        protected Builder(C obj) {
            super(obj);
        }

        B f2(int f2) {
            obj.f2 = f2;
            return (B)this;
        }
    }
}

तीसरे स्तर

import lombok.ToString;

@ToString(callSuper=true)
@SuppressWarnings("unchecked")
public class Class3 extends Class2 {
    protected int f3;

    public static class Builder<C extends Class3, B extends Builder<C, B>> extends Class2.Builder<C, B> {
        public Builder() {
            this((C) new Class3());
        }

        protected Builder(C obj) {
            super(obj);
        }

        B f3(int f3) {
            obj.f3 = f3;
            return (B)this;
        }
    }
}

और उपयोग का एक उदाहरण

public class Test {
    public static void main(String[] args) {
        Class2 b1 = new Class2.Builder<>().f1(1).f2(2).build();
        System.out.println(b1);
        Class2 b2 = new Class2.Builder<>().f2(2).f1(1).build();
        System.out.println(b2);

        Class3 c1 = new Class3.Builder<>().f1(1).f2(2).f3(3).build();
        System.out.println(c1);
        Class3 c2 = new Class3.Builder<>().f3(3).f1(1).f2(2).build();
        System.out.println(c2);
        Class3 c3 = new Class3.Builder<>().f3(3).f2(2).f1(1).build();
        System.out.println(c3);
        Class3 c4 = new Class3.Builder<>().f2(2).f3(3).f1(1).build();
        System.out.println(c4);
    }
}

बिल्डर के लिए कॉपी कंस्ट्रक्टर की विशेषता वाला एक लंबा लंबा संस्करण:

प्रथम स्तर - माता-पिता (संभावित सार)

import lombok.ToString;

@ToString
@SuppressWarnings("unchecked")
public abstract class Class1 {
    protected int f1;

    public static class Builder<C extends Class1, B extends Builder<C, B>> {
        C obj;

        protected void setObj(C obj) {
            this.obj = obj;
        }

        protected void copy(C obj) {
            this.f1(obj.f1);
        }

        B f1(int f1) {
            obj.f1 = f1;
            return (B)this;
        }

        C build() {
            return obj;
        }
    }
}

दूसरा स्तर

import lombok.ToString;

@ToString(callSuper=true)
@SuppressWarnings("unchecked")
public class Class2 extends Class1 {
    protected int f2;

    public static class Builder<C extends Class2, B extends Builder<C, B>> extends Class1.Builder<C, B> {
        public Builder() {
            setObj((C) new Class2());
        }

        public Builder(C obj) {
            this();
            copy(obj);
        }

        @Override
        protected void copy(C obj) {
            super.copy(obj);
            this.f2(obj.f2);
        }

        B f2(int f2) {
            obj.f2 = f2;
            return (B)this;
        }
    }
}

तीसरे स्तर

import lombok.ToString;

@ToString(callSuper=true)
@SuppressWarnings("unchecked")
public class Class3 extends Class2 {
    protected int f3;

    public static class Builder<C extends Class3, B extends Builder<C, B>> extends Class2.Builder<C, B> {
        public Builder() {
            setObj((C) new Class3());
        }

        public Builder(C obj) {
            this();
            copy(obj);
        }

        @Override
        protected void copy(C obj) {
            super.copy(obj);
            this.f3(obj.f3);
        }

        B f3(int f3) {
            obj.f3 = f3;
            return (B)this;
        }
    }
}

और उपयोग का एक उदाहरण

public class Test {
    public static void main(String[] args) {
        Class3 c4 = new Class3.Builder<>().f2(2).f3(3).f1(1).build();
        System.out.println(c4);

        // Class3 builder copy
        Class3 c42 = new Class3.Builder<>(c4).f2(12).build();
        System.out.println(c42);
        Class3 c43 = new Class3.Builder<>(c42).f2(22).f1(11).build();
        System.out.println(c43);
        Class3 c44 = new Class3.Builder<>(c43).f3(13).f1(21).build();
        System.out.println(c44);
    }
}

Answer 7

यदि आप अपनी आंख को कोण ब्रैकेट या तीन पर बाहर निकालना नहीं चाहते हैं, या शायद आपको महसूस नहीं होता है ... उम्म ... मेरा मतलब है ... खांसी ... आपकी टीम के बाकी लोग जल्दी से उत्सुकता से समझेंगे आवर्ती जेनरिक पैटर्न, आप ऐसा कर सकते हैं:

public class TestInheritanceBuilder {
  public static void main(String[] args) {
    SubType.Builder builder = new SubType.Builder();
    builder.withFoo("FOO").withBar("BAR").withBaz("BAZ");
    SubType st = builder.build();
    System.out.println(st.toString());
    builder.withFoo("BOOM!").withBar("not getting here").withBaz("or here");
  }
}

द्वारा समर्थित

public class SubType extends ParentType {
  String baz;
  protected SubType() {}

  public static class Builder extends ParentType.Builder {
    private SubType object = new SubType();

    public Builder withBaz(String baz) {
      getObject().baz = baz;
      return this;
    }

    public Builder withBar(String bar) {
      super.withBar(bar);
      return this;
    }

    public Builder withFoo(String foo) {
      super.withFoo(foo);
      return this;
    }

    public SubType build() {
      // or clone or copy constructor if you want to stamp out multiple instances...
      SubType tmp = getObject();
      setObject(new SubType());
      return tmp;
    }

    protected SubType getObject() {
      return object;
    }

    private void setObject(SubType object) {
      this.object = object;
    }
  }

  public String toString() {
    return "SubType2{" +
        "baz='" + baz + '\'' +
        "} " + super.toString();
  }
}

और मूल प्रकार:

public class ParentType {
  String foo;
  String bar;

  protected ParentType() {}

  public static class Builder {
    private ParentType object = new ParentType();

    public ParentType object() {
      return getObject();
    }

    public Builder withFoo(String foo) {
      if (!"foo".equalsIgnoreCase(foo)) throw new IllegalArgumentException();
      getObject().foo = foo;
      return this;
    }

    public Builder withBar(String bar) {
      getObject().bar = bar;
      return this;
    }

    protected ParentType getObject() {
      return object;
    }

    private void setObject(ParentType object) {
      this.object = object;
    }

    public ParentType build() {
      // or clone or copy constructor if you want to stamp out multiple instances...
      ParentType tmp = getObject();
      setObject(new ParentType());
      return tmp;
    }
  }

  public String toString() {
    return "ParentType2{" +
        "foo='" + foo + '\'' +
        ", bar='" + bar + '\'' +
        '}';
  }
}

प्रमुख बिंदु:

• ऑब्जेक्ट को बिल्डर में इनकैप्सुलेट करें ताकि वंशानुक्रम आपको मूल प्रकार में रखी गई ऑब्जेक्ट पर फ़ील्ड सेट करने से रोकता है
• सुपर को कॉल यह सुनिश्चित करता है कि सुपर प्रकार बिल्डर विधियों में जोड़ा गया तर्क (यदि कोई हो) उप प्रकारों में बनाए रखा गया है।
• डाउन साइड पैरेंट क्लास में स्पुचुअल ऑब्जेक्ट क्रिएशन है (एस) ... लेकिन इसे साफ करने के तरीके के लिए नीचे देखें
• अप साइड एक नज़र में समझना बहुत आसान है, और कोई वर्बोज़ कंस्ट्रक्टर गुणों को स्थानांतरित नहीं करता है।
• यदि आपके पास अपनी बिल्डर वस्तुओं तक पहुँचने के लिए कई सूत्र हैं ... मुझे लगता है मुझे खुशी है कि मैं आप नहीं हूँ :)।

संपादित करें:

मुझे स्फूर्त वस्तु निर्माण के चारों ओर एक रास्ता मिला। पहले इसे प्रत्येक बिल्डर में जोड़ें:

private Class whoAmI() {
  return new Object(){}.getClass().getEnclosingMethod().getDeclaringClass();
}

फिर प्रत्येक बिल्डर के लिए निर्माता में:

  if (whoAmI() == this.getClass()) {
    this.obj = new ObjectToBuild();
  }

new Object(){}अनाम आंतरिक वर्ग के लिए लागत एक अतिरिक्त वर्ग फ़ाइल है

Answer 8

एक चीज जो आप कर सकते हैं, वह यह है कि आप अपनी प्रत्येक कक्षा में एक स्थिर कारखाना विधि बनाएँ:

NutritionFacts.newBuilder()
GMOFacts.newBuilder()

यह स्थिर कारखाना विधि उपयुक्त बिल्डर को लौटा देगी। आपके पास एक GMOFacts.Builderविस्तार हो सकता है NutritionFacts.Builder, यह कोई समस्या नहीं है। दृश्यता से निपटने के लिए यहां समस्या होगी ...

Answer 9

निम्नलिखित IEEE योगदान जावा में परिष्कृत धाराप्रवाह बिल्डर समस्या का एक व्यापक समाधान देता है।

यह मूल प्रश्न को वंशानुक्रम की कमी और अर्ध -असमानता की दो उप-समस्याओं में विघटित करता है और दिखाता है कि कैसे जावा में शास्त्रीय बिल्डर पैटर्न में कोड पुन: उपयोग के साथ विरासत समर्थन के लिए इन दो उप-समस्याओं का समाधान खुलता है।

Comments

इस उत्तर में सहायक होने के लिए कोई जानकारी नहीं है, कम से कम लिंक में दिए गए उत्तर का सारांश नहीं है और एक लिंक की ओर जाता है जिसके लिए लॉगिन आवश्यक है।

— सोनाटा

यह उत्तर एक आधिकारिक प्रकाशन प्राधिकरण और आधिकारिक प्रकाशन और साझा करने की प्रक्रिया के साथ एक सहकर्मी की समीक्षा सम्मेलन प्रकाशन के लिए लिंक करता है।

— mc00x1

Answer 10

मैंने एक माता-पिता, अमूर्त जेनेरिक बिल्डर वर्ग बनाया जो दो औपचारिक प्रकार के मापदंडों को स्वीकार करता है। पहला बिल्ड के द्वारा लौटाए गए ऑब्जेक्ट के प्रकार के लिए है (), दूसरा वह प्रकार है जो प्रत्येक वैकल्पिक पैरामीटर सेटर द्वारा लौटाया जाता है। नीचे माता-पिता और बच्चे के उद्देश्य के लिए कक्षाएं हैं:

// **Parent**
public abstract static class Builder<T, U extends Builder<T, U>> {
    // Required parameters
    private final String name;

    // Optional parameters
    private List<String> outputFields = null;


    public Builder(String pName) {
        name = pName;
    }

    public U outputFields(List<String> pOutFlds) {
        outputFields = new ArrayList<>(pOutFlds);
        return getThis();
    }


    /**
     * This helps avoid "unchecked warning", which would forces to cast to "T" in each of the optional
     * parameter setters..
     * @return
     */
    abstract U getThis();

    public abstract T build();



    /*
     * Getters
     */
    public String getName() {
        return name;
    }
}

 // **Child**
 public static class Builder extends AbstractRule.Builder<ContextAugmentingRule, ContextAugmentingRule.Builder> {
    // Required parameters
    private final Map<String, Object> nameValuePairsToAdd;

    // Optional parameters
    private String fooBar;


    Builder(String pName, Map<String, String> pNameValPairs) {
        super(pName);
        /**
         * Must do this, in case client code (I.e. JavaScript) is re-using
         * the passed in for multiple purposes. Doing {@link Collections#unmodifiableMap(Map)}
         * won't caught it, because the backing Map passed by client prior to wrapping in
         * unmodifiable Map can still be modified.
         */
        nameValuePairsToAdd = new HashMap<>(pNameValPairs);
    }

    public Builder fooBar(String pStr) {
        fooBar = pStr;
        return this;
    }


    @Override
    public ContextAugmentingRule build() {
        try {
            Rule r = new ContextAugmentingRule(this);
            storeInRuleByNameCache(r);
            return (ContextAugmentingRule) r;
        } catch (RuleException e) {
            throw new IllegalArgumentException(e);
        }
    }

    @Override
    Builder getThis() {
        return this;
    }
}

यह एक मेरी संतुष्टि की जरूरत को पूरा किया है।