Java 如何在没有if语句的情况下做出决策

我正在学习Java课程，我们还没有正式学习if语句。我正在研究，看到了这个问题：

编写一个名为pay的方法，该方法接受两个参数：助教工资的实数和助教本周工作小时数的整数。该方法应返回支付TA的金额。例如，通话费（5.50,6）应该返回33.0。助教在8小时以上的任何时间都应获得正常工资1.5倍的“加班费”。例如，通话费（4.00,11）应返回（4.00*8）+（6.00*3）或50.0

在不使用if语句的情况下，如何解决此问题？到目前为止，我已经拿到了这个，但我一直坚持固定工资：

public static double pay (double salary, int hours) {

     double pay = 0;

     for (int i = hours; i > 8; i --) {
         pay += (salary * 1.5);
     }
}

---

有几种方法可以做到这一点，但很难知道什么是允许的（如果你甚至不能使用

if

）

我建议使用

while

循环：

double pay = 0;
while (hoursWorked > 8) {
    pay += (salary * 1.5);
    hoursWorked--;
}
pay += (hoursWorked * salary);

---

之所以有效，是因为它将您的

工作小时数

减至保证小于或等于

8

（假设

工作小时数

和

工资

均大于

0

）。如果自从使用for循环后

hoursweed，这里有一个解决方案，只使用两个for循环

public static double pay (double salary, int hours) {

    double pay = 0;

    for (int i = 0; i < hours && i < 8; i++) {
        pay += salary;
    }
    for (int i = 8; i < hours; i++) {
        pay += (salary * 1.5);
    }

    return pay;
}

公共静态双薪（双薪，整数小时）{
双薪=0；
对于（int i=0；i

这将正常工作时间的工资相加至8，然后将加班时间的工资相加，其中加班时间的工资为1.5*工资

如果没有加班时间，第二个for循环将不会被输入，也不会产生任何效果。
为了避免直接使用流控制语句，如
If
或
，而
可以使用
Math.min
和
Math.max
。对于这个特殊的问题，使用循环也不会有效

从技术上讲，他们可能使用if语句或等效语句，但您已经进行的许多其他标准库调用也是如此：

public static double pay (double salary, int hours) {
     int hoursWorkedRegularTime = Math.min(8, hours);
     int hoursWorkedOverTime = Math.max(0, hours - 8);
     return (hoursWorkedRegularTime * salary) +
            (hoursWorkedOverTime  * (salary * 1.5));
}

假设我们有（17小时，4份薪水）

17-8=9是加班

9*4*1.5+8*4=9*6+32=54+32=86
如果您真的想成为黑客，可以使用位运算符：

int otherHours = hours - 8;
int multiplier = (~otherHours & 0x80000000) >>> 31;
otherHours *= multiplier;

return otherHours * 0.5 * salary + hours * salary;

因此，基本上，如果
otherHours
为负值，就不应该多付。为此，我们选择
otherHours
的符号位，并将其移动到最低有效位（带0填充），以表示1或0。首先求反后（若符号位为1，则乘法器应为0）

当您将其与
otherHours
相乘时，如果少于8小时，它将是
0
，以便在进行最终计算时不会意外减去任何工资。
仅为记录，这里有一个解决方案非常接近您被停止的位置：

public static double pay (double salary, int hours) {
     double pay = salary * hours;
     for (int i = hours; i > 8; i --) {
         pay += salary * 0.5;
     }
}

不使用任何条件（隐式或显式）的解决方案

实际上，您需要计算
hours*rate
，但如果您有加班，则需要添加
加班时间*加班费率形式的奖金

在伪代码中：

//you need to return:
hours * rate + is_overtime * overtime_time * overtime_rate

在哪里

您只需使用三元运算符
？：
：

 pay = hours*salary + ((hours > 8) ? (hours-8)*salary*0.5 : 0); 

-在整个工作时间内支付标准工资，8小时以上的时间加50%（如有）。
为此目的，可以滥用转换为
int

请注意，函数

f(x) = 10/9 - 1/(x+1) = 1 + 1/9 - 1/(x+1)

对于
0=8
，介于0和1之间（独占）。对于
x<8
将此值强制转换为
int
结果
0
，对于
x>=8
将此值强制转换为
1

这可用于计算结果：

public static double pay(double salary, int hours) {
    int overtime = (int)(10d/9d - 1d/(hours+1));
    return salary * (hours + 0.5 * overtime * (hours - 8));
}

您可以创造性地将while语句用作if语句

while(hours > 8){
  return ((hours - 8) * salary * 1.5) + (8 * salary);
}
return hours * salary;

在Tsql中

声明@amount float=4.00
，@hrs int=11

声明@int
，@过轻钻头

设置@overlight=（@hrs/8）^1）

设置加班时间=上限（（@hrs%8）/（@hrs%8）+1.0））*~@overlight

--选择@hrs*@金额

选择（（@hrs-（@hrs%8*~@overeight））*@amount）+（@加班时间*（@hrs%8*（@amount*1.5）））

（来自上面的Valentin）
一些编程语言具有明确的模式匹配功能。例如，在XSLT中，如果正在处理的节点比程序中的其他模板更好地匹配给定的XPATH查询，那么给定的模板将触发

这种“声明性”编程的抽象级别高于Java，但您仍然拥有该语句，这使您能够使用“匹配”方法控制流，而不是使用显式if-else构造

public static double pay (double salary, int hours) {

 double pay = 0;

 for (int i = hours; i > 0;i--){ 
     switch (i){
         case 1:
         case 2:
         case 3: 
         case 4: 
         case 5:
         case 6:
         case 7:            
            pay += (salary);
            break;
         default:
            pay += (salary * 1.5);
            break;
     }
 }
 return pay;
}

话虽如此，对于您的特定示例，您真正需要的是if语句。
开关
方法可以工作，但有点做作
 已经有很多好的和更有效的答案了，但这里有另一个使用while循环和三元运算符的简单选项：

double pay = 0.0;

while(hours > 0){
    pay += hours > 8 ? wage * 1.5 : wage;
    hours--;
}       
return pay;

使用
tanh
确定
hours
是否低于
8
：

public static double pay (double salary, int hours) {
    int decider = (int)(tanh(hours - 8) / 2 + 1);

    double overtimeCompensation = 1.5;
    double result = salary * (hours * (1 - decider) + (8 + (hours - 8) * overtimeCompensation) * decider);
    return result;
}

当
hours
小于8时，
decider
变量为0，否则为1。这个等式基本上包含两部分：第一个
hours*（1-decider）
将用于
hours<8
，第二个
（8+（hours-8）*超时补偿）*当
hours>=8
时的decider
。如果
hours<8
，则
1-decider
为1，
decider
为0，因此使用方程的第一部分。如果
hours>=8
，
1-decider
为0，
decider
为1，则情况正好相反，等式的第一部分为0，第二部分乘以1。
下面是一种使用
整数除法截断的方法，这可能是您在java课程开始时学到的。基本上，解决方案是一个单行程序，它不需要
if
，
循环
public static double pay (double salary, int hours) {

 double pay = 0;

 for (int i = hours; i > 0;i--){ 
     switch (i){
         case 1:
         case 2:
         case 3: 
         case 4: 
         case 5:
         case 6:
         case 7:            
            pay += (salary);
            break;
         default:
            pay += (salary * 1.5);
            break;
     }
 }
 return pay;
}

double pay = 0.0;

while(hours > 0){
    pay += hours > 8 ? wage * 1.5 : wage;
    hours--;
}       
return pay;

public static double pay (double salary, int hours) {
    int decider = (int)(tanh(hours - 8) / 2 + 1);

    double overtimeCompensation = 1.5;
    double result = salary * (hours * (1 - decider) + (8 + (hours - 8) * overtimeCompensation) * decider);
    return result;
}

public static double pay(double salary, int hours) {

    //Pay all hours as overtime, and then subtract the extra from the first 8 hours
    double p1 = (hours * 1.5 * salary) - (4 * salary); 

    //In the case where the TA works for less than 8 hours, 
    //subtract all the extra so that ultimately, pay = salary * hours
    double p2 = (hours * 0.5 * salary) - (4 * salary); 

    //When theres no overtime worked, m equals to 1. 
    //When there are overtime hours, m is equals to 0.
    int m = (8 + 7) / (hours + 7);

    //When there are overtime hours, pay is simply equal to p1. 
    //When there are no overtime hours, p2 is subtracted from p1.
    return p1 - m*p2; 
}

    int extra_hours = hours - 8;
    extra_hours = extra_hours > 0 ? extra_hours : 0;


    double extra_salary = (salary * 1.5) * extra_hours;
    double normal_salary = extra_hours > 0 ? salary * 8 : salary * hours;

    return normal_salary + extra_salary;
}