大家好,,我想请你们帮助我理解这个程序的逻辑,特别是我可能在其中的一些部分。
1.方法ranking()
。它不接受任何参数,但返回参数"won“和"tied”的结果。好的。但是当我们像这样调用这个方法时
System.out.println(adelaideCrows.getName()+": result:
"+**adelaideCrows.ranking()**);
程序如何知道这个adealideCrows团队的“赢”和“平”的值?我知道OOP是关于将对象分别引用到对象。那么,当我们第一次调用adelaideCrows.matchResult(ohioFotlball, 1,0);
方法时,那么adelaideCrows是对matchResult方法的引用,在括号中传递这三个参数,然后将它们存储在adelaideCrows引用下的内存中吗?因此,当我们下一次使用另一个引用melbournSoccer.matchResult(newyorkSoccer,6,4);
调用相同的方法时,参数"won“和"tied”会在引用melbournSoccer下的括号中传递自己的值吗?因此,在调用带有引用的方法ranking()之后,例如,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、SoccerrPlayer和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;
}
}
}
发布于 2018-09-19 05:53:12
我试着回答你的第一个问题:变量“won”和“tied”是实例变量。这意味着每次创建team类的对象时,该对象都会获得自己的“won”和“tied”变量,以便在其中保存数据。您可以使用唯一对象的名称来访问它们(在您的示例中,团队名称为不带引号的示例“adelaideCrows.won”)。回答有关“matchResult”函数的问题:该函数再次与您的对象相关,因为您没有在方法名前面使用“static”声明。因此,如果没有静态,类的每个实例都有自己的方法,所以如果您将参数传递给该函数,它们将被传递到对象函数中。如果你想保存它们,你必须创建一个类变量(以“static int”为例)或一个实例变量,以便在对象存在时保存数据,否则数据将传递给函数,并在函数执行完成后丢失。
https://stackoverflow.com/questions/52394748
复制相似问题