Fatal编程技术网
  • java/
  • Java 为什么我的if-else语句不能正常工作？

Java 为什么我的if-else语句不能正常工作？

java if-statement

Java 为什么我的if-else语句不能正常工作？,java,if-statement,Java,If Statement,我有两个字段hourlyPayRate和hoursWorked 我试图编写一个构造函数和mutator，以满足特定的条件，即不允许工资率低于7.25或高于25。不允许工作时间小于0小时或大于70小时。如果值低于最小值 传递，然后将字段设置为最小值。如果传递的值高于最大值，则将字段设置为最大值 使用我的代码，它的测试通过了7.24，预期是7.25，但我的代码返回了7.24。我不明白为什么。测试还通过将pay设置为8.0，然后将其更改为7.25来检查我的mutator，但是我的代码返回8.0而没有更

我有两个字段hourlyPayRate和hoursWorked

我试图编写一个构造函数和mutator，以满足特定的条件，即不允许工资率低于7.25或高于25。不允许工作时间小于0小时或大于70小时。如果值低于最小值 传递，然后将字段设置为最小值。如果传递的值高于最大值，则将字段设置为最大值

使用我的代码，它的测试通过了7.24，预期是7.25，但我的代码返回了7.24。我不明白为什么。测试还通过将pay设置为8.0，然后将其更改为7.25来检查我的mutator，但是我的代码返回8.0而没有更改，尽管它看起来应该返回7.25的值。我做错了什么

public class ProductionWorker extends Employee
{   

private double hourlyPayRate;
private double hoursWorked;

public ProductionWorker(String name, String idNumber, 
String hireDate, ShiftType shift, double hourlyPayRate, double hoursWorked)
{
    super(name, idNumber, hireDate, shift);
    this.hourlyPayRate = hourlyPayRate;
    this.hoursWorked = hoursWorked;

    if (hourlyPayRate > 25)
    {
        hourlyPayRate = 25;
    }
    else if (hourlyPayRate < 7.25)
    {
        hourlyPayRate = 7.25;
    }
    else if (hourlyPayRate < 25 && hourlyPayRate > 7.25)
    {
        this.hourlyPayRate = hourlyPayRate;
    }
    else if (hoursWorked < 0)
    {
        hoursWorked = 0;
    }
    else if (hoursWorked > 70)
    {
        hoursWorked = 70;
    }
}
public double getHourlyPayRate()
{
    return hourlyPayRate;
}


public void setHourlyPayRate(double hourlyPayRate)
{

    //this.hourlyPayRate = hourlyPayRate;

    if (hourlyPayRate > 25)
    {
        hourlyPayRate = 25;
    }
    else if (hourlyPayRate < 7.25)
    {
        hourlyPayRate = 7.25;
    }
    else if (hourlyPayRate < 25 && hourlyPayRate > 7.25)
    {
        this.hourlyPayRate = hourlyPayRate;
    }
}


public double getHoursWorked()
{
    return hoursWorked;
}


public void setHoursWorked(double hoursWorked)
{
    this.hoursWorked = hoursWorked;

    if (hoursWorked < 0)
    {
        hoursWorked = 0;
    }
    else if (hoursWorked > 70)
    {
        hoursWorked = 70;
    }
    else if (hoursWorked > 0 && hoursWorked < 70)
    {
        this.hoursWorked = hoursWorked;
    }
 }
}

公共类ProductionWorker扩展员工
{   
私人双小时缴费率；
私人双小时工作；
public ProductionWorker（字符串名称、字符串ID编号、，
字符串租用、移位类型移位、双小时支付率、双小时工作）
{
超级（姓名、身份证号码、受雇日期、班次）；
this.hourlyPayRate=hourlyPayRate；
this.hoursWorked=hoursWorked；
如果（小时付款率>25）
{
小时支付率=25；
}
否则，如果（小时付款率<7.25）
{
小时支付率=7.25；
}
否则，如果（小时付款率<25和小时付款率>7.25）
{
this.hourlyPayRate=hourlyPayRate；
}
否则，如果（工作小时数<0）
{
工时=0；
}
否则，如果（工作小时数>70）
{
工作小时数=70；
}
}
公共双倍getHourlyPayRate（）
{
返回小时支付率；
}
公共无效setHourlyPayRate（双小时支付率）
{
//this.hourlyPayRate=hourlyPayRate；
如果（小时付款率>25）
{
小时支付率=25；
}
否则，如果（小时付款率<7.25）
{
小时支付率=7.25；
}
否则，如果（小时付款率<25和小时付款率>7.25）
{
this.hourlyPayRate=hourlyPayRate；
}
}
公共双小时工作（）
{
返回工作小时数；
}
公共无效设置工时（双工时）
{
this.hoursWorked=hoursWorked；
如果（工作小时数<0）
{
工时=0；
}
否则，如果（工作小时数>70）
{
工作小时数=70；
}
否则如果（工作小时数>0和工作小时数<70）
{
this.hoursWorked=hoursWorked；
}
}
}
我还以为应该用else结束if-else语句，但当我在这里这样做时，编译器会警告我它不是一个语句

if (...) {
    doA();
} else if (...) {
    doB();
} else if (...) {
    doC();
}
这永远不会超过
doA（）
、
doB（）
或
doC（）
中的一个

您对数据有两个单独的限制：工资率必须限制在某个范围内，工作时间必须在某个范围内

您将无法仅用一个
if…else if…else if…
语句强制执行两个contstraint。

为什么最后一个关键字为您节省了无数时间： 进行以下更改，您将了解什么是错误的，以及下次如何避免错误

public ProductionWorker(final String name, 
                        final String idNumber,
                        final String hireDate, 
                        final ShiftType shift, 
                        final double hourlyPayRate, 
                        final double hoursWorked)
如果执行上述操作并使用step调试器，您将理解为什么正确的引用语法和逻辑会变成：

if (hourlyPayRate > 25) { this.hourlyPayRate = 25; }
else if (hourlyPayRate < 7.25) { this.hourlyPayRate = 7.25; }
else { this.hourlyPayRate = hourlyPayRate; }

if (hoursWorked < 0) { this.hoursWorked = 0; }
else if (hoursWorked > 70) { this.hoursWorked = 70; }
else { this.hoursWorked = hoursWorked; }
在构造器中看不到这一点。这是 比一堆
if/elseif/else
声明

使用normalizeToRange函数，因为两者都在做相同的事情。 注意这里的
final
关键字与 
private
关键字，用于从
构造函数调用此方法


每当您发现自己在重新编写代码时，都应该创建一个方法。这允许您只调用该方法，而不是在多个位置编写相同的代码段。还有一些错误的if/else语句逻辑

让我们来看看如何稍微改进您的代码，从而使其更易于阅读和调试


public double hourlyPayRate(double hourlyPayRate) {
    if (hourlyPayRate > 25) {
        hourlyPayRate = 25;
    } else if (hourlyPayRate < 7.25) {
        hourlyPayRate = 7.25;
    }
    return hourlyPayRate;
}

public double hoursWorked(double hoursWorked) {
    if (hoursWorked > 70) {
        hoursWorked = 70;
    } else if (hoursWorked < 0) {
        hoursWorked = 0;
    }
    return hoursWorked;
}



公共双小时支付率（双小时支付率）{
如果（小时付款率>25）{
小时支付率=25；
}否则，如果（小时付款率<7.25）{
小时支付率=7.25；
}
返回小时支付率；
}
公共双小时工作（双小时工作）{
如果（工作小时数>70）{
工作小时数=70；
}否则，如果（工作小时数<0）{
工时=0；
}
返回工作小时数；
}


这些方法首先检查输入是否高于某个值，如果高于某个值，则将其设置为该值。否则，它会检查它是否低于某个值。

最后，它返回所述值。由于这些测试已经完成，您不必在最后检查它是否在下限和上限之间。
首先，您需要了解变量范围。在方法中，
hourlyPayRate
引用参数，
this.hourlyPayRate
引用类实例变量。从方法返回后，分配给
hourlyPayRate
的值将丢失

您的
setHourlyPayRate
mutator应该更像这样：


public void setHourlyPayRate(double hourlyPayRate)
{
    if (hourlyPayRate > 25)
    {
        this.hourlyPayRate = 25;
    }
    else if (hourlyPayRate < 7.25)
    {
        this.hourlyPayRate = 7.25;
    }
    else
    {
        this.hourlyPayRate = hourlyPayRate;
    }
}



public void setHourlyPayRate（双小时支付率）
{
如果（小时付款率>25）
{
该.hourlyPayRate=25；
}
否则，如果（小时付款率<7.25）
{
这一小时支付率=7.25；
}
其他的
{
this.hourlyPayRate=hourlyPayRate；
}
}


这将根据参数的值为类变量指定正确的值。避免这种混淆的一种方法是为内部变量和参数指定不同的名称

代码的第二个问题是
if
<在构造函数中使用code>else if
语句。只有在先前的条件为false时，才会执行
else if
部分。在您的情况下，只有当您的
hourlyPayRate
正好为25或7.25时，才会测试
hoursWorked
，因为在前面的
if
语句中没有测试这两个精确值

public class Q43789440
{
    /**
     * Shim/Polyfill for Java < 8 compatibility with Java 8
     *
     * @param <T>
     */
    public interface Predicate<T>
    {
        boolean test(T var1);
    }

    /**
     * Shim/Polyfill for Java < 8 compatibility with Java 8
     *
     * @param <T>
     * @param <F>
     */
    public interface Function<F, T>
    {
        T apply(F var1);

        boolean equals(Object var1);
    }

    public interface Constraint extends Predicate<Double>, Function<Double, Double>
    {
        public Double normalize(final Double input);
    }

    public static class LowerConstraint implements Constraint
    {
        private final Constraint next;

        public LowerConstraint(final Constraint next) { this.next = next; }

        @Override
        public Double normalize(final Double input)
        {
            if (this.test(input)) { return this.apply(input); }
            else { return this.next.normalize(input); }
        }

        @Override
        public boolean test(final Double d)
        {
            return d < 7.25;
        }

        @Override
        public Double apply(final Double d)
        {
            return 7.25;
        }
    }

    public static class UpperConstraint implements Constraint
    {
        private final Constraint next;

        public UpperConstraint(final Constraint next) { this.next = next; }

        @Override
        public Double normalize(final Double input)
        {
            if (this.test(input)) { return this.apply(input); }
            else { return this.next.normalize(input); }
        }

        @Override
        public boolean test(final Double d)
        {
            return d > 25.0;
        }

        @Override
        public Double apply(final Double d)
        {
            return 25.0;
        }
    }

    public static class InRangeConstraint implements Constraint
    {
        @Override
        public Double normalize(final Double input)
        {
            if (this.test(input)) { return this.apply(input); }
            else { throw new IllegalArgumentException(); }
        }

        @Override
        public boolean test(final Double d)
        {
            return d >= 7.25 && d <= 25.0;
        }

        @Override
        public Double apply(final Double d)
        {
            return d;
        }
    }

    public static void main(String[] args)
    {
        final Constraint rules = new LowerConstraint(new UpperConstraint(new InRangeConstraint()));
        for (double d = 0.0; d < 30; d++)
        {
            System.out.printf("%.2f normalized to %.2f", d, rules.normalize(d)).println();
        }
    }
}

public double hourlyPayRate(double hourlyPayRate) {
    if (hourlyPayRate > 25) {
        hourlyPayRate = 25;
    } else if (hourlyPayRate < 7.25) {
        hourlyPayRate = 7.25;
    }
    return hourlyPayRate;
}

public double hoursWorked(double hoursWorked) {
    if (hoursWorked > 70) {
        hoursWorked = 70;
    } else if (hoursWorked < 0) {
        hoursWorked = 0;
    }
    return hoursWorked;
}

public void setHourlyPayRate(double hourlyPayRate)
{
    if (hourlyPayRate > 25)
    {
        this.hourlyPayRate = 25;
    }
    else if (hourlyPayRate < 7.25)
    {
        this.hourlyPayRate = 7.25;
    }
    else
    {
        this.hourlyPayRate = hourlyPayRate;
    }
}

this.hourlyPayRate = hourlyPayRate;
this.hoursWorked = hoursWorked;

public ProductionWorker(String name, String idNumber, 
    String hireDate, ShiftType shift, double hourlyPayRate, double hoursWorked)

{
    super(name, idNumber, hireDate, shift);
    this.hourlyPayRate = hourlyPayRate;
    this.hoursWorked = hoursWorked;

if (hourlyPayRate > 25)
{
    this.hourlyPayRate = 25;
}
else if (hourlyPayRate < 7.25)
{
    this.hourlyPayRate = 7.25;
}
else if (hourlyPayRate < 25 && hourlyPayRate > 7.25)
{
    this.hourlyPayRate = hourlyPayRate;
}
else if (hoursWorked < 0)
{
    this.hoursWorked = 0;
}
else if (hoursWorked > 70)
{
    this.hoursWorked = 70;
}

if (hoursWorked < 0)
{
    this.hoursWorked = 0;
}
else if (hoursWorked > 70)
{
    this.hoursWorked = 70;
}
else if (hoursWorked > 0 && hoursWorked < 70)
{
    this.hoursWorked = hoursWorked;
}