2013-11-12 1 views
0

Привет, Я пытаюсь создать метод checkArg, который проверяет, набрал ли пользователь строку, когда должен был ввести целочисленный аргумент, и если пользователь вводит более трех аргументов, тогда скажите им: «Пожалуйста, введите правильное значение «если эти условия не выполняются, попросите снова и продолжите программу. У меня есть приблизительная схема в нижней части моего кода.Метод проверки аргументов

Я пытаюсь вызвать мой метод checkArg в моей основной в нижней части, чтобы сравнить аргумент «размер». Он компилируется, но не скажет мне «пожалуйста, введите правильное значение», а затем продолжите программу.

Мой код:

import java.util.*; 

public class trominoZ2 { 
    //create a drawing panel of width=400px and height=400px 

    private int[][] grid; 
    private int currentNum; 

    // Pre-condition: size must be a perfect power of 2 and 0<=x<size, 0<=y<size 
    // Post-condition: creates an empty tromino object with dimensions size x size. 
    public void tromino(int size, int x, int y) { 

     int actualsize = 1; 
     while (actualsize < size) actualsize*=2;  //actualsize = actualsize * 2 

     // Make sure the grid size is a perfect power of 2. 
     grid = new int[actualsize][actualsize]; 
     currentNum = 1; 

     // Fill in the grid with all empty squares. 
     for (int i=0; i<actualsize; i++) { 
      for (int j=0; j<actualsize; j++) { 
       grid[i][j] = 0; 
      } 
     } 

     // This represents the original hole in the tromino. 
     grid[x][y] = -1; 
    } 

    // Wrapper call for recursive method. 
    public void tile() { 
     tileRec(grid.length, 0, 0); 
    } 

    private void tileRec(int size, int topx, int topy) { 

     // No recursive case needed here, just fill in your one tromino... 
     if (size == 2) { 

      // Fill in the one necessary tromino. The hole is identified by a 
      // non-zero number, so don't fill in that one square. 
      for (int i=0; i<size; i++) 
       for (int j=0; j<size; j++) 
        if (grid[topx+i][topy+j] == 0) 
         grid[topx+i][topy+j] = currentNum; 

      // Advance to the next tromino. 
      currentNum++; 
     } 

     // Recursive case... 
     else { 

      // Find coordinates of missing hole 
      int savex=topx, savey=topy; 

      for (int x=topx; x<topx+size; x++) 
       for (int y=topy; y<topy+size; y++) 
        if (grid[x][y] != 0) { 
         savex = x; 
         savey = y; 
        } 

      // Hole in upper left quadrant.  
      if (savex < topx + size/2 && savey < topy + size/2) { 

       // Recursively tile upper left quadrant. 
       tileRec(size/2, topx, topy); 

       // Fill in middle tromino 
       grid[topx+size/2][topy+size/2-1] = currentNum; 
       grid[topx+size/2][topy+size/2] = currentNum; 
       grid[topx+size/2-1][topy+size/2] = currentNum; 

       // Advance to the next tromino 
       currentNum++; 

       // Now we can make our three other recursive calls. 
       tileRec(size/2, topx, topy+size/2); 
       tileRec(size/2, topx+size/2, topy); 
       tileRec(size/2, topx+size/2, topy+size/2); 

      } 

      // Hole in upper right quadrant 
      else if (savex < topx + size/2 && savey >= topy + size/2) { 

       // Recursively tile upper right quadrant. 
       tileRec(size/2, topx, topy+size/2); 

       // Fill in middle tromino 
       grid[topx+size/2][topy+size/2-1] = currentNum; 
       grid[topx+size/2][topy+size/2] = currentNum; 
       grid[topx+size/2-1][topy+size/2-1] = currentNum; 

       // Advance to the next tromino 
       currentNum++; 

       // Now we can make our three other recursive calls. 
       tileRec(size/2, topx, topy); 
       tileRec(size/2, topx+size/2, topy); 
       tileRec(size/2, topx+size/2, topy+size/2); 

      } 

      // Hole in bottom left quadrant 
      else if (savex >= topx + size/2 && savey < topy + size/2) { 

       // Recursively tile bottom left quadrant. 
       tileRec(size/2, topx+size/2, topy); 

       // Fill in middle tromino 
       grid[topx+size/2-1][topy+size/2] = currentNum; 
       grid[topx+size/2][topy+size/2] = currentNum; 
       grid[topx+size/2-1][topy+size/2-1] = currentNum; 

       // Advance to the next tromino 
       currentNum++; 

       // Now we can make our three other recursive calls. 
       tileRec(size/2, topx, topy); 
       tileRec(size/2, topx, topy+size/2); 
       tileRec(size/2, topx+size/2, topy+size/2); 
      } 
      else { 

       // Recursively tile bottom right quadrant. 
       tileRec(size/2, topx+size/2, topy+size/2); 

       // Fill in middle tromino 
       grid[topx+size/2-1][topy+size/2] = currentNum; 
       grid[topx+size/2][topy+size/2-1] = currentNum; 
       grid[topx+size/2-1][topy+size/2-1] = currentNum; 

       // Advance to the next tromino 
       currentNum++; 

       // Now we can make our three other recursive calls. 
       tileRec(size/2, topx+size/2, topy); 
       tileRec(size/2, topx, topy+size/2); 
       tileRec(size/2, topx, topy); 
      } 

     } // end large if-else 

    } // end tileRec 


    // Prints out the current object. 
    public void print() { 

     for (int i=0; i<grid.length; i++) { 
      for (int j=0; j<grid[i].length; j++) 
       System.out.print(grid[i][j] + "\t"); 
      System.out.println(); 
     } 
    } 

    public static int checkArg(int ch){ 
     String str = ""; 
     char[] all = str.toCharArray(); 
     for(int i = 0; i < all.length;i++) { 
      if(!Character.isDigit(all[i])) { 
       System.out.println("Please retype a correct value");    
      } 
     } 
     return ch; 
    } 

    public static void main(String[] args) { 

     Scanner stdin = new Scanner(System.in); 

     // Get user input... 
     int size = stdin.nextInt();    
     int x = stdin.nextInt(); 
     int y = stdin.nextInt(); 

     if(checkArg(size) != size){ 
      checkArg(size); 
     } else if (x != x){ 
      System.out.println("Please retype a correct value"); 
     } else if (y != y){ 
      System.out.println("Please retype a correct value"); 
     } 

     // Create our object and tile it! 
     tromino thisguy = new tromino(size, x, y); 

     //tile grid with trominos 
     thisguy.tile(); 

     // Print romino grid. 
     thisguy.print(); 

    } 
} 

Как я мог бы получить мой метод checkArg, чтобы проверить, если пользователь ввел более 3-х аргументов, или если он был не целое число аргументов?

ответ

0

Вы могли бы сделать что-то вроде этого. Попросите метод вернуть логическое значение. Затем проверьте аргументы в main для ответа boolean. И продолжайте цикл, пока метод не возвращает истину

public static boolean checkArg(String line){ 
    String[] args = line.split("\\s+"); 

    if (args.length != 3) { 
     return false; 
    } 

    try { 
     int num1 = Integer.parseInt(args[0].trim()); 
     int num1 = Integer.parseInt(arss[1].trim()); 
     int num3 = Integer.parseInt(args[2].trim()); 
    } catch (Exception ex) { 
     System.out.println("Must enter 3 integers"); 
     return false; 
    } 

    return true; 
} 

Использование в main

public static void main(String[] args) { 

    Scanner stdin = new Scanner(System.in); 
    String input = stdin.nextLine(); 

    while (!checkArgs(input)) { 
     input = stdin.nextLine(); 
    } 

    String[] args = input.split("\\s+"); 
    int size = Integer.parseInt(args[0].trim()); 
    int x = Integer.parseInt(arss[1].trim()); 
    int y = Integer.parseInt(args[2].trim()); 


    // Create our object and tile it! 
    tromino thisguy = new tromino(size, x, y); 

    //tile grid with trominos 
    thisguy.tile(); 

    // Print romino grid. 
    thisguy.print(); 
}