Vi vælger at basere klassen Kortbunke på List interfacet og ArrayList klassen.
Man kunne på en enkel måde blot anvende lister af kort, gennem List interfacet, men
denne opgave går ud på at lave en meget specifik klasse, som repræsenterer en bunke af spillekort.
Der bliver endvidere bedt om en helt bestemt grænseflade fra klassen. Derfor vælger vi at lave en
klasse Kortbunke, som er en klient af java.util.List (eller mere præcist, af java.util.ArrayList).
Klassen Kortbunke har en privat instansvariabel kaldet bunke af typen ArrayList. En del operationer
på kortbunken kalder blot en naturlig List operation på bunke (f.eks. tagØverte).
Man kan sige, at dette er en forholdsvis
omstændelig måde at lave klassen på, imodsætning til blot at bruge ArrayList, eller måske lave
en specialisering af ArrayList. Man kan dog pege på, at vi netop er i stand til at realisere en
bestemt grænsefalde i Kortbunke, og at vi kan indkapsle en del (ellers nødvendige) casts (typekonverteringer)
i Kortbunke's metoder (f.eks. i metoden tagØverste). Læg også mærke til operationen sorter, som sorterer en kortbunke i en bestemt rækkefølge.
Sorteringen foregår ved brug af den statiske metode Collections.sort(List,Comparator).
Den anden parameter er et objekt, som indkapsler en kort compare funktion. Der er tre konstruktorer i klassen Kortbunke. Konstruktoren der laver en tom bunke har, helt naturligt,
ingen parametre. Konstruktoren der laver en bunke med bestemte kort tager en liste af kort af typen List som parameter.
Konstruktoren som laver en bunke med et komplet kortspil har vi valgt at given en boolsk parameter.
Gennem konstanten HELT_KORTSPIL falder også denne konstruktor helt fornuftig på plads (se selv herunder). Her følger så min udgave af klassen Kortbunke, udvidet med nogle ekstra nyttige operationer
i forhold til opgavens ordlyd (lavet med henblik på smidig programmering af kortspillet Krig i en efterfølgende
opgave): Her er endvidere et link til det rene Java program med alle
nødvendige klasser samlet på én fil .import java.util.*;
class Kortbunke {
private List bunke;
/** Lav en tom kortbunke */
public Kortbunke (){
bunke = new ArrayList();
}
/** Lav en kortbunk med bestemte kort, repræsenteret som en liste */
public Kortbunke (List listeAfKort){
// Her burde vi nok checke typen af kort
bunke = (ArrayList)((ArrayList)listeAfKort).clone();
}
/** En konstant der symboliserer et fuldt spil kort */
public static final boolean HELT_KORTSPIL = true;
/** Lav et komplet spil kort hvis parameteren er den boolske værdi true. Hvis false, lav et tomt spil */
public Kortbunke (boolean kompletKortSpil){
bunke = new ArrayList();
if (kompletKortSpil){
for(int v = 1; v <= Spillekort.KONGE; v++)
for (int f = Spillekort.RUDER; f <= Spillekort.SPAR; f++){
Spillekort kort = new Spillekort(f,v);
bunke.add(kort);
}}
}
/** Fjern og returner øverste kort. Prebetingelse: bunken er ikke tom */
public Spillekort tagØverste(){
return (Spillekort)bunke.remove(0);
}
/** Læg kortet kort øverst i denne bunke */
public void lægØverst (Spillekort kort){
bunke.add(0,kort);
}
/** Læg alle kort i andenBunke øverst i denne bunke */
public void lægØverst(Kortbunke andenBunke){
for(Iterator kortIterator = andenBunke.bunkeIterator(); kortIterator.hasNext();){
this.lægØverst((Spillekort)kortIterator.next());
}
}
/** Læg kort nederst i denne bunke */
public void lægNederst (Spillekort kort){
bunke.add(kort);
}
/** Læg alle kort i andenBunke nederst i denne bunke */
public void lægNederst(Kortbunke andenBunke){
for(Iterator kortIterator = andenBunke.bunkeIterator(); kortIterator.hasNext();){
this.lægNederst((Spillekort)kortIterator.next());
}
}
/** Returner om denne bunke er tom */
public boolean erTom(){
return bunke.isEmpty();
}
/** Bland denne bunke tilfældigt */
public void bland(){
Collections.shuffle(bunke);
}
/* En klasse der indkapsler en compare funktion på to kort */
private static class KortSortering implements Comparator{
public int compare(Object o1, Object o2){
Spillekort kort1 = (Spillekort) o1;
Spillekort kort2 = (Spillekort) o2;
if (kort1.ligMed(kort2))
return 0;
else if (kort1.totalMindreEnd(kort2))
return -1;
else
return 1;
}
}
/** Sorter denne bunke ved brug af KortSortering's compare operation */
public void sorter(){
Collections.sort(bunke,new KortSortering());
}
/** Returner en iterator, som tillader et gennemløb af bunken */
public Iterator bunkeIterator(){
return bunke.listIterator();
}
/** Returner en streng præsentation af denne kortbunke */
public String toString(){
return bunke.toString();
}
/** Tøm denne bunke */
public void tøm(){
bunke.clear();
}
/** Returner antallet af kort i denne bunke */
public int antalKort(){
return bunke.size();
}
}