Eksamen 2011

       public static String MALE_GENDER = "male", FEMALE_GENDER = "female";
       private String gender;
       private Date dateOfBirth;

       public Person(String gender) {
              if (gender != MALE_GENDER && gender != FEMALE_GENDER) {
                      throw new IllegalArgumentException(gender + " is not a legal gender");
              }
              this.gender = gender;
       }

       public String getGender() {
              return gender;
       }    
       public Date getDateOfBirth() {
              return dateOfBirth;
       }
       public void setDateOfBirth(Date dateOfBirth) {
              this.dateOfBirth = dateOfBirth;
       }

		private String pid;
       private static int[] factors1 = {3, 7, 6, 1, 8, 9, 4, 5, 2}, factors2 = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};
       
		private static int computeControlDigit(String digits, int[] factors) {
              int sum = 0;
              for (int i = 0; i < factors.length; i++) {
                      sum += (digits.charAt(i) - '0') * factors[i];
              }
              return 11 - (sum % 11);
       }     
       private static boolean checkDigits(String digits, int pos, int num) {
              return (num / 10 == digits.charAt(pos) - '0' && num % 10 == digits.charAt(pos + 1) - '0');
       }   
       private boolean validatePID(String pid) {
              if (pid.length() != 11) {
                     return false;
              }

              for (int i = 0; i < pid.length(); i++) {
                      if (! Character.isDigit(pid.charAt(i))) {
                             return false;
                      }
              }
              int day = dateOfBirth.getDay(), month = dateOfBirth.getMonth(), year = dateOfBirth.getYear();
              if (! (checkDigits(pid, 0, day) && checkDigits(pid, 2, month)) && checkDigits(pid, 4, year)) {
                      return false;
              }
              boolean isOdd = ((pid.charAt(8) - '0') % 2) == 1;
              if ((gender == MALE_GENDER) != isOdd) {
                      return false;
              }
              int k1 = computeControlDigit(pid, factors1), k2 = computeControlDigit(pid, factors2);
              if (k1 != pid.charAt(9) - '0' || k2 != pid.charAt(10) - '0') {
                      return false;
              }
              return true;
       }
       public String getPID() {
              return pid;
       }

       public void setPID(String pid) {
              if (! validatePID(pid)) {
                      throw new IllegalArgumentException(pid + " is not a valid PID for " + gender + " and " + dateOfBirth);
              }
              this.pid = pid;
       }

public class MatchResult {
      
       private final String participant1, participant2;
       private int points1 = 0, points2 = 0;  

       public MatchResult(String participant1, String participant2) {
              this.participant1 = participant1;
              this.participant2 = participant2;
       }

       public String toString() {
              return participant1 + " - " + participant2 + ": " + points1 + " - " + points2;
       }
      
       public String getParticipant1() {
              return participant1;
       }

       public String getParticipant2() {
              return participant2;
       }

       public boolean isParticipant(String participant) {
              return participant.equals(participant1) || participant.equals(participant2);
       }
       public int getPoints(String participant) {
              if (participant.equals(participant1)) {
                      return points1;
              } else if (participant.equals(participant2)) {
                      return points2;
              } else {
                      return -1;
              }
       }
       public boolean isWinner(String participant) {
              return (participant.equals(participant1) && points1 > points2) || (participant.equals(participant2) && points2 > points1);
       }

       public boolean isDraw() {
              return points1 == points2;
       }

       public void addPoints(String participant, int points) {
              if (participant.equals(participant1)) {
                      points1 += points;
              } else if (participant.equals(participant2)) {
                      points2 += points;
              }
       }
} 

public class LeagueTableRow implements Comparable<LeagueTableRow> {
       private String participant;

       public LeagueTableRow(String participant) {
              this.participant = participant;
       }

       public String getParticipant() {
              return participant;
       }
       private int points = 0;
       public int getPoints() {
              return points;
       } 
       public void addPoints(int points) {
              this.points += points;
       }

       // Comparable<LeagueTableRow>  
       public int compareTo(LeagueTableRow other) {
              return other.points - points;
       }
}


Tabell-klassen må ha en konstruktør som tar inn navnene til lagene. Det er naturlig å opprette én tabellrad for hvert lag. En trenger ikke å huske navnene, siden de ligger i radene. En må ha en metode for å legge til et resultat som oppdaterer antall poeng for hvert lag og sorterer i etterkant. Innkapsling av radene, dvs. at en har metoder for å lese radene, er ikke så sentralt. Det kan gjøres på ulike måter og her gjør vi det enkelt med en iterator()-metode. (Siden vi har iterator()-metoden så har vi markert at klassen implementerer Iterable, men det er ikke viktig.)


public class LeagueTable implements MatchListener, Iterable<LeagueTableRow>{

       private List<MatchResult> matchResults;
       private List<LeagueTableRow> tableRows;

       public LeagueTable(List<String> participantNames) {
              this.matchResults = new ArrayList<MatchResult>();
              this.tableRows = new ArrayList<LeagueTableRow>();
              for (String participant : participantNames) {
                      tableRows.add(new LeagueTableRow(participant));
              }
       }

       private LeagueTableRow findEntry(String participant) {
              for (LeagueTableRow entry : tableRows) {
                      if (entry.getParticipant().equals(participant)) {
                             return entry;
                      }
              }
              return null;
       }
       public Iterator<LeagueTableRow> iterator() {
              return tableRows.iterator();
       }

       public int getParticipantPoints(MatchResult match, String participant) {
              if (match.isWinner(participant)) {
                      return 3;
              } else if (match.isParticipant(participant) && match.isDraw()) {
                      return 1;
              }
              return 0;
       }
       private void addPoints(MatchResult matchResult, String partipant) {
              findEntry(partipant).addPoints(getParticipantPoints(matchResult, partipant));
       }

       public void addMatchResult(MatchResult matchResult) {
              if (findEntry(matchResult.getParticipant1()) == null || findEntry(matchResult.getParticipant2()) == null) {
                      throw new IllegalArgumentException("Both teams must be part of the league");              }
              matchResults.add(matchResult);
              addPoints(matchResult, matchResult.getParticipant1());
              addPoints(matchResult, matchResult.getParticipant2());
              Collections.sort(tableRows);
       }
}