I'；我想测试两个整数中哪一个最接近Java中的第三个整数

我觉得这有一个非常明显的答案，所以请原谅我的愚蠢。 我正在为小学生创建一个简单的基于文本的游戏，在这个游戏中，作为法师的用户需要通过混合各种法术卡（在我的例子中，将它们的值相乘，以尝试获得最接近龙的弱点数）来避开强大的龙。这个弱点数字每回合都会改变，直到龙的生命值小于或等于0，这时另一条龙将诞生，玩家也将不得不避开这条龙。整个项目分为五类，一类是玩家，另一类是纸牌，另一类是龙，另一类是游戏的玩法，第五类是车手。 我想到的第一件事是在Player.java中创建一个如下所示的方法：

    public int isClosestToo(int num, int max){
        int counter = 0;
        for(int i = num; i <= max; i++){
            counter++
        }
        return counter;    
    }

我意识到这是可行的，但我想确保我没有遗漏一些明显的、简单的我可以做的事情。可能是Integer类中的某个方法？ 请记住，这是该项目的早期版本，我希望稍后实现Slick2D图形。 以下是我迄今为止的所有代码： 从Game.java：

import java.util.Scanner;

   public class Game {
Scanner scan = new Scanner(System.in);
public Game(){}

public void play(){
    Player p = new Player();
    while(p.getHP() > 0){
        Dragon d = new Dragon();
        System.out.println("You have " + p.getHP() + " HP");
        System.out.println(d);
        System.out.println(p.elementHandToString());
        System.out.println(p.attackHandToString());
        System.out.println("Choose the two cards that multiply to be closest too the weakness of the dragon for the most damage!");
        int element = scan.nextInt();
        int attack = scan.nextInt();
        int damage = d.getWeakness() - (p.getElementCard(element - 1).getNum() * p.getAttackCard(attack - 1).getNum());
        d.setHP(d.getHP() - damage);
        p.afterTurn(element, attack);
        d.newWeakness();
    }
}
}

和Player.java：

import java.util.Random;
import java.util.ArrayList;

public class Player {
Random r = new Random();
int hp;
ArrayList<Card> attackHand;
ArrayList<Card> elementHand;
ArrayList<String> elements;
ArrayList<String> attacks;


public Player(){ 
    this.hp = 100;
    this.genHands();
    attackHand = new ArrayList<Card>();
    elementHand = new ArrayList<Card>();

    //arraylist of types of elements, feel free to add more using the .add method
    elements = new ArrayList<String>();
    elements.add("Fire");
    elements.add("Ice");
    elements.add("Water");
    elements.add("Air");
    elements.add("Rock");
    elements.add("Mana");

    //arraylist of types of attacks, feel free to add more using the .add method
    attacks = new ArrayList<String>();
    attacks.add("Projectile");
    attacks.add("Self");
    attacks.add("Explosion");
    attacks.add("Repeated");
    attacks.add("Debuff");
    attacks.add("Melee");
}

public Player(int hp){ this.hp = hp; }

public int getHP(){ return hp; }

public ArrayList<Card> getAttackHand(){ return attackHand; }

public ArrayList<Card> getElementHand(){ return elementHand; }

public Card getAttackCard(int whichCard){ return attackHand.get(whichCard); }

public Card getElementCard(int whichCard){ return elementHand.get(whichCard); }

public void afterTurn(int element, int attack){ 
    attackHand.add(new Card(genRand(1, 12), attacks.get(genRand(1, 12))));
    elementHand.add(new Card(genRand(1, 12), elements.get(genRand(1,12))));
    attackHand.remove(attack - 1);
    elementHand.remove(element - 1);
}

public String elementHandToString(){ return "Card 1: " + elementHand.get(0) + "/nCard 2: " + elementHand.get(1) + "/nCard 3: " + elementHand.get(2) + "/nCard 4: " + elementHand.get(3); }

public String attackHandToString(){ return "Card 1: " + attackHand.get(0) + "/nCard 2: " + attackHand.get(1) + "/nCard 3: " + attackHand.get(2) + "/nCard 4: " + attackHand.get(3); }

//generates the player's hands
public void genHands(){
    //creates a deck of random elemental cards
    for(int x = 0; x <= 4; x++){
        elementHand.add(new Card(genRand(1, 12), elements.get(genRand(0, elements.size() - 1))));
    }

    //creates a deck of random attack cards
    for(int i = 0; i <= 4; i++){
        attackHand.add(new Card(genRand(1, 12), attacks.get(genRand(0, attacks.size() - 1))));
    }
}

//returns a random integer between min and max
//@param1 minimum number for random to be
//@param2 maximum number for random to be
public int genRand(int min, int max){ return r.nextInt(max) + min; }
}

最后是Card.java：

import java.util.Random;

public class Card{
int num;
Random r = new Random();
String element;

public Card(){
    num = 0;
    element = "n/a";
}

public Card(int n, String e){
    num = n;
    element = e;
}

public int getNum(){
    return num;
}

public String getElement(){
    return element;
}

public String toString(){
    return "This is a " + element + "card with a value of " + num + ".";
}
}

首先，我遇到的问题是Game类的play（）循环，我需要计算玩家造成的伤害。很明显，（在我用元素逻辑编程之前），我希望伤害能真正造成伤害，而不是以负数结束，让龙获得生命。我们将非常感谢您的任何帮助。非常感谢。 -尼克

这是一个选项

if((max-int1)>(max-int2) && max-int2>=0){
   //do something with int2
}
else if((max-int1)<(max-int2) && max-int1>=0){
   //do something with int1
}
else if(max-int1>=0){
   //do something with int1
}
else if(max-int2>=0){
   //do something with int2
}
else{
   //do something if conditions aren't met
}

if（（max-int1）>（max-int2）&max-int2>=0）{
//用int2做点什么
}
else如果（（max-int1）=0）{
//用int1做点什么
}
否则如果（max-int1>=0）{
//用int1做点什么
}
否则如果（max-int2>=0）{
//用int2做点什么
}
否则{
//如果条件不满足，就做些什么
}

在java中，当一个方法以“is”开头时，它返回布尔值。但是你的项目可能由你自己维护，它可以是你想要的任何东西。 isClosestToo方法接受两个参数，即num和max，都是整数，但当调用它时，只接受一个参数

    public int isClosestToo(int num, int max){
        int counter = 0;
        for(int i = num; i <= max; i++){
            counter++
        }
        return counter;    
    }


    if(isClosestToo(num1) > isClosestToo(num2){
        /*do something*/
    }

---

您可以取Max-int1和Max-int2，如果（Math.abs（Max-num1）；否则返回num2稍微短一点。返回Math.abs（max-num1）num1和

num2

正数？为什么不干脆

if（num1>num2）

或者反之亦然

if((max-int1)>(max-int2) && max-int2>=0){
   //do something with int2
}
else if((max-int1)<(max-int2) && max-int1>=0){
   //do something with int1
}
else if(max-int1>=0){
   //do something with int1
}
else if(max-int2>=0){
   //do something with int2
}
else{
   //do something if conditions aren't met
}

    public int isClosestToo(int num, int max){
        int counter = 0;
        for(int i = num; i <= max; i++){
            counter++
        }
        return counter;    
    }


    if(isClosestToo(num1) > isClosestToo(num2){
        /*do something*/
    }

public int ClosestTo(int[] num,int max)
{
    1.declare a variable to store the closest num
    2.for every element in num, if Math.abs(max-num) < closestNum, store num to closestNum
    3.return closestNum
}

public int DiffMax(int num)
{
    1. return Math.abs(max-num) < closestNum
}

 if(DiffMax(num1) > DiffMax(num2){
        /*do something*/
    }