Aufruf derselben Methode rekursiv von if und else.Getting unexpected output

Question

Aufruf der gleichen Methode rekursiv von if und else.Calee Ausgabe erhalten, die unerwartet ist (Wie Sie von sysout sehen können). Erwartete Ausgabe: 4

Debugging der Code und sah was passiert. Aber kann nicht viel verstehen. Bitte helfen

public class GetSquares { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     String rectDimension="5X3"; 
     int noOfSquares=0; 
     int noOfSq=getNoofSquares(rectDimension,noOfSquares); 
     System.out.println(noOfSq); 
    } 

    public static int getNoofSquares(String rectDimension,int noOfSquares){ 

     int length=Integer.parseInt(rectDimension.split("X")[0]); 
     int breadth=Integer.parseInt(rectDimension.split("X")[1]); 


     if(length<breadth){ 
      rectDimension=String.valueOf(breadth-length)+"X"+length; 
      ++noOfSquares; 
      getNoofSquares(rectDimension, noOfSquares); 
     }else if(length>breadth){ 
      rectDimension=String.valueOf(length-breadth)+"X"+breadth; 
      ++noOfSquares; 
      getNoofSquares(rectDimension, noOfSquares); 
     }else { 
      noOfSquares=noOfSquares+1; 
      System.out.println(noOfSquares); 
      return noOfSquares; 
     } 

     return noOfSquares; 



    } 
} 

Answer 1

Sie nicht den Rückgabewert von Methode getNoofSquare() in rekursiven Aufruf zu halten, erhalten den Wert wie

noOfSquares= getNoofSquares(rectDimension, noOfSquares); 

Answer 2

Ihr Problem ist, dass primitive Typen in Java von Wert übergeben werden, nicht durch Referenzen.

Dieser Code wird gedruckt 0.

Wenn Sie einen "Ausgabeparameter" haben wollen, muss er veränderbar sein, aber int ist nicht. Sie würden eine Klasse erstellen, die eine Halterung für die ganze Zahl ist:

public class MutableInteger { 

    private int value = 0; 

    public void increment() { 
     value++; 
    } 

    public int getValue() { 
     return value; 
    } 

} 

Code Dann würde wie folgt aussehen:

// SOLUTION 1 
public class GetSquares { 

    public static void main(String[] args) { 
     String rectDimension = "5X3"; 
     MutableInteger noOfSq = new MutableInteger(); 
     getNoofSquares(rectDimension, noOfSq); 
     System.out.println(noOfSq.getValue()); 
    } 

    public static void getNoofSquares(String rectDimension, MutableInteger noOfSquares) { 

     int length = Integer.parseInt(rectDimension.split("X")[0]); 
     int breadth = Integer.parseInt(rectDimension.split("X")[1]); 

     noOfSquares.increment(); 

     if (length < breadth) { 
      rectDimension = String.valueOf(breadth - length) + "X" + length; 
      getNoofSquares(rectDimension, noOfSquares); 
     } else if (length > breadth) { 
      rectDimension = String.valueOf(length - breadth) + "X" + breadth; 
      getNoofSquares(rectDimension, noOfSquares); 
     } 
    } 

} 

Ein weiterer Ansatz ist nur Rückgabewert zu verwenden, um das Ergebnis zurück:

// SOLUTION 2 
public class GetSquares { 

    public static void main(String[] args) { 
     String rectDimension = "5X3"; 
     int noOfSq = getNoofSquares(rectDimension); 
     System.out.println(noOfSq); 
    } 

    public static int getNoofSquares(String rectDimension) { 
     int length = Integer.parseInt(rectDimension.split("X")[0]); 
     int breadth = Integer.parseInt(rectDimension.split("X")[1]); 

     if (length < breadth) { 
      rectDimension = String.valueOf(breadth - length) + "X" + length; 
      return 1 + getNoofSquares(rectDimension); 
     } else if (length > breadth) { 
      rectDimension = String.valueOf(length - breadth) + "X" + breadth; 
      return 1 + getNoofSquares(rectDimension); 
     } else { 
      return 1; 
     } 
    } 

} 

auch anstelle String-Parsing/Spalten/Gebäude zu tun, würde ich empfehlen, nur zwei haben int Parameter für Länge und Breite:

// SOLUTION 2 (cleaned) 
public class GetSquares { 

    public static void main(String[] args) { 
     String rectDimension = "5X3"; 

     int length = Integer.parseInt(rectDimension.split("X")[0]); 
     int breadth = Integer.parseInt(rectDimension.split("X")[1]); 

     int noOfSq = getNoofSquares(length, breadth); 
     System.out.println(noOfSq); 
    } 

    public static int getNoofSquares(int length, int breadth) { 
     if (length < breadth) { 
      return 1 + getNoofSquares(breadth - length, length); 
     } else if (length > breadth) { 
      return 1 + getNoofSquares(length - breadth, breadth); 
     } else { 
      return 1; 
     } 
    } 

} 

Answer 3

Java ist nach Wert übergeben. Sie erhöhen eine lokale Variable und Sie tun nichts mit dem Wert, der von den Rekursionen zurückgegeben wird.

Da Sie nicht anyhthing tun nach aber kehren Sie könnten genauso gut gemacht:

public class GetSquares { 

    public static void main(String[] args) { 
     String rectDimension = args.length > 0 ? args[0] : "5X3"; 
     System.out.println("Number of squares from " + rectDimension 
      + " is " + getNoofSquares(rectDimension)); 
    } 

    public static int getNoofSquares(String rectDimension){ 
     String parts[] = rectDimension.split("X"); 
     int length=Integer.parseInt(parts[0]); 
     int breadth=Integer.parseInt(parts[1]); 
     return getNoofSquares(length, breadth, 0); 
    } 

    public static int getNoofSquares(int length, int breadth, int noOfSquares){ 
     if (length < breadth) { 
      return getNoofSquares(breadth-length, length, noOfSquares+1); 
     } else if (length > breadth) { 
      return getNoofSquares(length-breadth, breadth, noOfSquares+1); 
     } else { 
      return noOfSquares+1; 
     } 
    } 
} 

hielt ich Ihren Akku so jetzt ist es Schwanz rekursiv. Java hat noch keine TCO.