ComS 228 Project 1: ISP-Gewinnsimulation mit Java

Einführung in das ISP-Projekt: Gewinn durch Bandbreiten-Nichtnutzung

Stell dir vor, du arbeitest für Blaze, einen fiktiven Internetanbieter, der in einem Raster aus n x m Zellen Kunden versorgt. Deine Aufgabe: Berechne die jährliche Gewinnauslastung basierend auf dem Nutzerverhalten. Klingt nach einem klassischen Programmierprojekt? Genau das ist das ComS 228 Project 1 – Profit Utilization for Internet Service. In diesem Tutorial zeige ich dir, wie du die Simulation in Java umsetzt – ohne die Lösung komplett vorzugeben. Wir konzentrieren uns auf die Kernkonzepte: Zelluläre Automaten, Vererbung mit TownCell und die Implementierung der Update-Regeln.

Warum ist das relevant? In Zeiten von KI-gestützten Netzwerken und 5G-Ausbau müssen Provider verstehen, wie sie ihre Infrastruktur optimieren. Dein Code simuliert genau das – ein bisschen wie ein digitaler Zwilling eines ISP-Netzes. Und wer weiß, vielleicht inspirieren dich die Streamer und Reseller zu deinem eigenen Startup-Idee?

Die Grid-Struktur und Zelltypen

Das Spielfeld ist ein 2D-Array von TownCell-Objekten. Jede Zelle kann einen von fünf Zuständen annehmen:

C (Casual): Normale Nutzer, die Instagram und TikTok nutzen – sie bringen Gewinn, weil sie ihr Datenvolumen nicht ausschöpfen.
S (Streamer): Angehende E-Celebrities mit hohem Bandbreitenbedarf – kein Gewinn für Blaze.
R (Reseller): Verkaufen günstige Internetzugänge außerhalb des Rasters – ebenfalls kein Gewinn.
E (Empty): Leere Zelle – potenziell neuer Kunde.
O (Outage): Störung – Internet fällt aus.

Die Nachbarschaft eines Cells ist entweder 3x3 (innen) oder kleiner an den Rändern. Das beeinflusst die Update-Regeln – ein zentraler Punkt für die Simulation.

Vererbungshierarchie: TownCell und seine Unterklassen

Im Projekt ist TownCell eine abstrakte Oberklasse. Du musst fünf konkrete Unterklassen erstellen: Casual, Streamer, Reseller, Empty und Outage. Jede Unterklasse überschreibt Methoden wie who() (gibt den Zelltyp zurück) und implementiert die Update-Logik. Ein Beispiel: Die Casual-Klasse prüft, ob ein Reseller in der Nachbarschaft ist – falls ja, wird sie zu Outage. Sonst, wenn ein Streamer da ist, wird sie selbst zum Streamer.

Das ist ein klassisches Strategy Pattern in Aktion: Jeder Zelltyp hat sein eigenes Verhalten. In der Town-Klasse liegt das Grid als TownCell[][] grid. Die ISPBusiness-Klasse steuert die Simulation: Sie erstellt das Grid (entweder aus Datei oder zufällig) und führt 12 Update-Zyklen durch.

Update-Regeln verstehen und implementieren

Die Regeln sind das Herzstück. Sie laufen gleichzeitig ab: Der neue Zustand einer Zelle basiert auf dem alten Zustand ihrer Nachbarn. Deshalb brauchst du ein zweites Grid für die neuen Zustände. Hier eine Zusammenfassung der wichtigsten Regeln:

Casual (C): Wird zu O, wenn ein Reseller in der Nachbarschaft ist; sonst zu S, wenn ein Streamer da ist.
Streamer (S): Wird zu O bei Reseller; sonst zu E, wenn ein Outage in der Nähe ist.
Reseller (R): Wird zu E, wenn ≤ 3 Casuals oder ≥ 3 Empty-Zellen in der Nachbarschaft sind.
Outage (O): Wird immer zu E (Störung behoben).
Empty (E): Wird zu C (neuer Kunde).

Zusätzlich: Jede Nicht-Reseller-/Nicht-Outage-Zelle mit ≤ 1 (Empty + Outage) wird zum Reseller. Und wenn keine Regel greift, aber ≥ 5 Casuals in der Nachbarschaft sind, wird die Zelle zum Streamer. Sonst bleibt sie unverändert.

Ein Tipp: Schreibe eine Methode countNeighbors(TownCell.CASUAL), die die Anzahl der Casuals in der Nachbarschaft zählt. Das erleichtert die Implementierung ungemein.

Gewinnberechnung: Profit Utilization

Blaze verdient nur an Casual-Kunden: 1 $ pro Casual pro Monat. Die potentielle maximale Gewinn ist die Anzahl aller Zellen (n*m). Die tatsächliche Gewinnauslastung ist (Anzahl Casuals / (n*m)) * 100. Nach 12 Monaten gibst du nur diesen einen Prozentwert aus – nicht den gesamten Grid-Verlauf. Im Beispiel mit 12x10 Grid und 46 Casuals wäre das 46/120 * 100 = 38,33 → gerundet 38.

Achtung: Die Ausgabe soll nur eine ganze Zahl sein, z.B. 38. Keine Kommastellen, keine Grid-Ausgabe.

Implementierungsschritte in Java

1. Paketstruktur und Klassen

Lege das Paket edu.iastate.cs228.hw1 an. Erstelle die abstrakte Klasse TownCell mit:

public abstract class TownCell {
    public static final int CASUAL = 0;
    public static final int STREAMER = 1;
    public static final int RESELLER = 2;
    public static final int EMPTY = 3;
    public static final int OUTAGE = 4;
    protected Town town;
    protected int row;
    protected int col;
    public abstract State who();
    public abstract TownCell next(Town tNew);
}

Die fünf Unterklassen erben davon. Jede Unterklasse implementiert who() (gibt den entsprechenden State-Enum zurück) und next() (berechnet den neuen Zustand basierend auf den Regeln).

2. Die Town-Klasse

Town enthält das Grid und eine Methode, um die Nachbarschaft einer Zelle zu erhalten:

public class Town {
    private int length, width;
    public TownCell[][] grid;
    public Town(int length, int width) {
        this.length = length;
        this.width = width;
        grid = new TownCell[length][width];
    }
    public TownCell[] getNeighbors(int row, int col) {
        // gibt alle existierenden Nachbarn zurück (max 8)
    }
}

3. ISPBusiness – die Simulation

Hier läuft die Hauptlogik. Die main-Methode fragt den Benutzer nach der Grid-Generierung (Datei oder Zufall). Bei Zufall: Random gen = new Random(seed); und dann gen.nextInt(5) für jede Zelle. Dann startest du eine Schleife über 12 Monate:

for (int month = 0; month < 12; month++) {
    Town tNew = new Town(town.getLength(), town.getWidth());
    for (int i = 0; i < town.getLength(); i++) {
        for (int j = 0; j < town.getWidth(); j++) {
            tNew.grid[i][j] = town.grid[i][j].next(tNew);
        }
    }
    town = tNew;
}

Nach der Schleife zählst du die Casuals und berechnest den Prozentsatz. Gib nur diesen Wert aus.

Häufige Fehler und Tipps

Gleichzeitige Updates: Vergiss nicht, dass alle Zellen gleichzeitig aktualisiert werden. Verwende ein separates neues Grid für die neuen Zustände.
Randbehandlung: Zellen am Rand haben kleinere Nachbarschaften. Deine getNeighbors-Methode muss das berücksichtigen – z.B. nur existierende Zellen hinzufügen.
Zufallsgenerator mit Seed: Der Seed sorgt für reproduzierbare Ergebnisse. Verwende new Random(seed) genau einmal und rufe dann nextInt(5) für jede Zelle auf.
Dateieingabe: Die erste Zeile enthält Zeilen und Spalten, danach folgen die Zeilen mit den Buchstaben C, S, R, E, O. Achte auf Großbuchstaben und keine Leerzeichen zwischen den Buchstaben.

Trend-Beispiel: Wie KI und Gaming die Simulation inspirieren

Stell dir vor, Blaze wäre ein Metaverse-ISP und die Zellen wären Avatare in einer virtuellen Welt. Casual-Nutzer sind Gelegenheitsspieler, Streamer sind Content-Creator, Reseller sind Händler von virtuellen Gütern. Die Update-Regeln ähneln den Populationsdynamiken in Spielen wie Fortnite oder Roblox. Oder denk an KI-Trainingsdaten: Leere Zellen werden zu Casuals, genau wie neue Datenpunkte das Modell verbessern. Diese Analogien helfen dir, die Logik intuitiver zu verstehen.

Fazit

Das ComS 228 Project 1 ist eine hervorragende Übung in objektorientierter Programmierung, Simulation und Algorithmendesign. Indem du die Zelltypen als Unterklassen modellierst und die Update-Regeln sauber implementierst, lernst du, wie man komplexe Systeme in Java abbildet. Der Fokus liegt auf der Gewinnoptimierung – ein Thema, das in der Telekommunikationsbranche hochaktuell ist. Viel Erfolg bei deinem Projekt! Denk daran: Der Code muss nur den finalen Prozentwert ausgeben, aber die innere Logik ist das Herzstück.