जावा में बार-बार कोड से कैसे बचें?

Question

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

 if(i == 1){ 
      uf.union(len*len, xyTo1D(i,j)); 
      if(existAndOpen(i+1,j)){ 
       uf2.union(xyTo1D(i+1,j), xyTo1D(i,j)); 
       uf.union(xyTo1D(i,j), xyTo1D(i+1,j)); 
      } 
      if(existAndOpen(i-1,j)){ 
       uf2.union(xyTo1D(i-1,j), xyTo1D(i,j)); 
       uf.union(xyTo1D(i,j), xyTo1D(i-1,j)); 
      } 
      if(existAndOpen(i,j-1)){ 
       uf2.union(xyTo1D(i,j-1), xyTo1D(i,j)); 
       uf.union(xyTo1D(i,j), xyTo1D(i,j-1)); 
      } 
      if(!(j == len && i == len)){ 
       if(existAndOpen(i,j+1)){ 
        uf2.union(xyTo1D(i,j+1), xyTo1D(i,j)); 
        uf.union(xyTo1D(i,j), xyTo1D(i,j+1)); 
       } 
      } 
     } 
     else{ 
     if(existAndFull(i+1,j)){ 
      uf2.union(xyTo1D(i+1,j), xyTo1D(i,j)); 
      uf.union(xyTo1D(i,j), xyTo1D(i+1,j)); 
     } 
     if(existAndFull(i-1,j)){ 
      uf2.union(xyTo1D(i-1,j), xyTo1D(i,j)); 
      uf.union(xyTo1D(i,j), xyTo1D(i-1,j)); 
     } 
     if(existAndFull(i,j-1)){ 
      uf2.union(xyTo1D(i,j-1), xyTo1D(i,j)); 
      uf.union(xyTo1D(i,j), xyTo1D(i,j-1)); 
     } 
     if(!(j== len && i == len)){ 
      if(existAndFull(i,j+1)){ 
       uf2.union(xyTo1D(i,j+1), xyTo1D(i,j)); 
       uf.union(xyTo1D(i,j), xyTo1D(i,j+1)); 
      } 
     } 
     if(existAndOpen(i+1,j)){ 
      uf.union(xyTo1D(i,j), xyTo1D(i+1,j)); 
     } 
     if(existAndOpen(i-1,j)){ 
      uf.union(xyTo1D(i,j), xyTo1D(i-1,j)); 
     } 
     if(existAndOpen(i,j-1)){ 
      uf.union(xyTo1D(i,j), xyTo1D(i,j-1)); 
     } 
     if(!(j== len && i == len)){ 
      if(existAndOpen(i,j+1)){ 
       uf.union(xyTo1D(i,j), xyTo1D(i,j+1)); 
      } 
     } 
    } 
    } 

मैं कैसे कोड को आसान बनाने में कर सकते हैं: यह वास्तविक कोड है?

Answer 1

प्रयास करें इस

boolean f1(int a, int b) { } 
boolean f2(int a, int b) { } 
void A(int a, int b) { } 

void testAndA(BiPredicate<Integer, Integer> p, int a, int b) { 
    if (p.test(a, b)) 
     A(a, b); 
} 

और

if(x == 1){ 
     testAndA(this::f1, x + 1, y); 
     testAndA(this::f1, x, y + 1); 
    } else { 
     testAndA(this::f2, x + 1, y); 
     testAndA(this::f2, x, y + 1); 
    } 

Answer 2

आप विभिन्न मूल्यों है कि इस तरह की तरह कुछ के रूप में f1(), के लिए पारित किया जा सकता है के सभी लूप करने के लिए एक पाश लिख सकते हैं:

for (int deltax = -1; deltax <= 1; deltax++) { 
    for (int deltay = -1; deltay <= 1; deltay++) { 
     if (f1(x + deltax, y + deltay)) { 
      A(x + deltax, y + deltay); 
     } 
    } 
} 

बेशक डेल्टाक्स और डेल्टे के प्रारंभ और अंत मूल्यों को बदलें, आप किन स्थितियों पर निर्भर करते हैं देखने की जरूरत है।

Answer 3

आप कहते हैं कि "प्रत्येक ब्लॉक में बयान अगर अधिक हैं।" लाइनों के बीच पढ़ना, मुझे लगता है कि इसका मतलब है कि आपको f1/f2 और A पर और अधिक कॉल करने की आवश्यकता है, लेकिन विभिन्न x और y ऑफ़सेट के साथ।

यहां एक ऐसा प्रोग्राम है जो कोडिंग पुनरावृत्ति से बचने के लिए कोड को दोबारा करने का एक तरीका दिखाता है। इसकी मुख्य विशेषताएं हैं:

• यह आंतरिक if ब्लॉक को सारणी के लिए ऑब्जेक्ट ओरिएंटेशन का उपयोग करता है।
• यह प्रत्येक आंतरिक if ब्लॉक के लिए x/y ऑफ़सेट का प्रतिनिधित्व करने के लिए offsets सरणी का उपयोग करता है।

• doIt() विधि आंतरिक if ब्लॉक को आमंत्रित करने के लिए लूप का उपयोग करती है।

  public class Main { 
  
      static interface F { 
       void f(int i, int j); 
      } 
  
      static class F1Caller implements F { 
       public void f(int a, int b) { 
       if (f1(a, b)) { 
        A(a, b); 
       } 
       } 
      } 
  
      static class F2Caller implements F { 
       public void f(int a, int b) { 
       if (f2(a, b)) { 
        A(a, b); 
       } 
       } 
      } 
  
      static boolean f1(int a, int b) { System.out.print(" f1. "); return true; } 
      static boolean f2(int a, int b) { System.out.print(" f2. "); return true; } 
      static void A(int a, int b) { System.out.println("a: " + a + ", b: " + b); } 
  
      static F1Caller f1Caller = new F1Caller(); 
      static F2Caller f2Caller = new F2Caller(); 
  
      // x and y offsets for each call to f1/f2. 
      // Add more offset rows, as needed. 
      static int offsets[][] = { 
       {1, 0}, 
       {0, -1} 
      }; 
  
      static void doIt(int x, int y) { 
       System.out.println("x: " + x + ", y: " + y); 
  
       F f = (x == 1) ? f1Caller : f2Caller; 
       for (int k = 0; k < offsets.length; k++) { 
        f.f(x + offsets[k][0], y + offsets[k][1]); 
       } 
      } 
  
  
      public static void main(String[] args) { 
       doIt(0, 0); 
       doIt(1, 0); 
      } 
  } 
  

उपरोक्त कार्यक्रम के उत्पादन में है:

x: 0, y: 0 
    f2. a: 1, b: 0 
    f2. a: 0, b: -1 
x: 1, y: 0 
    f1. a: 2, b: 0 
    f1. a: 1, b: -1 

Answer 4

आप एक साथ समारोह जोड़ सकते हैं।

स्विच का उपयोग करना।

public static boolean func(int a, int b, int fun) 
{ 
    boolean output = false; 
    switch(fun) 
    { 
    case 1: 
     //do stuff 
     output = true; 
     break; 
    case 2: 
     //do stuff 
     output = true; 
     break; 
    default: 
     //unknown function handling 
     output = false; 
    } 
    return output; 
} 

के साथ एकीकृत एक के लिए लूप:

public static void main(String[] args) 
{ 
    int i; 
    //Change this to whatever you want or set it to a argument. 
    int repeat = 2; 
    for(i = 1; i <= repeat; i++) 
    { 
      func(a, b, i); 
    } 
}