Question

大家好， 我想请您帮忙了解此程序的逻辑，尤其是我可能要堆叠的某些部分。

1。方法ranking()。它不接受任何参数，但返回参数“赢得”和“并列”的结果。好。但是当我们像这样

调用此方法时

System.out.println(adelaideCrows.getName()+": result: 
         "+**adelaideCrows.ranking()**);

程序如何知道这个adealideCrows团队的“获胜”和“并列”值？我知道OOP是关于传递对象各自对对象的引用。那么它是否起作用，以便当我们首先调用方法adelaideCrows.matchResult(ohioFotlball, 1,0);时，对方法matchResult的引用就是adelaideCrows的引用，并在括号中传递参数，然后将它们存储在adelaideCrows的引用下的内存中？因此，当我们接下来用另一个引用melbournSoccer.matchResult(newyorkSoccer,6,4);调用同一方法时，参数“ won”和“ tied”在引用melbournSoccer下的括号中传递了自己的值？所以在调用例如带有引用的方法rank（）之后adelaideCrows程序知道在该引用下已经存储了“ won”和“ tied”参数的值，然后该方法返回正确的值。对吧？

2。这里System.out.println(melbournSoccer.compareTo(newyorkSoccer));的逻辑是否相同？ melbournSoccer引用在方法public int compareTo(Team<T> team)中连接到this.ranking()，但是引用newyorkSoccer是连接到team.ranking()吗？那么调用this.ranking()会调用存储在参考melbournSoccer内存中的值，依此类推吗？

非常感谢。

这是Main类的代码：

public class Main
{
    public static void main(String[] args) {
        SoccerPlayer soccerPlayer = new SoccerPlayer("joe");
        BaseballPlayer baseballPlayer = new BaseballPlayer("pat");
        FootballPlayer footballPlayer = new FootballPlayer("backham");


         Team<FootballPlayer> adelaideCrows = new Team<>("Adelaide Crows 
         footbal");
         Team<SoccerPlayer> melbournSoccer = new Team<>("Melbourn soccer");
         Team<BaseballPlayer> jerseeBaseball = new Team<>("Jersee 
         Baseball");


         melbournSoccer.addPlayer(soccerPlayer);
         jerseeBaseball.addPlayer(baseballPlayer);

         adelaideCrows.matchResult(ohioFotlball, 1,0);
         melbournSoccer.matchResult(newyorkSoccer,6,4);

         System.out.println("Ranking...");
         System.out.println(adelaideCrows.getName()+": result: 
         "+adelaideCrows.ranking());
         System.out.println(melbournSoccer.getName()+": result: 
         "+melbournSoccer.ranking());
         System.out.println(jerseeBaseball.getName()+": result: 
         "+jerseeBaseball.ranking());


         System.out.println(melbournSoccer.compareTo(newyorkSoccer)); 
         System.out.println(adelaideCrows.compareTo(ohioFotlball));

这里是Player类，另外三个类FotballPlayer，SoccerPlayer和BaseballPlayer继承自该类。

public abstract class Player{
    private String name;

    public Player(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

}

这是团队班。

import java.util.ArrayList;

public class Team<T extends Player> implements Comparable<Team<T>>{
    private String name;
    int played = 0;
    int lost = 0;
    int won = 0;
    int tied = 0;

    private ArrayList<T> members = new ArrayList<>();

    public Team(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public boolean addPlayer(T player){    
        if(members.contains(player)){
            System.out.println(player.getName()+" is already on this 
   team.");
            return false;
        }else{
            members.add(player);
            System.out.println(player.getName()+" has been added to team 
  "+this.name);
            return true;
        }
    }

    public int numPlayers(){
        return this.members.size();

    }

    public void matchResult(Team<T> oponent, int ourScore, int theirScore){
        if(ourScore > theirScore){
            won++;
        }else if(ourScore == theirScore){
            tied++;
        }else{
            lost++;
        }
        played++;
        if(oponent != null){
            oponent.matchResult(null, theirScore, ourScore);
        }
    }

    public int ranking(){
        return (won * 2) + tied;
    }

    @Override
    public int compareTo(Team<T> team){
       if(this.ranking() > team.ranking()){
           return -1;
       } else if(this.ranking() < team.ranking()){
               return 1;
       }
            else{
                   return 0;
               }

       }



}

Answer 1

以下是对这些问题的澄清。

问题1 ：

方法ranking()。它不接受任何参数，但返回结果从参数“赢”和“绑”。好。但是当我们像这样调用此方法时

System.out.println(adelaideCrows.getName() + ": result: " + **adelaideCrows.ranking()**);

程序为此如何知道“获胜”和“并列”的值 adealideCrows团队？ ...

答案1 ：

在Main类中考虑以下语句：adelaideCrows.matchResult(ohioFotlball, 1, 0);。当该语句执行时：

adelaideCrows对象受到影响。在matchResult方法中，根据方法输入更改实例变量won和tied 参数（在这种情况下为1和0）。
执行语句adelaideCrows.ranking()时，ranking()方法使用adelaideCrows的对象实例变量won和tied（之前已设置）计算排名（(won * 2) + tied并返回值。

注释：请参阅有关StackOverflow的这篇文章（我的回答），以了解有关Java类，对象，引用以及类的属性和行为的知识：Object References in Java。

问题2 ：

还有这里 System.out.println(melbournSoccer.compareTo(newyorkSoccer));是否逻辑是一样的吗？ melbournSoccer个引用已在方法中连接 public int compareTo(Team<T> team)至this.ranking()，但参考 newyorkSoccer已连接到team.ranking()？所以打电话 this.ranking()调用引用内存中存储的值 melbournSoccer等等？

答案2 ：

考虑以下语句：System.out.println(melbournSoccer.compareTo(newyorkSoccer));

Q）。 melbournSoccer个引用已在方法public int compareTo(Team<T> team) to this.ranking()中连接
A）。关键字this指向当前对象-这里是melbournSoccer。 this.ranking方法获得melbournSoccer的排名。

Q）。引用newyorkSoccer已连接到team.ranking()？
A）。方法参数compareTo()以Team作为输入-这里是一个newyorkSoccer组对象。

Q）。那么调用this.ranking()会调用引用melbournSoccer的内存中存储的值，依此类推吗？
A）。是的。

注释：这是指向Oracle Java教程主题Using the this Keyword的链接。

Answer 2

我尝试回答您的第一个问题：变量“ won”和“ tied”是实例变量。这意味着每次您创建团队类的对象时，该对象都会获得自己的“ won”和“ tied”变量以将数据保存到其中。您可以使用唯一对象的名称来访问它们（在您的情况下，团队名称例如“ adelaideCrows.won”，不带引号）。要回答有关“ matchResult”函数的问题：该函数又与您的对象相关，因为您没有在方法名称前使用“ static”声明。因此，如果没有静态实例，则类的每个实例都会获得自己的方法，因此，如果将参数传递给该函数，则它们将被传递给对象函数。如果要保存它们，则必须创建一个类变量（以“ static int”为例）或一个实例变量，以便在对象存在的情况下保存数据，否则数据将被传递给函数，函数执行完成后将会丢失。

程序如何将值传递给方法rank（）

2 个答案: