如何在不超过最大值的情况下递增变量？

我正在为学校设计一个简单的视频游戏程序，并且创建了一种方法，如果调用该方法，玩家将获得15个健康点。我必须保持最大生命值100，并且由于目前有限的编程能力，我正在执行此类操作。

public void getHealed(){
    if(health <= 85)
        health += 15;
    else if(health == 86)
        health += 14;
    else if(health == 87)
    health += 13; 
}// this would continue so that I would never go over 100

我了解我的语法不是很完美，但是我的问题是，什么是更好的方法，因为我还必须对损坏点做类似的事情，并且不要低于0。

这称为饱和算术。

我只会这样做。基本上，它的最小值介于100（最大运行状况）之间，以及15点额外的运行状况。它确保用户的健康状况不超过100。

public void getHealed() {
    health = Math.min(health + 15, 100);
}

为确保生命值不会降到零以下，您可以使用类似的功能：Math.max。

public void takeDamage(int damage) {
    if(damage > 0) {
        health = Math.max(health - damage, 0);
    }
}

只需增加15点生命值，即可：

health += 15;
if(health > 100){
    health = 100;
}

但是，正如bland所指出的那样，有时候在多线程（一次执行多个代码块）中，运行状况随时超过100 可能会引起问题，并且多次更改运行状况属性也可能很糟糕。在这种情况下，您可以执行此操作，如其他答案中所述。

if(health + 15 > 100) {
    health = 100;
} else {
    health += 15;
}

您不需要为int上述每个单独的案例85。只需拥有一个else，这样，如果健康状况已经存在86或更高，则直接将其设置为100。

if(health <= 85)
    health += 15;
else
    health = 100;

我认为惯用的，面向对象的方法是setHealth在Character类上进行操作。该方法的实现将如下所示：

public void setHealth(int newValue) {
    health = Math.max(0, Math.min(100, newValue))
}

这可以防止运行状况低于0或高于100，无论您将其设置为什么。

您的getHealed()实现可以是这样的：

public void getHealed() {
    setHealth(getHealth() + 15);
}

Character拥有一个getHealed()方法是否有意义是读者的一项练习：)

我将提供更多可重用的代码片段，它不是最小的代码，但是您可以使用任何数量的代码，因此仍然值得一提

health += amountToHeal;
if (health >= 100) 
{ 
    health = 100;
}

如果要将统计信息添加到制作的游戏中，也可以将100更改为maxHealth变量，因此整个方法可能是这样的

private int maxHealth = 100;
public void heal(int amountToHeal)
{
    health += amountToHeal;
    if (health >= maxHealth) 
    { 
        health = maxHealth;
    }
}

编辑

有关更多信息

您可以在播放器损坏时执行相同的操作，但是您不需要minHealth，因为无论如何该值都为0。这样，您将可以使用相同的代码来破坏和修复任何金额。

health = health < 85 ? health + 15 : 100;

我会在助手类中创建一个静态方法。这样，您可以拥有一个通用的方法，而不是为需要适合某些边界的每个值重复执行代码。它将接受两个定义最小值和最大值的值，以及第三个将被限制在该范围内的值。

class HelperClass
{
    // Some other methods

    public static int clamp( int min, int max, int value )
    {
        if( value > max )
            return max;
        else if( value < min )
            return min;
        else
            return value;
    }
}

对于您的情况，您可以在某个地方声明最小和最大健康状况。

final int HealthMin = 0;
final int HealthMax = 100;

然后调用该函数，以传递您的最小，最大和调整后的运行状况。

health = HelperClass.clamp( HealthMin, HealthMax, health + 15 );

我知道这是一个学校项目，但是如果您以后想扩展游戏并能够提高治疗能力，请编写如下函数：

public void getHealed(healthPWR) {
    health = Math.min(health + healthPWR, 100);
}

并调用该函数：

getHealed(15);
getHealed(25);

...等等...

此外，您可以通过创建非函数本地变量来创建最大HP。由于我不知道您使用的是哪种语言，因此我不会显示示例，因为它的语法可能错误。

也许这个吗？

public void getHealed()
{
  if (health <= 85)
  {
    health += 15;
  } else
  {
    health = 100;
  }
}

如果您想要厚脸皮并且将代码放在一行上，则可以使用三元运算符：

health += (health <= 85) ? 15 : (100 - health);

请注意，由于（可能是）易读性差，某些人会不赞成这种语法！

我相信这会做

if (health >= 85) health = 100;
else health += 15;

说明：

• 如果治愈差距不超过15，则健康状况将变为100。

• 否则，如果差距大于15，它将使生命值增加15。

例如，如果健康值为83，它将变为98，而不是100。

如果我想成为线程安全的，我会这样做，而不是使用同步块。

原子的compareAndSet实现了与同步相同的结果，而没有开销。

AtomicInteger health = new AtomicInteger();

public void addHealth(int value)
{
    int original = 0;
    int newValue = 0;
    do
    {
        original = health.get();
        newValue = Math.min(100, original + value);
    }
    while (!health.compareAndSet(original, newValue));
}

使用模数运算符的最简单方法。

健康=（健康+ 50）％100;

健康永远不会等于或超过100。

   private int health;
    public void Heal()
    {
        if (health > 85)
            health = 100;
        else
            health += 15;
    }
    public void Damage()
    {
        if (health < 15)
            health = 0;
        else
            health -= 15;
    }