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

大家好， 我想请你们帮助我理解这个程序的逻辑，特别是我可能会用到的一些部分

1.方法

ranking（）

。它不接受任何参数，但返回参数“赢”和“平”的结果。好啊但是当我们这样称呼这个方法的时候

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

该计划如何知道这支队伍的“获胜”和“平局”的价值观？我知道OOP是关于将对象各自的引用传递给对象的。当我们第一次调用方法

adelaideCrows.matchResult（Ohiofotball，1,0）时，它是否起作用

then adelaideCrows是对方法matchResult的引用，在括号中传递这些参数，然后将它们存储在内存中的adelaideCrows引用下？因此，当我们下次使用另一个引用调用相同的方法时，

melbournSoccer.matchResult（newyorkSoccer，6,4）

那么参数“WIN”和“TIDE”在引用melbournSoccer下的括号中传递了它们自己的值？因此，在调用带有引用的方法ranking（）后，例如adelaideCrows，程序知道在该引用下已经存储了参数“won”和“tie”的值，然后该方法返回正确的值。对吧?

2.这里还有

System.out.println（melbournSoccer.compareTo（newyorkSoccer））逻辑是否相同？melbournSoccer引用在方法
public int compareTo（团队）
中连接到
this.ranking（）
，但引用newyorkSoccer连接到
Team.ranking（）
？那么调用
this.ranking（）
调用存储在引用melbournSoccer内存中的值等等

非常感谢

以下是主类的代码：

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));


这是团队课

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

       }



}

import java.util.ArrayList；
公共类团队实现了可比较的{
私有字符串名称；
int=0；
int lost=0；
整数=0；
int=0；
私有ArrayList成员=新ArrayList（）；
公共团队（字符串名称）{
this.name=名称；
}
公共字符串getName（）{
返回名称；
}
公共布尔addPlayer（T player）{
如果（成员包含（玩家））{
System.out.println（player.getName（）+”已在该服务器上
团队。”）；
返回false；
}否则{
成员。添加（玩家）；
System.out.println（player.getName（）+）已添加到团队中
“+此名称）；
返回true；
}
}
公共int numPlayers（）{
返回此.members.size（）；
}
公开无效匹配结果（团队OPONT、int OURCORE、int THIERSCORE）{
如果（我们的分数>他们的分数）{
韩元++；
}否则如果（我们的分数==他们的分数）{
绑定++；
}否则{
丢失的++；
}
播放++；
如果（opont！=null）{
oponent.matchResult（null，他们的分数，我们的分数）；
}
}
公共int排名（）{
回报（韩元*2）+平局；
}
@凌驾
公共int比较（团队）{
if（this.ranking（）>team.ranking（））{
返回-1；
}else if（this.ranking（）
我试图回答您的第一个问题：变量“赢”和“绑定”是实例变量。这意味着每次创建团队类的对象时，对象都会获得自己的“赢”和“绑定”变量以保存其中的数据。您可以使用唯一对象的名称访问它们（在您的情况下，团队名称如“adelaideCrows.won”等，不带引号）。回答关于“matchResult”功能的问题：该功能再次与您的对象相关，因为您没有使用“静态”“方法名称前面的声明。因此，如果没有静态，则类的每个实例都会获得自己的方法，因此，如果要将参数传递给该函数，则会将它们传递到objects函数中。如果要保存它们，则必须创建一个类变量（以“static int”为例）或者一个实例变量，以便在对象存在时保存数据，否则数据将传递给函数，并在函数执行完成后丢失。
以下是对问题的一些澄清

问题1：

方法
ranking（）
。它不接受任何参数，但返回结果
从参数“赢”和“平”。好的。但是当我们调用这个方法时
这：

程序如何知道“赢得”和“平局”的价值
adealideCrows
team

答案1：

考虑
Main
类中的以下语句：
adelaideCrows.matchResult（Ohiofotball，1，0）；
。执行此语句时：


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

注意事项：请参阅这篇关于StackOverflow的文章（我的答案），了解Java类、对象、引用以及类的属性和行为：


问题2：

还有这里
System.out.println（melbournSoccer.compareTo（newyorkSoccer））；
逻辑是否相同？
melbournSoccer
方法中连接了参考
public int compareTo（团队）
到
this.ranking（）
但是参考
newyorkSoccer
已连接到
team.ranking
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;
               }

       }



}

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