ฉันจะเพิ่มตัวแปรโดยไม่ให้เกินค่าสูงสุดได้อย่างไร

ฉันกำลังทำงานกับโปรแกรมวิดีโอเกมง่ายๆสำหรับโรงเรียนและฉันได้สร้างวิธีการที่ผู้เล่นจะได้รับคะแนนพลังชีวิต 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);
}

เพื่อให้มั่นใจว่า hitpoints Math.maxไม่ลดลงต่ำกว่าศูนย์คุณสามารถใช้ฟังก์ชั่นที่คล้ายกัน:

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

เพียงแค่เพิ่ม 15 ให้กับสุขภาพดังนั้น:

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

อย่างไรก็ตามตามที่ระบุไว้อย่างอ่อนโยนบางครั้งการทำงานแบบมัลติเธรด (การทำงานของโค้ดหลายบล็อกพร้อมกัน) การมีสุขภาพที่มากกว่า 100 ณจุดใดก็ได้อาจทำให้เกิดปัญหาได้และการเปลี่ยนคุณสมบัติด้านสุขภาพหลายครั้งอาจเป็นผลเสียได้เช่นกัน ในกรณีนี้คุณสามารถทำได้ดังที่กล่าวไว้ในคำตอบอื่น ๆ

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

คุณไม่จำเป็นต้องเป็นกรณีที่แยกต่างหากสำหรับแต่ละข้างต้นint 85เพียงแค่มีหนึ่งelseเพื่อที่ว่าถ้าสุขภาพที่มีอยู่แล้วหรือที่สูงขึ้นแล้วเพียงแค่ตั้งโดยตรงไปยัง86100

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

ถ้าฉันต้องการให้เธรดปลอดภัยฉันจะทำด้วยวิธีนี้แทนที่จะใช้บล็อกที่ซิงโครไนซ์

atomic 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;
    }