比较来自同一类、不同类的两个整数

Question

为学校做一项大作业，需要帮助解决一个问题。

我们需要比较“Class X”（属性类）中的两个整数，在“Class Y”中我们有一些方法。这只是分配的结构。

到目前为止我们的代码：

import java.util.ArrayList;

public class Event {

private String name;
private int numberOfTries;
private ArrayList<Result> resultList = new ArrayList<Result>();

public Event(String name, int numberOfTries) {
    this.name = name;
    this.numberOfTries = numberOfTries;
}

public String getName() {
    return name;
}

public int getNumberOfTries() {
    return numberOfTries;
}

public String toString() {
    return name + ", " + numberOfTries;
}

public void addResult(Participant partResult) {
    int participantIndex = -1;
    for (int i = 0; i < resultList.size(); i++) {
        if (resultList.get(i).getParticipant().getStartNumber() == partResult.getStartNumber()) {
    for (int a = 0; a < result.length; a++)
    result[i] = maxAttempts();
}
}
}
}

这个问题：无法将结果求解为变量。未为 Event 类型定义 maxAttempts。

其他类：

public class Result {

public double[] result;
public Participant participant;
public int maxAttempts;
public int attemptsUsed;
public Result(double result, int noOfAttempts, Participant p) {
    //this.result = result;
    this.result = new double[noOfAttempts];
    this.result[0]= result;
    this.participant = p;
    this.maxAttempts=noOfAttempts;
    attemptsUsed++;
    }

public double[] getResult() {
    return result;
}
public Participant getParticipant() {
    return participant;
}
public int getAttemptsUsed() {
    return attemptsUsed;
}
public int getMaxAttempts() {
    return maxAttempts;
}

import java.util.ArrayList;
import java.util.Scanner;

public class SportsCompetition {
private Scanner scan;
private ArrayList<Event> eventList = new ArrayList<Event>();
private ArrayList<Participant> participantList = new   ArrayList<Participant>();
private int eventLoop, participantLoop, participantLoop2, participantLoop3,  number, startNumber;
private Participant partResult;
private Event eventResult;

public static void main(String[] args) {
    new SportsCompetition().run();
}

private void run() {
    scan = new Scanner(System.in);
    commandLoop();
}

private void commandLoop() {
    boolean exit = false;
    do {
        System.out.println(
                "Vad vill du göra?\n1. Lägg till gren\n2. Lägg till deltagare\n3. Ta bort deltagare\n4. Lägg till resultat\n5. Resultatlista för deltagare\n6. Resultatlista för gren\n7. Meddelande\n8. Avsluta");
        String Command = scan.nextLine();
        switch (Command) {
        case "1":
        case "add event":
            addEvent();
            break;
        case "2":
        case "add participant":
            addParticipant();
            break;
        case "3":
        case "remove participant":
            removeParticipant();
            break;
        case "4":
        case "add result":
            addResult();
            break;
        //
        // case "5":
        // case "participant":
        // participant();
        // break;
        //
        // case "6":
        // case "GRENNAMN":
        // OKLART();
        // break;
        //
        // case "7":
        // case "message":
        // message();
        // break;
        //
        case "8":
        case "exit":
            exit = true;
        default:
            System.out.println("Fel! Mata in godkänt kommando!");
        }
    } while (!exit);
}

public void addEvent() {
    eventList.add(new Event("Jacob", 5));
    eventLoop = 0;
    while (eventLoop == 0) {
        eventLoop++;
        System.out.print("Event name: ");
        String name = scan.nextLine();
        name = name.trim();
        if (name.matches(".*[a-z].*")) {
            for (int i = 0; i < eventList.size(); i++) {
                if (eventList.get(i).getName().equals(name)) {
                    System.out.println("Error " + name + " has already been added\n");
                    return;
                }
            }
        } else {
            System.out.println("Error: name can't be empty!");
            eventLoop = 0;
        }
        System.out.print("Attempts allowed: ");
        int numberOfTries = scan.nextInt();
        scan.nextLine();
        while (numberOfTries <= 0) {
            System.out.print("Error: too low, must be at least one attempt: ");
            int numberOfTries2 = scan.nextInt();
            scan.nextLine();
            numberOfTries = numberOfTries;
        }
        eventList.add(new Event(name, numberOfTries));
        System.out.println(name + " added\n");

    }
}

public boolean checkString(String s) {
    if (s.length() > 0 && s.matches(".*[a-z].*")) {
        return true;
    } else {
        return false;
    }
}

public void addParticipant() {
    String firstName = "name";
    String lastName = "name";
    String team = "name";
    participantLoop = 0;
    while (participantLoop == 0) {
        System.out.print("First name: ");
        firstName = scan.nextLine();
        firstName = firstName.trim();
        if (checkString(firstName) == false) {
            System.out.println("Error: name can't be empty!");
            participantLoop = 0;
        } else {
            participantLoop++;
        }
    }
    participantLoop2 = 0;
    while (participantLoop2 == 0) {
        System.out.print("Last name: ");
        lastName = scan.nextLine();
        lastName = lastName.trim();
        if (checkString(lastName) == false) {
            System.out.println("Error: name can't be empty!");
            participantLoop2 = 0;
        } else {
            participantLoop2++;
        }
    }
    participantLoop3 = 0;
    while (participantLoop3 == 0) {
        participantLoop3++;
        System.out.print("Team: ");
        team = scan.nextLine();
        team = team.trim();
        if (checkString(team) == false) {
            System.out.println("Error: name can't be empty!");
            participantLoop3 = 0;
        } else {
            // boolean found = false;
            // for (int i = 0; i < participantList.size(); i++) {
            // if (participantList.get(i).getTeam().equalsIgnoreCase(team)) {
            // participantList.get(i);
            // found = true;
            // }
            // }
            //
            // if (!found) {
            // participantList.add(new Team);
            // }
            participantLoop3++;
        }
    }
    number++;
    startNumber = 99 + number;
    participantList.add(new Participant(firstName, lastName, team, startNumber));
    System.out.println(firstName + " " + lastName + " from " + team + " with number " + startNumber + " added.");
    // printa listan för att testa
    System.out.print(participantList);
}

public void removeParticipant() {
    System.out.println("Skriv in siffran på deltagaren du vill ta bort: ");
    int startNumber = scan.nextInt();
    scan.nextLine();
    boolean found = false;
    for (int i = 0; i < participantList.size(); i++) {
        if (participantList.get(i).getStartNumber() == startNumber) {
            participantList.remove(i);
            found = true;
            System.out.println(startNumber + " har tagits bort!\n");
        }
    }
    if (!found) {
        System.out.println("Error: no participant with number" + startNumber + "found!\n");
    }
}

public void addResult() {

    System.out.println("Ange nummer på deltagare: ");
    int startNumber = scan.nextInt();
    scan.nextLine();
    boolean numberFound = false;

    for (int i = 0; i < participantList.size(); i++) {
        if (participantList.get(i).getStartNumber() == startNumber) {
            numberFound = true;
            partResult = participantList.get(i);
        }
    }
    if (!numberFound) {
        System.out.println("Error: no participant with number " + startNumber + " found!\n");
        numberFound = false;
        return;
    }

    System.out.println("Event: ");
    String name = scan.nextLine();
    boolean eventFound = false;

    for (int i = 0; i < eventList.size(); i++) {
        if (eventList.get(i).getName().equalsIgnoreCase(name)) {
            eventFound = true;
            eventResult = eventList.get(i);
        }
    }

    if (!eventFound) {
        System.out.println("Error: no event with name " + name + " found!\n");
        eventFound = false;
        return;
    }

    System.out.println("Results for " + partResult.getFirstName() + " " + partResult.getLastName() + " from "
            + partResult.getTeam() + " in " + eventResult.getName() + ": ");
    int result = scan.nextInt();
    scan.nextLine();

}
}

import java.util.ArrayList;

public class Participant {

private String firstName, lastName, team;
private int startNumber;
private ArrayList<Result> participantResultList = new ArrayList<Result>();

public Participant(String firstName, String lastName, String team, int startNumber) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.team = team;
    this.startNumber = startNumber;
}

public String getFirstName() {
    return firstName;
}

public String getLastName() {
    return lastName;
}

public String getTeam() {
    return team;
}

public int getStartNumber() {
    return startNumber;
}

public String toString() {
    return firstName + lastName + team + startNumber;
}

public void addResult(Result result) {
    participantResultList.add(result);
}

}

Answer 1

好吧，我不知道您的代码的确切逻辑，但您可以将 addResult 方法更改为以下内容：

public void addResult(Participant partResult) {
    int participantIndex = -1;
    for (int i = 0; i < resultList.size(); i++) {
        Result result = resultList.get(i);
        if (result.getParticipant().getStartNumber() == partResult.getStartNumber()) {
            for (int a = 0; a < result.getResult().length; a++)
                result.getResult()[i] = result.getMaxAttempts();
        }
    }
}

Answer 2

在您的 Event 类中，您可以这样做：

result[i] = maxAttempts();

但在您的 Events 类中，您没有 maxAttempts 方法。您需要添加此方法，或者从正确的类/实例中调用它。

回答这个问题：

未为 Event 类型定义 maxAttempts。

另一个问题：

结果无法解析为变量。

您正在尝试将该方法的结果分配为名为 result 的数组的元素，但在您的 Event 类中没有这样的数组，在您的方法中也没有作为局部变量。

编辑

要调用该方法，首先需要创建类Result的实例

Result example = new Result(0, 5, partResult);

完成后，你可以调用它的get方法：

example.getMaxResults();

那么你就有了你的结果。如果要将其存储在数组中，则需要在本地或类级别创建该数组（或其他变量）。

无论哪种方式，我的建议是停止做你现在正在做的事情。你写了一大堆你自己都不理解的代码。

先学习OO的基本原理，以后会容易很多。