在一行上调用具有先前值的方法

Question

因此，我有一个非常简单的方法，该方法只有一项工作，它必须为我提供调整变量的最小值和最大值。

    public int[] axisLimits(int axisInfo, int axisMin, int axisMax){

    if(axisInfo >= axisMax){
        axisMax = axisInfo;
    }else if(axisInfo < axisMin){
        axisMin = axisInfo;
    }


    int axisLimits[] = {axisMin, axisMax};
    /*
    axisLimits[0] = axisMin;
    axisLimits[1] = axisMax;
    */
    return axisLimits;
}

以前我使用int axisLimits [] = new int [2]来获得它，这就是为什么我对这两行进行了注释。

因此它工作正常，但我必须为每个轴预定义2个变量，并在下一次调用之前保存最小值和最大值：

    int limitZ[] = new Limits().axisLimits((int)accelZ, minAccelZ, maxAccelZ);
    minAccelZ = limitZ[0];
    maxAccelZ = limitZ[1];

然后我可以使用minAccelZ和max AccelZ或limitZ [0]和limitZ [1]。

有什么办法可以解决这个问题，并使其成为单线通话吗？ （因此我可以根据需要使用limitZ [0]和limitZ [1]吗？

Answer 1

 public int[] axisLimits(int ...intvalues){

            int axisLimits[] = new int [intvalues.length];
            int arrayofints[] = intvalues;
            arrayofints[2] = (arrayofints[0] >= arrayofints[2]) ? arrayofints[0] : arrayofints[2]; //axismax
            arrayofints[1]  = (arrayofints[0] < arrayofints[1] ) ? arrayofints[0] : arrayofints[1]; //axismin

            //int axisInfo = arrayofints[0]
            //int axisMin =arrayofints[1] 
            //int axisMax = arrayofints[2]

            int index = 0;
            for (int intvalue : arrayofints) {
                axisLimits[index] = intvalue;
                ++index;
            }        


        return axisLimits;
        }

也许这种方法可以帮助您，我已经更改了方法以接受任何int值，并且您不必担心创建数组并将值手动添加到数组中，这将完成您的工作

Answer 2

我将为此创建一个类，这有点像Java方式：

public class AxisLimit {
    private int min, max;

    public AxisLimit(int min, int max) {
        this.min = min;
        this.max = max;
    }

    public int min() {
        return min;
    }

    public int max() {
        return max;
    }
}

并将您的代码更改为此：

public static AxisLimit axisLimit(int axisInfo, AxisLimit axisLimit){
    int max = axisLimit.max();

    if(axisInfo > max) {
        return new AxisLimit(axisLimit.min(), axisInfo);
    } 

    if(axisInfo < min) {
        return new AxisLimit(axisInfo, axisLimit.max());
    }

    return new AxisLimit(axisLimit.min(), axisLimit.max());
}

和这个：

AxisLimit limitZ = Limits.axisLimits((int)accelZ, minAccelZ, maxAccelZ);
minAccelZ = limitZ.min();
maxAccelZ = limitZ.max();

注意，您可以将Limits.axisLimits（int，int，int）设为静态，这样可以避免在每次调用时创建新实例。

一旦实现这一目标，您就可以进一步扩展OO技能。 因为知道如何扩展自身以包含值是极限的责任。 您可以像这样重构它：

public class AxisLimit {
    private int min, max;

    public AxisLimit(int min, int max) {
        this.min = min;
        this.max = max;
    }

    public int max() {
        return max;
    }

    public int min() {
        return min;
    }

    public AxisLimit containing(int axisInfo) {
        if(axisInfo > max) {
            return new AxisLimit(min, axisInfo);
        } 

        if(axisInfo < min) {
            return new AxisLimit(axisInfo, max);
        }

        return new AxisLimit(min, max);
    }
}

删除静态方法：）

并且调用方块变为：

AxisLimit limitZ = new AxisLimit(axisMin, axisMax).containing((int)accelZ);

您可以在适当的地方高兴地使用limitZ.min()和limitZ.max()或将它们存储在变量中，如第一个示例所示。

注意代码如何变得更具可读性？ 变量名比较简单，通常这是您在正确方向上构建解决方案的标志。

Answer 3

像这样的课程怎么样：

public class MinMax {

    private int min;
    private int max;

    public MinMax(int min, int max) {
        this.min = min;
        this.max = max;
    }

    public MinMax axisInfo(int axisInfo) {
        if ( axisInfo > max ) max = axisInfo;
        else if ( axisInfo < min ) min = axisInfo;
        return this;
    }

    public int getMin() {
        return min;
    }

    public int getMax() {
        return max;
    }
}

接着：

MinMax m = new MinMax(100,1000)
        .axisInfo(1500)
        .axisInfo(90)
        .axisInfo(70);

int min = m.getMin();
int max = m.getMax();