Programming lesson
Java-Sammlungsklasse für Turnier-Spieler: Schritt-für-Schritt-Tutorial zur ICS 141 Aufgabe 5
Lerne, wie du eine eigene Sammlungsklasse in Java implementierst – angewendet auf ein Turnier-Spieler-Management. Dieses Tutorial führt dich durch die Erstellung einer Thing-Klasse und einer Collection-Klasse, inspiriert von E-Sport- und Gaming-Trends.
Java-Sammlungsklasse selbst erstellen: Ein praxisnahes Tutorial zur ICS 141 Aufgabe 5
In diesem Tutorial lernst du, wie du eine eigene Sammlungsklasse in Java implementierst. Wir nutzen ein aktuelles Beispiel aus der Welt des E-Sports und Turnier-Gamings: Eine SpielerCollection für ein fiktives Turnier. So wird der Stoff greifbar und du verstehst, wie du die Anforderungen der ICS 141 – 02 part 1 assignment 5 umsetzt.
Warum eine eigene Sammlungsklasse? – Analogie zum E-Sport-Team-Manager
Stell dir vor, du entwickelst eine App für ein E-Sport-Turnier wie die League of Legends Worlds 2026 oder ein Valorant Champions-Event. Du musst Spieler verwalten, ihre Punktzahlen summieren, den besten Spieler finden oder zählen, wie viele Spieler einer bestimmten Rolle (z.B. „Support“) angehören. Genau das machst du mit einer Sammlungsklasse – nur ohne vorgefertigte Klassen wie ArrayList. Du baust alles selbst mit einem einfachen Array, genau wie in der Aufgabenstellung gefordert.
Teil A: Die Thing-Klasse – hier: Spieler-Klasse
Deine Thing-Klasse repräsentiert ein Element deiner Sammlung. Wir nennen sie Spieler und geben ihr drei Instanzvariablen:
- int punkte – die Turnierpunktzahl (wird für Summe und Maximum genutzt)
- String rolle – die Rolle im Spiel (z.B. „Top“, „Jungle“, „Mid“, „Bot“, „Support“) – dient als Kategorie
- String name – der Spielername (drittes Attribut, String)
Alle Variablen sind private. Du implementierst Getter, Setter, toString (mit Tabs getrennt) und equals (Groß-/Kleinschreibung ignorieren).
public class Spieler {
private int punkte;
private String rolle;
private String name;
public Spieler(String name, String rolle, int punkte) {
this.name = name;
this.rolle = rolle;
this.punkte = punkte;
}
// Getter und Setter
public int getPunkte() { return punkte; }
public void setPunkte(int punkte) { this.punkte = punkte; }
public String getRolle() { return rolle; }
public void setRolle(String rolle) { this.rolle = rolle; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
@Override
public String toString() {
return name + "\t" + rolle + "\t" + punkte;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Spieler other = (Spieler) obj;
return punkte == other.punkte &&
rolle.equalsIgnoreCase(other.rolle) &&
name.equalsIgnoreCase(other.name);
}
}Teil B: Die Collection-Klasse – SpielerCollection
Jetzt baust du die Sammlungsklasse. Sie heißt SpielerCollection und verwendet ein Array vom Typ Spieler[]. Keine ArrayList! Drei Instanzvariablen: name (String), numItems (int), items (Spieler[]).
Konstruktor und add-Methoden
Der Konstruktor nimmt den Sammlungsnamen und die maximale Größe. Die erste add-Methode fügt ein existierendes Spieler-Objekt hinzu, die zweite erzeugt ein neues aus drei Parametern.
public class SpielerCollection {
private String name;
private int numItems;
private Spieler[] items;
public SpielerCollection(String name, int maxGroesse) {
this.name = name;
this.numItems = 0;
this.items = new Spieler[maxGroesse];
}
public void add(Spieler spieler) {
if (numItems < items.length) {
items[numItems] = spieler;
numItems++;
} else {
System.out.println("Sammlung ist voll!");
}
}
public void add(String name, String rolle, int punkte) {
add(new Spieler(name, rolle, punkte));
}Weitere Methoden: size, toString, total, greatest, countCategory, contains, countOccurances
Hier siehst du die Implementierung aller geforderten Methoden. Die toString-Methode gibt eine Tabelle aus – perfekt für die Konsolenausgabe.
public int size() {
return numItems;
}
@Override
public String toString() {
String output = name + "\n";
output += "Name\tRolle\tPunkte\n";
output += "------------------------\n";
for (int i = 0; i < numItems; i++) {
output += items[i].toString() + "\n";
}
return output;
}
public int total() {
int summe = 0;
for (int i = 0; i < numItems; i++) {
summe += items[i].getPunkte();
}
return summe;
}
public Spieler greatest() {
if (numItems == 0) return null;
Spieler maxSpieler = items[0];
for (int i = 1; i < numItems; i++) {
if (items[i].getPunkte() > maxSpieler.getPunkte()) {
maxSpieler = items[i];
}
}
return maxSpieler;
}
public int countCategory(String kategorie) {
int anzahl = 0;
for (int i = 0; i < numItems; i++) {
if (items[i].getRolle().equalsIgnoreCase(kategorie)) {
anzahl++;
}
}
return anzahl;
}
public boolean contains(Spieler spieler) {
for (int i = 0; i < numItems; i++) {
if (items[i].equals(spieler)) {
return true;
}
}
return false;
}
public int countOccurances(Spieler spieler) {
int anzahl = 0;
for (int i = 0; i < numItems; i++) {
if (items[i].equals(spieler)) {
anzahl++;
}
}
return anzahl;
}
}Teil C: Die Driver-Klasse – Teste deine Sammlung
Im Hauptprogramm erstellst du eine Sammlung für 10 Spieler, fügst 5 hinzu und rufst alle Methoden auf. Nutze feste Werte – kein Scanner nötig.
public class SpielerCollectionDriver {
public static void main(String[] args) {
SpielerCollection turnier = new SpielerCollection("Worlds 2026 Kader", 10);
turnier.add(new Spieler("Faker", "Mid", 1200));
turnier.add(new Spieler("Caps", "Mid", 1100));
turnier.add("Chovy", "Mid", 1150);
turnier.add("Deft", "Bot", 1050);
turnier.add("Keria", "Support", 950);
System.out.println("=== Sammlungsdetails ===");
System.out.println(turnier);
System.out.println("Anzahl Spieler: " + turnier.size());
System.out.println("Gesamtpunktzahl: " + turnier.total());
System.out.println("Bester Spieler: " + turnier.greatest());
System.out.println("Anzahl Mid-Spieler: " + turnier.countCategory("Mid"));
System.out.println("Enthält Faker? " + turnier.contains(new Spieler("Faker", "Mid", 1200)));
System.out.println("Anzahl von Faker: " + turnier.countOccurances(new Spieler("Faker", "Mid", 1200)));
}
}Warum dieses Beispiel perfekt für die Aufgabe ist
Die E-Sport-Szene boomt – 2026 ist ein großes Turnierjahr. Mit diesem Beispiel verbindest du Programmierlogik mit einem Thema, das viele Studenten begeistert. Du lernst Java-Arrays, Objektorientierung und Sammlungsklassen auf eine Weise, die über die reine Theorie hinausgeht.
Häufige Fehler vermeiden
- Array-Grenzen prüfen: Deine
add-Methode muss sicherstellen, dass das Array nicht überläuft. - equals-Methode korrekt überschreiben: Verwende
equalsIgnoreCasefür Strings. - toString tabellarisch formatieren: Nutze Tabs und Trennstriche für eine saubere Ausgabe.
- Methodensignaturen exakt einhalten: Die Aufgabenstellung gibt Namen und Parameter vor – halte dich daran.
Fazit
Mit diesem Tutorial hast du eine vollständige Java-Sammlungsklasse für ein Turnier-Spieler-Management erstellt. Du hast gesehen, wie man eine Thing-Klasse und eine Collection-Klasse nach den Vorgaben der ICS 141 Aufgabe implementiert. Das Beispiel aus dem E-Sport macht den Lernprozess spannend und relevant. Jetzt bist du bereit, deine eigene Sammlungsklasse für dein Projekt zu schreiben – egal ob für Spieler, Bücher oder Autos. Viel Erfolg!
Hinweis: Dieses Tutorial dient als Lernhilfe. Verwende es, um die Konzepte zu verstehen, und implementiere deine eigene Lösung gemäß den Aufgabenanforderungen.