Java Interfaces: CharSequence implementieren mit ASCII-Codes

Java Interfaces verstehen – am Beispiel CharSequence

In der objektorientierten Programmierung mit Java sind Interfaces ein zentrales Konzept. Sie definieren einen Vertrag: Jede Klasse, die ein Interface implementiert, muss bestimmte Methoden bereitstellen. Ein bekanntes Beispiel ist das Interface CharSequence, das unter anderem von der Klasse String implementiert wird. In diesem Tutorial zeigen wir Dir, wie Du CharSequence selbst implementierst – eine typische Aufgabe aus dem COP3330 Homework 4. Du wirst sehen, wie Du mit ASCII-Codes arbeitest und eigene charAt, length und subSequence Methoden schreibst.

Was ist das CharSequence Interface?

Das Interface CharSequence aus dem Paket java.lang definiert drei abstrakte Methoden:

char charAt(int index) – gibt das Zeichen an einer bestimmten Position zurück
int length() – liefert die Anzahl der Zeichen
CharSequence subSequence(int start, int end) – gibt eine Teilsequenz zurück

Jede Klasse, die dieses Interface implementiert, muss diese Methoden überschreiben. Das ist vergleichbar mit einem Vertrag: Wenn Du zusagst, ein bestimmtes Feature zu liefern (wie bei einer App-Entwicklung), musst Du es auch umsetzen. Stell Dir vor, Du entwickelst eine Musik-Streaming-App – das Interface könnte Playable heißen und Methoden wie play(), pause() und stop() vorgeben. Genauso zwingt Dich CharSequence, die drei genannten Methoden zu implementieren.

Unsere Aufgabe: Code-Klasse mit CharSequence

Wir haben eine Klasse Code, die ein zweidimensionales int[][] array namens codeArray enthält. Dieses Array speichert ASCII-Codes (Zahlen zwischen 0 und 127). Ziel ist es, die drei Methoden von CharSequence so zu überschreiben, dass sie auf diesem Array arbeiten. Dabei wird das Array zeilenweise in einen eindimensionalen Index abgebildet. Wenn Du also charAt(6) aufrufst, suchst Du das 7. Element (Index 6) in der zeilenweisen Anordnung des zweidimensionalen Arrays.

Beispiel aus dem echten Leben

Stell Dir vor, Du hast eine Tabelle mit Highscores in einem Spiel (wie bei einem Battle-Royale-Turnier). Jede Zelle enthält einen Zahlenwert, der für einen Buchstaben im Spieler-Namen steht. Deine Aufgabe ist es, aus diesen Zahlen den Namen zu rekonstruieren. Genau das machst Du hier mit charAt und subSequence.

Schritt 1: Die Methode charAt implementieren

Die Methode charAt(int index) soll das Zeichen zurückgeben, dessen ASCII-Code an der Position index im Array steht. Da das Array zweidimensional ist, musst Du den Index in Zeilen- und Spaltenindizes umrechnen. Angenommen, das Array hat numRows Zeilen und numColumns Spalten. Dann gilt:

Zeilenindex = index / numColumns
Spaltenindex = index % numColumns

Beispiel: Bei einem 3x4-Array (12 Elemente) und Index 6 ergibt sich Zeile 1 (6/4=1) und Spalte 2 (6%4=2). Das Element ist 71, und (char)71 ist 'G'. So implementierst Du es:

@Override
public char charAt(int index) {
    int row = index / numColumns;
    int col = index % numColumns;
    return (char) codeArray[row][col];
}

Schritt 2: Die Methode length() implementieren

Die Methode length() soll die Anzahl der Zeichen im Array zurückgeben, also die Gesamtzahl der Elemente. Das ist einfach numRows * numColumns. Beispiel: Bei 3 Zeilen und 4 Spalten ist die Länge 12.

@Override
public int length() {
    return numRows * numColumns;
}

Schritt 3: Die Methode subSequence implementieren

Die Methode subSequence(int start, int end) gibt einen String zurück, der aus den Zeichen von Index start bis end (exklusive end) besteht. Du rufst für jeden Index charAt auf und hängst die Zeichen an einen StringBuilder an.

@Override
public String subSequence(int start, int end) {
    StringBuilder sb = new StringBuilder();
    for (int i = start; i < end; i++) {
        sb.append(charAt(i));
    }
    return sb.toString();
}

Vollständige Code-Klasse und Test

Hier siehst Du die komplette Code-Klasse mit den drei überschriebenen Methoden:

class Code implements CharSequence {
    private int[][] codeArray;
    private int numRows, numColumns;

    public Code(int numRows, int numColumns) {
        this.numRows = numRows;
        this.numColumns = numColumns;
        codeArray = new int[numRows][numColumns];
    }

    public void loadCodeArray(int numRows, int numColumns) {
        Scanner myScan = new Scanner(System.in);
        for (int i = 0; i < numRows; i++) {
            System.out.print("Enter Row " + (i + 1) + ": ");
            for (int j = 0; j < numColumns; j++) {
                codeArray[i][j] = myScan.nextInt();
            }
        }
    }

    public void printCodeArray(int numRows, int numColumns) {
        System.out.println(" _____________ ");
        for (int i = 0; i < numRows; i++) {
            for (int j = 0; j < numColumns; j++) {
                System.out.print(codeArray[i][j] + "\t");
            }
            System.out.println();
        }
    }

    @Override
    public char charAt(int index) {
        int row = index / numColumns;
        int col = index % numColumns;
        return (char) codeArray[row][col];
    }

    @Override
    public int length() {
        return numRows * numColumns;
    }

    @Override
    public String subSequence(int start, int end) {
        StringBuilder sb = new StringBuilder();
        for (int i = start; i < end; i++) {
            sb.append(charAt(i));
        }
        return sb.toString();
    }
}

Mit dieser Implementierung kannst Du die DriverClass aus der Aufgabenstellung verwenden, um das Programm zu testen. Du wirst sehen, wie aus Zahlen Buchstaben werden – ein bisschen wie das Entschlüsseln eines Codes in einer Escape-Room-Challenge.

Warum ist das wichtig? Trend-Verbindung

Das Konzept von Interfaces ist nicht nur in der Uni-Aufgabe wichtig. In der echten Softwareentwicklung, etwa bei der Erstellung von APIs für KI-Assistenten wie ChatGPT oder bei der Entwicklung von Apps, definieren Interfaces die Schnittstellen zwischen Komponenten. Stell Dir vor, Du baust eine App, die verschiedene Datenquellen unterstützt (z.B. lokale Dateien, Cloud-Speicher). Du definierst ein Interface DataSource mit Methoden wie read() und write(). Jede konkrete Datenquelle implementiert dieses Interface – genau wie Deine Code-Klasse CharSequence implementiert.

Häufige Fehler vermeiden

IndexOutOfBoundsException: Achte darauf, dass der Index zwischen 0 und length()-1 liegt. In der Aufgabenstellung wird garantiert, dass der Benutzer gültige Eingaben macht, aber in der Praxis solltest Du Prüfungen einbauen.
Falsche Reihenfolge bei subSequence: Der Parameter end ist exklusiv, d.h. das Zeichen bei Index end wird nicht mehr mitgenommen. In der Schleife verwendest Du i < end, nicht i <= end.
Vergessen, den Cast zu char durchzuführen: Ohne (char) erhältst Du einen int-Wert, der nicht zu char kompatibel ist.

Fazit

Du hast gelernt, wie Du das Java-Interface CharSequence implementierst und dabei ASCII-Codes in lesbare Zeichen umwandelst. Diese Fähigkeit ist grundlegend für das Verständnis von Interfaces und Abstraktion in Java – ein Schlüsselkonzept für Dein COP3330 Homework 4. Probiere es selbst aus und experimentiere mit verschiedenen Arrays. Viel Erfolg beim Programmieren!