मैं अपने कोड से कुछ दोहराव को दूर करने का प्रयास कर रहा हूं और इसके द्वारा, जावा जेनरिक की मेरी समझ को और आगे बढ़ा रहा हूं।

निम्नलिखित कोड स्निपेट सामान्य प्रकार के वर्ग में निहित है:

ContainerClass<S1,S2,A>  

इस वर्ग के कार्यों में से एक में मुझे दो सेटों पर निम्नानुसार पुनरावृति करने की आवश्यकता का सामना करना पड़ा है:

for (SomeClass<S1,A> t1 : set1) {
    logic.setT1(t1);
    if(set2.isEmpty()) {
        logic.apply();
    } else {
        for(SomeClass<S2,A> t2 : set2) {
            logic.setT2(t2);
            logic.apply();
        }
    }
}

logic बस कुछ वर्ग है।

विधियों के तर्क के लिए एक और पुनरावृत्ति की आवश्यकता होती है:

for(SomeClass<S2,A> t2 : set2) {
    logic.setT2(t2);
    if(set1.isEmpty()) {
        logic.apply();
    } else {
        for (SomeClass<S1,A> t1 : set1) {
            logic.setT1(t1);
            logic.apply();
        }
    }
}

मुझे एक ऐसी विधि बनाने में कुछ परेशानी हो रही है जो प्रति तर्क कॉल दोनों मामलों को संभाल सकती है।

किसी भी मदद की बहुत सराहना की जाएगी,
अग्रिम में धन्यवाद।

अनुरोध के अनुसार, निम्नलिखित तर्क वर्ग (एक आंतरिक वर्ग) है:

private class Logic
{
    private Pair<S1,S2> currState;
    private Optional<Transition<S1,A>> t1;
    private Optional<Transition<S2,A>> t2;

    Logic()
    {
        init();
    }

    void setCurrState(Pair<S1,S2> currState)
    {
        this.currState = currState;
    }

    void setT1(Transition<S1,A> t1)
    {
        this.t1 = Optional.of(t1);
    }

    void setT2(Transition<S2,A> t2)
    {
        this.t2 = Optional.of(t2);
    }

    void apply()
    {
        if(t1.isPresent() && t2.isPresent()) {
            handleBoth();
        } else {
            handleSingle();
        }
        init();
    }

    private void add(Pair<S1,S2> to, A action)
    {
        if (!res.getStates().contains(to)){
            toReach.add(to);
            res.addState(to);
        }
        res.addAction(action);
        res.addTransition(new Transition<>(currState,action,to));
    }

    private void handleBoth()
    {
        var _t1 = t1.get();
        var _t2 = t2.get();

        if (_t1.getAction().equals(_t2.getAction()) && handshake.contains(_t1.getAction())) {
            add(Pair.pair(_t1.getTo(), _t2.getTo()), _t1.getAction());
        } else {
            handleSingle();
        }
    }

    private void handleSingle()
    {
        t1.ifPresent(_t1 -> {
            if(!handshake.contains(_t1.getAction())) 
                add(Pair.pair(_t1.getTo(),currState.second),_t1.getAction());
        });
        t2.ifPresent(_t2 -> {
            if (!handshake.contains(_t2.getAction()))
                add(Pair.pair(currState.first,_t2.getTo()),_t2.getAction());
        });
    }

    private void init()
    {
        t1 = Optional.empty();
        t2 = Optional.empty();
    }
}
0
Gal Sheldon 18 नवम्बर 2018, 16:15

1 उत्तर

सबसे बढ़िया उत्तर

ऐसा लगता है कि आप कुछ अतिरिक्त जेनरिक को Logic में जोड़ना चाहेंगे, ताकि इसे Logic<S1, S2, A> बनाया जा सके, स्वतंत्र रूप से संलग्न वर्ग से। आप जो दिखाते हैं उसके आधार पर, तर्क सममित और स्टेटलेस है कि आप निम्न विधि को Container में जोड़ सकते हैं:

public void <X1, X2> doTheThing(X1 set1, X2 set2)
{
    Logic logic = new Logic<X1, X2, A>();
    for (SomeClass<X1, A> t1 : set1) {
        logic.setT1(t1);
        if(set2.isEmpty())
            logic.apply();
        else
            for (SomeClass<S2,A> t2 : set2) {
                logic.setT2(t2);
                logic.apply();
            }
    }
}

अब आप इसे doTheThing(set1, set2) और doTheThing(set2, set1) से कॉल कर सकते हैं।

0
Mad Physicist 18 नवम्बर 2018, 15:23