Java 如何使用OOP构造实现循环算法的类？

我在一个项目中工作，使用循环调度算法生成一个锦标赛。下面是我实现算法的类：

公共类匹配{
公共团队之家；
公共团队合作；
公共目标；
公共国际旅行社；
公众字符串匹配日；
公共国际午间；
公共字符串[][]轮；
公共字符串[][]轮；
团队列表=新团队（）；
//无参数构造函数
match（）{
}
比赛（连续比赛日、主场队、客场队、主场队、主场队、主场队）{
this.matchDay=matchDay；
this.teamHome=teamHome；
this.teamAway=teamAway；
this.teamHomeGoals=teamHomeGoals；
this.teamAwayGoals=teamAwayGoals；
}
//循环调度法
公共字符串[][]计划（）{
this.rounds=新字符串[（teamList.getSize（）-1）*2][（teamList.getSize（）/2）]；
对于（int round=0；round<（teamList.getSize（）-1）*2；round++）{
对于（int match=0；match<（teamList.getSize（）/2）；match++）{
this.teamHome=teamList.getIndex（（round+match）%（teamList.getSize（）-1））；
this.teamAway=teamList.getIndex（（teamList.getSize（）-1-匹配+轮数）%（teamList.getSize（）-1））；
//最后一队待在同一个地方，而其他队则围绕着它旋转。
如果（匹配==0）{
teamAway=teamList.getIndex（teamList.getSize（）-1）；
}
//从第二轮开始，在第二轮中交换球队的位置，以获得主客场比赛
弦混合音；
if（轮<（teamList.getSize（）-1））{
mixedRounds=（teamHome+“vs”+teamAway+“”+teamHome.getGoal（）+“-”+teamAway.getGoal（））；
}否则{
mixedRounds=（teamAway+“vs”+teamHome+“”+teamAway.getGoal（）+“-”+teamHome.getGoal（））；
}
轮数[轮数][匹配]=混合轮数；
}
}
回程；
}
}

schedule（）

方法可以很好地显示我的

团队列表

的比赛日程，这是一个

数组列表

，包含12个字符串（12个团队名称），下面是

团队

类，以便更好地理解。但是考虑到上述类的定义方式，我不可能在另一个类中调用不同的属性-例如，如果我想要特定团队的目标总数，我想调用一个方法，如

getteamhomegals（）

我一直在尝试的是将

schedule（）

方法“分解”为几部分：定义

setTeamHome（）

和

settamaway（）

方法，为每个方法生成随机目标，创建

getMatchDay（）

方法，并将每一轮构建为包含

teamHome

的

match

对象，

teamAway

，

teamHomeGoals

，

teamAwayGoals

，

matchDay

到目前为止，我有以下方法（没有返回我想要的）：

---

谢谢

将您的逻辑放入另一个类，如ScheduleGenerator，它将输出一个计划。计划是包含匹配项列表的类。比赛是由主队、探视队和日期组成的。您还可以添加用于评分和比赛统计的字段。homeTeam和visitorTeam和您一样是Team类的实例。在您的案例中，一个团队只有一个名称，但可以有一个团队中的球员列表和其他属性，如团队所在的城市。ScheduleGenerator类将在静态函数中执行所有逻辑，该函数将创建匹配的所有实例，并以参数形式提供团队列表

我觉得如果我给你更多的信息，我将做你的家庭作业。

团队课程：

public class Teams {

// the name of the team object
private String teamName;    


Teams (String name){
    this.teamName =name;
    }

public String getName(){
    return teamName;
}

@Override
public String toString(){
    return teamName;
}
}

游戏类别：

public class Game {
public Teams teamHome;
public Teams teamAway;
public String day;

Game(){
}

调度器类（ScheduleGenerator）

公共类调度程序{
公共字符串[][]轮；
//循环调度法
公共字符串[][]计划（ArrayList列表）{
this.rounds=新字符串[（list.size（）-1）*2][（list.size（）/2）]；
对于（int round=0；round<（list.size（）-1）*2；round++）{
对于（int match=0；match<（list.size（）/2）；match++）{
游戏=新游戏（）；
game.teamHome=list.get（（回合+比赛）%（list.size（）-1））；
game.teamAway=list.get（（list.size（）-1-比赛+回合）%（list.size（）-1））；
//最后一队待在同一个地方，而其他队则围绕着它旋转。
如果（匹配==0）{
game.teamAway=list.get（list.size（）-1）；
}
//从第二轮开始，在第二轮中交换球队的位置，以获得主客场比赛
弦混合音；
if（圆形<（列表大小（）-1））{
混响=（game.teamHome+“vs”+game.teamAway）；
}否则
//交换一半团队的位置（（teamList.size（）-1）
{
混响=（game.teamAway+“vs”+game.teamHome）；
}
轮数[轮数][匹配]=混合轮数；
}
}
回程；
}
}

和冠军级，捆绑在一起并展示：

import java.util.ArrayList;
import java.util.Arrays;
public class Championship {
public static ArrayList<Teams> teamList =  new ArrayList<Teams>();
public static Scheduler schedule = new Scheduler(); 

Championship(){ 
}

//static ArrayList<Teams> teamList = new ArrayList<Teams>();
public void createDefaultList(int noOfTeams){
    for(int i=0;i<noOfTeams;i++)  
    {  
        Championship.teamList.add(new Teams("Team "+ (i+1)));  
    }
}

public void createDanishLeagueList(){
    teamList.add(new Teams("Brondby IF"));
    teamList.add(new Teams("AaB"));
    teamList.add(new Teams("Viborg FF"));
    teamList.add(new Teams("Esbjerg"));
    teamList.add(new Teams("FC Copenhagen"));
    teamList.add(new Teams("Randers FC"));
    teamList.add(new Teams("FC Midtjylland"));
    teamList.add(new Teams("FC Nordsjaelland"));
    teamList.add(new Teams("Odense BK"));
    teamList.add(new Teams("AGF Aarhus"));
    teamList.add(new Teams("FC Vestsjaelland"));
    teamList.add(new Teams("Sonderjyske"));
}

public static void main(String[] args) {
    Championship championship = new Championship();


    //default teams (team1, team2, etc)
    championship.createDefaultList(4);

    //danish league teams
    //championship.createDanishLeagueList();

    String[][] fixtures = schedule.schedule(teamList);

    // Display the schedule

    for (int i = 0; i < (teamList.size() - 1)*2; i++) {
        if (i%2 == 0){
            System.out.println("Wednesday " +  (i + 2)/2);
        }
        else {
            System.out.println("Sunday " + (i+1)/2);    
        }
        for (int j = 0; j < (teamList.size()/2); j++){
            System.out.println(Arrays.asList(fixtures[i][j]));
            System.out.println();
            }
        }
}
}

import java.util.ArrayList；
导入java.util.array；
公开课冠军赛{
public static ArrayList teamList=new ArrayList（）；
public static Scheduler schedule=new Scheduler（）；
冠军{
}
//静态ArrayList团队列表=新建ArrayList（）；
public void createDefaultList（int nooftams）{
对于（int i=0；在花时间在算法上之前，我需要正确定义类。你的团队类没有任何意义。是的，这是我主要问的，它应该如何定义？Proba
public class Game {
public Teams teamHome;
public Teams teamAway;
public String day;

Game(){
}

public class Scheduler {
public String[][] rounds;

    //  round robin schedule method
    public String[][] schedule(ArrayList<Teams> list){


        this.rounds = new String[(list.size()-1)*2][(list.size() / 2)];

        for (int round = 0; round < (list.size()-1)*2; round++) {
            for (int match = 0; match < (list.size() / 2); match++) {
                Game game = new Game();

                game.teamHome = list.get((round + match) % (list.size() - 1)); 
                game.teamAway = list.get((list.size() - 1 - match + round) % (list.size() - 1)); 

                // Last team stays in the same place while the others rotate around it.
                if (match == 0) {
                    game.teamAway = list.get(list.size() - 1);
                }

                // from rounds half interchange the position of teams in rounds, to get both home and away matches     
                String mixedRounds;
                if (round < (list.size() - 1)) {
                    mixedRounds = ( game.teamHome + " vs " + game.teamAway );
                } else 
                    //interchange the place of teams from half ((teamList.size() - 1)
                {
                    mixedRounds = (game.teamAway + " vs " + game.teamHome);
                }

                rounds[round][match] = mixedRounds;
            }
        }
        return rounds;
    }
}

import java.util.ArrayList;
import java.util.Arrays;
public class Championship {
public static ArrayList<Teams> teamList =  new ArrayList<Teams>();
public static Scheduler schedule = new Scheduler(); 

Championship(){ 
}

//static ArrayList<Teams> teamList = new ArrayList<Teams>();
public void createDefaultList(int noOfTeams){
    for(int i=0;i<noOfTeams;i++)  
    {  
        Championship.teamList.add(new Teams("Team "+ (i+1)));  
    }
}

public void createDanishLeagueList(){
    teamList.add(new Teams("Brondby IF"));
    teamList.add(new Teams("AaB"));
    teamList.add(new Teams("Viborg FF"));
    teamList.add(new Teams("Esbjerg"));
    teamList.add(new Teams("FC Copenhagen"));
    teamList.add(new Teams("Randers FC"));
    teamList.add(new Teams("FC Midtjylland"));
    teamList.add(new Teams("FC Nordsjaelland"));
    teamList.add(new Teams("Odense BK"));
    teamList.add(new Teams("AGF Aarhus"));
    teamList.add(new Teams("FC Vestsjaelland"));
    teamList.add(new Teams("Sonderjyske"));
}

public static void main(String[] args) {
    Championship championship = new Championship();


    //default teams (team1, team2, etc)
    championship.createDefaultList(4);

    //danish league teams
    //championship.createDanishLeagueList();

    String[][] fixtures = schedule.schedule(teamList);

    // Display the schedule

    for (int i = 0; i < (teamList.size() - 1)*2; i++) {
        if (i%2 == 0){
            System.out.println("Wednesday " +  (i + 2)/2);
        }
        else {
            System.out.println("Sunday " + (i+1)/2);    
        }
        for (int j = 0; j < (teamList.size()/2); j++){
            System.out.println(Arrays.asList(fixtures[i][j]));
            System.out.println();
            }
        }
}
}