[JAVA] Ich habe die Serverseite des Online-Kartenspiels gemacht made

Letztes Mal hier

Entschuldigung

Ich habe ein wenig geschummelt. .. .. Wir werden dieses Mal kein Deck oder keine Hand implementieren.

Stattdessen möchte ich eine abstrakte Klasse erstellen, die die Klassen enthält, die die Karten zusammenhalten.

Machen Sie ein paar Karten Schnittstelle

Deck, Hand, Friedhof usw. enthalten mehrere Karten in einer Datenstruktur. Also habe ich ein Kartenbündel-Interface erstellt.

public interface CardSheaf {
    /**
     *Gibt zurück, wo sich das übergebene Kartenobjekt in der Datenstruktur befindet.
     *Stellen Sie sicher, dass die Datenstruktur eine Liste oder ein Array ist.
     * @param card Das Objekt der Karte, deren Nummer Sie wissen möchten
     * @Rückgabe Nummer in der Struktur des Argumentobjekts
     */
    int indexOf(Card card);

    /**
     *Gibt die Anzahl der Karten zurück.
     * @Anzahl der Rückgabekarten
     */
    int cardSize();

    /**
     *Fügen Sie der Datenstruktur eine Karte hinzu.
     */
    void addCard(Card card);

    /**
     *Entfernen Sie die Karte aus der Datenstruktur.
     */
    void removeCard(Card card);

    /**
     *Entfernen Sie die Karte aus der Datenstruktur.
     */
    void removeCard(int index);

    /**
     *Gibt eine Karte zurück, deren Nummer und Markierung übereinstimmen.
     */
    Card find(int number, Card.Mark mark);

    /**
     *Gibt die Nummer der Karte zurück, deren Nummer und Markierung übereinstimmen.
     */
    int indexOf(int number, Card.Mark mark);

    /**
     *Gibt die Karte an die angegebene Nummer zurück.
     *Das Element wird nicht gelöscht.
     * @param index Die Nummer der gewünschten Karte
     */
    Card getCard(int index);

    /**
     *Entfernen Sie die Karte unter der angegebenen Nummer.
     *Die Karte wird aus der Datenstruktur entfernt.
     * @param index Die Nummer der gewünschten Karte
     */
    Card takeCard(int index);
}

Außerdem möchte ich, dass die Datenstruktur ein Array oder eine Liste ist, also habe ich eine Schnittstelle erstellt, um dies so weit wie möglich zu tun.

Da es möglich ist, dass Funktionen wie Abrufen und Suchen gemeinsam genutzt werden können, bereiten Sie sie mit statischen Methoden vor. (Ich brauche es nicht, aber ich möchte den gleichen Prozess später nicht immer wieder schreiben.)

Da es sich um eine statische Methode handelt, habe ich eine Liste für das Argument erhalten und die Liste zurückgegeben, wenn sich etwas geändert hat.

Paare und Taples sind nicht im Java-Standard enthalten, daher habe ich sie durch Map.Entry ersetzt.

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public interface CardSheaf {

    //Abkürzung

    static int indexOf(List<Card> list, Card card){
        int i;
        for (i = 0; i < list.size(); i++) {
            Card c = list.get(i);
            if(c == null) continue;
            if(c.equals(card)) break;
        }
        if(i == list.size()) return -1;
        return i;
    }

    static List<Card> addCard(List<Card> list, Card card){
        list.add(card);
        return list;
    }

    static List<Card> removeCard(List<Card> list, Card card){
        list.remove(card);
        return list;
    }

    static List<Card> removeCard(List<Card> list, int index){
        list.remove(index);
        return list;
    }

    static Card find(List<Card> list, int number, Card.Mark mark){
        for (Card card: list){
            if(card == null) continue;
            if(card.getMark() == mark && card.getNumber() == number) return card;
        }
        return null;
    }

    static int indexOf(List<Card> list, int number, Card.Mark mark){
        int i;
        for (i = 0; i < list.size(); i++){
            Card card = list.get(i);
            if(card == null) continue;
            if(card.getMark() == mark && card.getNumber() == number) break;
        }
        if(i == list.size()) return -1;
        return i;
    }

    static Card getCard(List<Card> list, int index){
        return list.get(index);
    }

    static Map.Entry<List<Card>, Card> takeCard(List<Card> list, int index){
        Card card = list.get(index);
        list.remove(card);
        return new HashMap.SimpleEntry<List<Card>, Card>(list, card);
    }

Nächstes Mal