时间戳

首页 > 解决方案 > 如何检查其他方法中的语句

java - 如何检查其他方法中的语句

问题描述

我正在使用 while 循环来检查输入，然后重复直到满足相关条件（注释掉的代码）。但是由于我有很多输入，我决定为此制定一个方法，并且它工作得很好（没有注释代码）。问题是当我想输入 acurrentnumber时，它不应该大于boughtNumber. 旧方法适用于此，但现在我无法将该语句传递给该inputCheck方法。我怎样才能做到这一点，或者用另一种更好的方法代替它。不确定java是否支持“断言”，我可以在这里使用它。

我的方法

public void save() throws IOException{
        String name = "";
        String boughtNumber = "", currentNumber = "";
        String buyPrice = "", sellPrice = "";

        name = Functions.inputCheck("Unesite naziv artikla:\t\t", "string", true, false);
        boughtNumber = Functions.inputCheck("Unesite nabavnu kolicinu:\t", "int", true, false);
        currentNumber = Functions.inputCheck("Unesite trenutnu kolicinu:\t", "int", true, Integer.parseInt(currentNumber) > Integer.parseInt(boughtNumber));
        buyPrice = Functions.inputCheck("Unesite nabavnu cijenu:\t\t", "float", true, false);
        sellPrice = Functions.inputCheck("Unesite prodajnu cijenu:\t", "float", true, false);

//      while(name == null || patternString.matcher(name).matches()==false) {
//          System.out.print("Unesite naziv artikla:\t\t");
//          name = input.nextLine();            
//      }
//      while(boughtNumber == null || patternInt.matcher(boughtNumber).matches()==false) {
//          System.out.print("Unesite nabavnu kolicinu:\t");
//          boughtNumber = input.nextLine();
//      }
//      
//      while(currentNumber == null || patternInt.matcher(currentNumber).matches()==false || Integer.parseInt(currentNumber) > Integer.parseInt(boughtNumber)) {    
//          System.out.print("Unesite trenutnu kolicinu:\t");
//          currentNumber = input.nextLine();
//      }
//      
//      while(buyPrice == null || patternFloat.matcher(buyPrice).matches()==false) {
//          System.out.print("Unesite nabavnu cijenu:\t\t");
//          buyPrice = input.nextLine();
//      }
//      
//      while(sellPrice == null || patternFloat.matcher(sellPrice).matches()==false) {
//          System.out.print("Unesite prodajnu cijenu:\t");
//          sellPrice = input.nextLine();   
//      }

带有 inputCheck 方法的类

package hr.atos.praksa.josipmaricevic.zadatak15;

import java.util.Scanner;
import java.util.regex.Pattern;

public class Functions {

    static Scanner input = new Scanner(System.in);
    final static private Pattern patternNotBlank = Pattern.compile("\\S+");
    final static private Pattern patternOIB = Pattern.compile("^[0-9]{11}$");
    final static private Pattern patternString = Pattern.compile("[A-Z][a-z]*");
    final static private Pattern patternInt = Pattern.compile("[0-9]+$");
    final static private Pattern patternFloat = Pattern.compile("^[0-9]+([.]?[0-9]+|[0-9]*)");

    public static String inputCheck(String print, String _pattern, boolean andStatement, boolean orStatement ) {
        String string = "";
        Pattern pattern = patternFloat;

        switch(_pattern) {
        case "int":
            pattern = patternInt;
            break;
        case "float":
            pattern = patternFloat;
            break;
        case "string":
            pattern = patternString;
            break;
        case "oib":
            pattern = patternOIB;
            break;
        case "notblank":
            pattern = patternNotBlank;
            break;
        }

        while((andStatement && pattern.matcher(string).matches()==false) || orStatement){
            System.out.print(print);
            string = input.nextLine();          
        }


        return string;
    }


}

如果有什么不清楚的地方，我可以澄清一下。

标签： java

解决方案

您可能想为此研究谓词。

谓词是指定某个输入是否正常的函数，并且可以链接

例如：

final static private Pattern patternInt = Pattern.compile("[0-9]+$");

    static Predicate isNumber = input -> patternInt.matcher((String)input).matches();

    public static void main(String[] args) {

        System.out.println();

        Predicate numberOver50 = isNumber.and(input -> Integer.parseInt((String)input)>50);

        test(numberOver50,"50");
        test(numberOver50,"51");

    }
    static void test(Predicate test,String input){
        System.out.println(test.test(input));
    }

重写此 Functions 类将产生以下更改：

static Scanner input = new Scanner(System.in);
    final static private Predicate<String> patternNotBlank = input -> Pattern.compile("\\S+").matcher(input).matches();
    final static private Predicate<String> patternOIB = input -> Pattern.compile("^[0-9]{11}$").matcher( input).matches();
    final static private Predicate<String> patternInt = input -> Pattern.compile("[0-9]+$").matcher( input).matches();
    final static private Predicate<String> patternString = input -> Pattern.compile("[A-Z][a-z]*").matcher(input).matches();
    final static private Predicate<String> patternFloat = input -> Pattern.compile("^[0-9]+([.]?[0-9]+|[0-9]*)").matcher(input).matches();

    public static String inputCheck(String print, String _pattern, Predicate andStatement, Predicate orStatement ) {
        Predicate<String> typeTest = patternFloat;
        if (andStatement==null){
            andStatement = input -> true;// a passthrough, always true
        }
        if (orStatement==null){
            orStatement = input -> false;// a passthrough, always true
        }

        switch(_pattern) {
            case "int":
                typeTest = patternInt;
                break;
            case "float":
                typeTest = patternFloat;
                break;
            case "string":
                typeTest = patternString;
                break;
            case "oib":
                typeTest = patternOIB;
                break;
            case "notblank":
                typeTest = patternNotBlank;
                break;
        }

        String string;
        do {
            System.out.print(print);
            string = input.nextLine();
        } while (andStatement.and(typeTest.negate()).or(orStatement).test(string));

        return string;
    }

现在您可以在声明函数时添加额外的测试：

Predicate NOEND = input -> true;
Preducate NOOR = input -> false;
...

currentNumber = Functions.inputCheck("Unesite trenutnu kolicinu:\t", "int",NOEND, input->{return Integer.parseInt((String)input)> Integer.parseInt(boughtNumber)};

请注意，函数中使用的变量必须是“final”（有效的 final，它并不总是与预定义为 final 的类型相同！）

另外函数会在你写的时候定义好，所以当时需要填写buyNumber，如果你把ordering改为先获取currentNumber再buyNumber的话，由于还没有填写buyNumber，所以不生效。 't 有效 final （将在后面的方法中更改！）

编辑：通过定义不需要额外转换的谓词类。（更改了示例代码以显示这一点。）

推荐阅读