Question

所以我有一个非常简单的方法，只有一个工作，它必须给我一个chaning变量的最小值和最大值。

    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();

在单行上调用带有先前值的方法

3 个答案: