Question

我是java编程的初学者，并且正在尝试制作Rock Paper Scissors游戏。我为缺乏评论而道歉。

这是我的主程序，它调用另外两个对象。

 import java.util.*;

  public class RPSMain extends RPSPlayer{
   RPSPlayer player = new RPSPlayer();
   RPSGame gameObject = new RPSGame ();
   public void main () {


     Random generator = new Random ();
     Scanner sc = new Scanner(System.in);
     System.out.print ("Number of Rounds: ");
     int rounds = sc.nextInt();


    //Call and process all of the methods found in RPSPlayer and RPSGame
     for (int i = 0; i < rounds; i++){
        player.makeThrow();
        gameObject.makeThrow();
        gameObject.announceWinner (compThrow, getPThrow);
     }
    //Final Output
     System.out.print (gameObject.bigWinner(winner, rounds));
  }
//accessor to return round to RPSGame
   public static int getRound (int round){
     this.round = round;
     return round;
  }
}

我的第一个对象是玩家输入他们想要的投掷次数，然后在那里进行处理。

  import java.util.*;

  public class RPSPlayer {

  public static void main (String args[]) {
     Random generator = new Random ();
     Scanner sc = new Scanner(System.in);
  }
//This method gets the throw, and loops if throw is not within 1 and 3
  public static int makeThrow (){
     Scanner sc = new Scanner (System.in);
     int playerThrow;
     do{
        System.out.print ("Enter your throw (1=Rock, 2=Paper, 3=Scissors)");
        playerThrow = sc.nextInt();
     } while (playerThrow > 3 && playerThrow < 1);
     return playerThrow;
  }

    //Accessor method
  public static int getThrow (int playerThrow){
    this.playerThrow = playerThrow;
     return playerThrow;
  }


 }

最后一个对象是所有计算发生的地方。有很多变量无法正确编译，我无法弄清楚为什么......

  import java.util.*;

 public class RPSGame extends RPSPlayer{
  RPSPlayer player = new RPSPlayer();
  RPSGame game = new RPSGame ();
  RPSMain mainRPS = new mainRPS();
   public static void main (String args[]) {

     Random generator = new Random ();
     Scanner sc = new Scanner(System.in);
     int rounds = mainRPS.getRound(rounds);
   }
   //Random Throw Generator
   public static int makeCompThrow (){
     int Max = 3;
     int Min = 1;

     int compThrow =   Min + (int)(Math.random() * ((Max - Min) + 1));
     return compThrow;
  }

   //  Get the throw from the player in RPSPlayer
       public static int getPlayerThrow (){
     RPSPlayer player = new RPSPlayer();
     int getPThrow = player.makeThrow();
     return getPThrow;
  }

 //Does all of the calculatoins and ouputs who threw what.
   public static int announceWinner (int compThrow, int getPThrow) {
     int winner = 0;

     if (getPThrow == 1){
        System.out.println ("Player throws ROCK.");
     }
     else if (getPThrow == 2){
        System.out.println ("Player throws PAPER.");
     }
     else if (getPThrow == 3){
        System.out.println ("Player throws SCISSORS.");
     }


     if (compThrow == 1){
        System.out.println ("Computer throws ROCK.");
     }
     else if (compThrow == 2){
        System.out.println ("Computer throws PAPER.");
     }
     else if (compThrow == 3){
        System.out.println ("Computer throws SCISSORS.");
     }

     if (getPThrow == compThrow){
        winner = 3;
     }
     else if (getPThrow == 1 && compThrow == 3){
        winner = 1;
     }
     else if (getPThrow == 1 && compThrow == 2){
        winner = 2;
     }
     else if (getPThrow == 2 && compThrow == 1){
        winner = 1;
     }
     else if (getPThrow == 2 && compThrow == 3){
        winner = 2;
     }
     else if (getPThrow == 3 && compThrow == 1){
        winner = 2;
     }
     else if (getPThrow == 3 && compThrow == 2){
        winner = 1;
     }  

     return winner;
   }

//Final Output with imported values of 'rounds' and 'winner'
   public int bigWinner (int winner, int rounds){
     int tie = 0;
     int playerWins = 0;
     int compWins = 0;

     if (winner == 1){
        playerWins = playerWins + 1;
     }

     else if (winner == 0){
        tie = tie + 1;
     }

     else if (winner == 3){
        compWins = compWins + 1;
     }
     System.out.println ("You win " +playerWins+ ". Computer wins " +(compWins)+ ".");
     if (playerWins > compWins){
        System.out.print ("You win!"); 
     }
     if (playerWins < compWins){
        System.out.print ("Computer wins!"); 
     }

     if (playerWins == compWins){
        System.out.print ("It's a tie!"); 
     }
     return tie;
  }


 }

再次编译时，在添加WATTO Studios的建议后会出现2个新错误，这些是编译错误：

RPSMain.java:23: cannot find symbol
symbol  : variable winner
location: class RPSMain
     RPSGame.bigWinner(winner, rounds);
                       ^
RPSMain.java:23: non-static method bigWinner(int,int) cannot be referenced 
from a static context
     RPSGame.bigWinner(winner, rounds);

如果我从RPSGame引用它为什么不能找到变量'胜利者'，为什么它仍然在搜索RPSMain变量？

Answer 1

对于这些错误，在RPSMain课程中，您尝试从其他课程中访问变量。你的代码在这里......

 for (int i = 0; i < rounds; i++){
    player.makeThrow();
    gameObject.makeThrow();
    gameObject.announceWinner (compThrow, getPThrow);
 }

实际应该是这个......

 for (int i = 0; i < rounds; i++){
    int playerThrow = player.makeThrow();
    int compThrow = gameObject.makeCompThrow();
    gameObject.announceWinner (compThrow, playerThrow );
 }

请注意，当我们调用类似makeThrow()的方法时，我们会捕获变量并将其称为playerThrow。现在我们可以在announceWinner()方法中使用此变量。 compThrow变量也是如此。

您在RPSGame.bigWinner(winner, rounds);行中做同样的事情 - 它抱怨winner不存在。这是真的 - winner不是RPSMain中的变量，它只是RPSGame中的变量 - 你不能像这样在不同的类之间共享变量。

您的gameObject.announceWinner()方法会返回代表实际获胜者的int。如果要使用此返回值，则需要将其捕获到变量中。目前，您在RPGMain ...

中有这样的代码

for (int i = 0; i < rounds; i++){
   int playerThrow = player.makeThrow();
   int compThrow = gameObject.makeCompThrow();
   gameObject.announceWinner (compThrow, playerThrow );
}
System.out.print (gameObject.bigWinner(winner, rounds));

如果您想保留int方法返回的announceWinner()，则必须通过进行以下调整来捕获它...

for (int i = 0; i < rounds; i++){
   int playerThrow = player.makeThrow();
   int compThrow = gameObject.makeCompThrow();
   int winner = gameObject.announceWinner (compThrow, playerThrow );
   System.out.print (gameObject.bigWinner(winner, rounds));
}

现在说，gameObject.announceWinner()返回的值将存储在winner类中名为RPGMain的局部变量中。现在当它尝试在下一行的winner方法中使用gameObject.bigWinner()变量时，它知道该值。

要解决non-static method bigWinner(int,int) cannot be referenced from a static context错误，您需要更改以下行...

public int bigWinner (int winner, int rounds){

在其中加上static，就像这样......

public static int bigWinner (int winner, int rounds){

或者，更好的是，从代码中的任何位置删除单词static。如果您是Java新手，尝试使用static变量和方法只会使事情变得更加复杂，而且我真的不需要它，而且我看不出为什么需要它们{{{ 1}}在你的程序中。

Answer 2

compThrow和getPThrow是RPSGame的局部变量。你不能在RPSMain中使用它们。使用它们的一种方法是通过方法调用将这些作为参数发送到RPSMain，并在RPSMain中重新声明变量以接受这些变量。

其他更优选的解决方案是在类RPSPlayer中使它们成为受保护的实例变量。这样，通过继承，RPSGame和RPSMain都可以使用它们。

Answer 3

心理注意：好像你有很多静态方法，有些类完全由静态方法组成，但你仍然实例化类并调用方法，好像它们是对象实例的一部分

通常，在调用静态方法时，应使用静态引用：

RSPGame.makeCompThrow();

而不是

RSPGame game = new RSPGame().
game.makeCompThrow();

应生成编译器警告。

Answer 4

我会挑选你的makeThrow方法：

} while (playerThrow > 3 && playerThrow < 1);

永远不会循环，因为没有数字小于1 AND（&&）大于3。它应该读

} while (playerThrow > 3 || playerThrow < 1);

小于3的OR（||）小于1.现在它应该按预期工作。

由于缺少变量导致的编译器错误（变量在不同的类中定义）

4 个答案: