Question

所以基本上我创建了一个投注程序，其中Player1，Player2，Player3等是对象，每个都有五个初始化字段-1，这意味着没有赌注。

我要求用户输入他们的投注号码（这些数字是数组内的整数），他们最多可以有五个投注，解释了五个初始化字段-1。

这里的问题是我似乎无法找到让某些玩家只输入1或2个投注的方法，而另一个输入4和另外5个例如。如果他们拒绝下注5次，我的程序会强制每个用户输入5个整数。我能用这种方式工作吗？

所以这是我的驱动程序类:(其他部分无关紧要）

System.out.println("Wheel : 0-32-15-19-4-21-2-25-17-34-6-27-13-36-11-30-8-23-10-5-24-16-33-1-20-14-31-9-22-18-29-7-28-12-35-3-26"); 
        System.out.println("Dealer…Place your bets");

        // initializing the six players of the game

        Player player1 = new Player(-1,-1,-1,-1,-1);
        System.out.println("Player 1: ");
            int number1 = keyin.nextInt();
            int number2 = keyin.nextInt();
            int number3 = keyin.nextInt();
            int number4 = keyin.nextInt();
            int number5 = keyin.nextInt();
                System.out.println("");

        Player player2 = new Player(-1, -1, -1, -1, -1);
        System.out.println("Player 2: ");
            number1 = keyin.nextInt();
            number2 = keyin.nextInt();
            number3 = keyin.nextInt();
            number4 = keyin.nextInt();
            number5 = keyin.nextInt();
                System.out.println("");

        Player player3 = new Player(-1, -1, -1, -1, -1);
        System.out.println("Player 3: ");
            number1 = keyin.nextInt();
            number2 = keyin.nextInt();
            number3 = keyin.nextInt();
            number4 = keyin.nextInt();
            number5 = keyin.nextInt();
                System.out.println("");

        Player player4 = new Player(-1, -1, -1, -1, -1);
            System.out.println("Player 4: ");
            number1 = keyin.nextInt();
            number2 = keyin.nextInt();
            number3 = keyin.nextInt();
            number4 = keyin.nextInt();
            number5 = keyin.nextInt();
                System.out.println("");

        Player player5 = new Player(-1, -1, -1, -1, -1);
            System.out.println("Player 5: ");
            number1 = keyin.nextInt();
            number2 = keyin.nextInt();
            number3 = keyin.nextInt();
            number4 = keyin.nextInt();
            number5 = keyin.nextInt();
                System.out.println("");

        Player player6 = new Player(-1, -1, -1, -1, -1);
            System.out.println("Player 6: ");
            number1 = keyin.nextInt();
            number2 = keyin.nextInt();
            number3 = keyin.nextInt();
            number4 = keyin.nextInt();
            number5 = keyin.nextInt();
                System.out.println("");

这是我的其他球员类别：

public class Player {

int number1;
int number2;
int number3;
int number4;
int number5;
// constructor for each player at the table
public Player(int number1, int number2, int number3, int number4, int number5) {

    this.number1 = number1;
    this.number2 = number2;
    this.number3 = number3;
    this.number4 = number4;
    this.number5 = number5;

number1，number2 ...代表五个赌注。

另外，为了澄清，不能要求用户输入某个String，int，char，以让程序知道他/她已完成输入他们的赌注。它必须看起来像这样

Player 1: 12 13 15
Player 2: 0 5 4

Answer 1

跟进你的评论帕特里克。这就是您使用Integer.parseInt

的方式

...    
Player player2 = new Player(-1, -1, -1, -1, -1);
System.out.println("Player 2: ");
 try {
                number1 = Integer.parseInt(keyin.nextLine());
                number2 = Integer.parseInt(keyin.nextLine());
                number3 = Integer.parseInt(keyin.nextLine());
                number4 = Integer.parseInt(keyin.nextLine());
                number5 = Integer.parseInt(keyin.nextLine());
                System.out.println("");
    }
    //Code will go to this block when user entered something other than integers
    catch(NumberFormatException e) {
        System.out.println("Done accepting bets from player2");
    }
    ...

或者，可以将keyin.nextLine()的输出存储到字符串中并应用parseInt或对其进行评估以获得您想要的某个“关键字”。

String keyedinString = keyin.nextLine();
if(keyinString.equalsIgnoreCase("done betting") {
    throw new Exception();
}

你很快就会意识到这个过程的重复性。因此，正如其他人所说，建议考虑为您的任务使用数组和for循环。像这样。

int[] player1Bets = new int[5];
for(int i=0;i<5;i++) {
   try {
      player1Bets[i] = Integer.parseInt(keyin.nextLine());
   }
   catch(NumberFormatException e) {
       System.out.println("Player1 took" + i + "bets. he is done betting");
   }
}
...

这样，代替number1, number2, number3, number4 ...等，您将在player1Bets[0], second bet in player1Bets[1]中进行第一次下注...更容易输入和编码。

希望事情很清楚。

Answer 2

有很多方法可以做到这一点：

如果只有一个参数，则使用1,2,3,4,5参数构造函数。
更好的方法是使用BUilder模式，因为稍后您可能需要进行5次以上的投注，而不是继续添加构造函数，这是一个更好的选择。
您还可以使用变量参数。请参阅When do you use varargs in Java?
就像@immibs说的那样，你也可以拥有一个成员变量列表，然后你可以根据需要添加它们

Answer 3

您始终可以循环输入并为循环指定一定数量以终止。例如;投注是1,2和3并且从那里停止，用户可以输入0然后退出循环或者程序可以每次询问用户他们是否想要再次下注。例如，

投注：1

你想再次下注吗？按1表示是，0表示否

如果这个问题在逻辑部分更多，那么这可能对你有帮助。我希望我有所帮助，我是新来的，我试图回答问题，以提高我的技能和经验。：）

Answer 4

如果要传递多个参数并且参数计数不固定，则可能需要“构建器模式”。有关“构建器模式”的详细信息，请参阅https://jlordiales.wordpress.com/2012/12/13/the-builder-pattern-in-practice/。

以下是一个例子：

如果您有一个包含多个参数的User类，

public class User {
  private final String firstName; // required
  private final String lastName; // required
  private final int age; // optional
  private final String phone; // optional
  private final String address; // optional

  public static class UserBuilder {
    private final String firstName;
    private final String lastName;
    private int age;
    private String phone;
    private String address;
    public UserBuilder(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
    }
    public UserBuilder withAge(int age) {
      this.age = age;
      return this;
    }
    public UserBuilder withPhone(String phone) {
      this.phone = phone;
      return this;
    }
    public UserBuilder withAddress(String address) {
      this.address = address;
      return this;
    }
    public User build() {
      // if(age < 0) { ... } return new User(this);
      // not thread-safe, a second thread may modify the value of age
      User user = new User(this);
      if (user.getAge() < 0) {
        throw new IllegalStateException("Age out of range!"); // thread-safe
      }
      return user;
    }
  }

  private User(UserBuilder builder) {
    this.firstName = builder.firstName;
    this.lastName = builder.lastName;
    this.age = builder.age;
    this.phone = builder.phone;
    this.address = builder.address;
  }

  public String getFirstName() {
    return firstName;
  }
  public String getLastName() {
    return lastName;
  }
  public int getAge() {
    return age;
  }
  public String getPhone() {
    return phone;
  }
  public String getAddress() {
    return address;
  }
}

使用以下方式创建新的User实例：

User user1 = new User.UserBuilder("Jhon", "Doe")
                    .withAge(30)
                    .withPhone("1234567")
                    .withAddress("Fake address 1234")
                    // maybe more parameters
                    .build();
User user2 = new User.UserBuilder("Tom", "Jerry")
                    .withAge(28)
                    // maybe more parameters
                    .build();

使用没有构造函数参数的对象java

4 个答案: