Programm läßt sich nicht kompilieren

[transcripttom]

Irgendwie will mein Programm nicht starten. Ich arbeite mit Eclipse und da schiebt er probleme mit der import.io.java
Könnte vielleicht für mich jemand das Programm testen ob ich vielleicht doch irgendwo was nicht beachtet habe?

vielen Dank im voraus

import java.util.*;

public class Satz
{
    public String satz = new String();         // Ursprungsstring (= unkorrigierter Satz)
    public int wortzahl = 0;                    // Zähler für Wörter
    public int buchstzahl = 0;                  // Zähler für Buchstaben

//  KONSTRUKTOR
//  -----------
    public Satz(String _satz) {
        satz = _satz + " ";                 // Leerzeichen anfügen, um später Satzende zu detektieren falls Benutzer kein ., ! oder ? eingegeben hat
    }

//  KORREKTURMETHODE FÜR EINZELNES WORT
//  -----------------------------------
    private String wortkorrektur(String w) {
        w = w.charAt(0) + w.substring(1).toLowerCase();      // ersten Buchstaben im Wort nicht berücksichtigen, die restlichen klein schreiben
        return w;
    }

//  KORREKTURMETHODE FÜR SATZANFANG
//  -------------------------------
    private String korr_satzanfang(String s)
    {
        int i = 0;
        while (i < s.length() && !(Character.isLetterOrDigit(s.charAt(i)))) i++;              // i auf Position des ersten Buchstabens setzen
        if (i < s.length()) {
                s = s.substring(0,i) + Character.toUpperCase(s.charAt(i)) + s.substring(i+1);    // ersten Buchstaben im Satz groß schreiben (falls vorhanden!)
        }
        else s = "";                    // Sollten garkeine Buchstaben gefunden werden, handelt es sich nicht um einen Satz --> String löschen
        return s;
    }

//  KORREKTURMETHODE KOMPLEX 1
//  --------------------------
    public String korrektur_1() {
        String ksatz = new String();    // Ergebnisstring (= korrigierter Satz)

        int i = 0;                      // Zählvariable: Anfang des zuletzt detektierten Wortes

//      HAUPTSCHLEIFE: Eingabestring zeichenweise durchlaufen
        for (int j = 0; j < satz.length(); j++) {                   // ZIEL: Wörter finden, auszählen und einzeln korrigieren
            if (!(Character.isLetterOrDigit(satz.charAt(j)))) {     // aktuelles Zeichen ist kein Buchstabe oder eine Ziffer
                if (j > i) {                                        // Wort detektiert
                    wortzahl++;                                     // Wortzähler erhöhen
//                    buchstzahl = buchstzahl + satz.substring(i,j).length(); // Buchstabenzähler erhöhen
                    buchstzahl = buchstzahl + (j-i); // Buchstabenzähler erhöhen
                    ksatz = ksatz + wortkorrektur(satz.substring(i,j));     // Detektiertes Wort an Korrekturmethode übergeben und das Resultat
                                                                            // an den Ergebnisstring anfügen.
                }
                ksatz = ksatz + satz.charAt(j);
                i = j+1;
            }
        }

        ksatz = ksatz.trim();                   // Im Konstruktor eingefügtes sowie ggf. führende Leerzeichen entfernen
        if (!(ksatz.endsWith(".") || ksatz.endsWith("!") || ksatz.endsWith("?"))) ksatz = ksatz + ".";  // bei fehlendem Satzendezeichen Punkt anfügen

        ksatz = korr_satzanfang(ksatz);         // Abschließende Prüfung des Ergebnisstring (siehe Methode korr_satzanfang):

    // Rückgabe des Ergebnisstrings an Aufrufer:
        return ksatz;
    }


//  KORREKTURMETHODE KOMPLEX 2
//  --------------------------
    public String korrektur_2() {
        String ksatz = new String();    // Ergebnisstring (= korrigierter Satz)
        boolean lz = false;             // "true", falls letztes gelesenes Zeichen ein Leerzeichen war

//      HAUPTSCHLEIFE: Eingabestring zeichenweise durchlaufen
        for (int j = 0; j < satz.length(); j++) {
            // aktuelles Zeichen ist kein Buchstabe oder Klammerungszeichen:
            if (!(Character.isLetterOrDigit(satz.charAt(j)) || satz.charAt(j) == '\"' || satz.charAt(j) == '\'' || satz.charAt(j) == '(' || satz.charAt(j) == ')')) {
                if (satz.charAt(j) == ' ') {                        // akt. Zeichen ist ein Leerzeichen
                    if (lz == false) ksatz = ksatz + " ";    // füge gelesenes Leerzeichen an Ergebnisstring an ...
                                                                        // ... ABER NUR, wenn nicht schon unmittelbar davor eins gelesen wurde!
                    lz = true;                                      // auf jeden Fall wurde gerade ein Leerzeichen gelesen --> lz = true
                }
                else {                                              // akt. Zeichen ist kein Leerzeichen
                    // akt. Zeichen ist eines der vorgesehenen Sonderzeichen:
                    if (satz.charAt(j) == ',' || satz.charAt(j) == ';' || satz.charAt(j) == ':' || satz.charAt(j) == '.') {
                        if (lz == false) {                          // letztes Zeichen war kein Leerzeichen
                            ksatz = ksatz + satz.charAt(j) + " ";   // füge gelesenes Sonderzeichen + ein Leerzeichen an Ergebnisstring an
                        }
                        else {                                      // letztes Zeichen war ein Leerzeichen
                            // kürze den Ergebnisstring um das zuletzt gelesene Leerzeichen; füge dahinter das gelesene Sonderzeichen + ein Leerzeichen an:
                            ksatz = ksatz.substring(0, ksatz.length()-1) + satz.charAt(j) + " ";
                        }
                    lz = true;  // Da zusammen mit dem Sonderzeichen in jedem Fall ein "künstliches" Leerzeichen angefügt wurde, müssen wir dafür sorgen,
                                // dass ein ggf. folgendes Leerzeichen im Ursprungsstring nun ignoriert wird --> "tue so", als wäre das zuletzt gelesene Zeichen ein LZ.
                    }
                    // alle Sonderzeichen, die kein Interpunktions- oder Klammerungszeichen sind, fallen an dieser Stelle heraus (werden nicht an ksatz angefügt)
                }
            }
            else {  // aktuelles Zeichen ist ein Buchstabe oder Klammerungszeichen
                ksatz = ksatz + satz.charAt(j); // Zeichen, wie gewohnt, einfach anfügen.
                lz = false;
            }
        }

        ksatz = ksatz.trim();                   // Im Konstruktor eingefügtes Leerzeichen entfernen (nur relevant, falls zuvor nicht schon korrektur_1() aufgerufen wurde)

        return ksatz;
    }


//  KORREKTURMETHODE KOMPLEX 3
//  --------------------------
    public String korrektur_3() {
        String ksatz = new String();    // Ergebnisstring (= korrigierter Satz)
        String stack = new String();    // Stackstring: Führt Buch über das Auftreten öffnender Klammerungszeichen

/*      STACKOPERATIONEN:
 *      POP:    Entferne oberstes Stackelement (= letztes Zeichen im String "stack")
 *      PUSH:   Lege gerade gelesenes Zeichen auf den Stack (= füge es hinten an den String "stack" an)
 */

/*      HAUPTSCHLEIFE: Eingabestring zeichenweise durchlaufen
 *      PRINZIP: Enscheidung über einzufügendes Zeichen basiert auf Zuständen
 *               (jede mögliche Kombination aus gelesenem Eingabezeichen und obersten Stackzeichen steht für einen Zustand)
 *
 *               Große Fallunterscheidung: Welches Zeichen im Eingabestring wurde gerade gelesen?
 *                  Kleinere Fallunterscheidungen: Welches Zeichen steht dann jeweils als oberstes auf dem Stack (= wurde zuletzt davor gelesen)?
 */
        for (int j = 0; j < satz.length(); j++) {
            switch (satz.charAt(j)) {
                case '\'':                                                  // ' im Ursprungsstring gelesen
                    if (stack.length() > 0) {                               // Stack nicht leer
                        switch (stack.charAt(stack.length()-1)) {
                            case '\'':                                          // ' ist oberstes Stackelement
                                stack = stack.substring(0,stack.length()-1);        // POP
                                ksatz = ksatz + satz.charAt(j);                     // ' anfügen (korrekter Klammerschluss)
                            break;
                            case '\"':                                          // " ist oberstes Stackelement
                                stack = stack.substring(0,stack.length()-1);        // POP
                                ksatz = ksatz + '\"';                               // " anfügen statt ' (vermuteter Fehler: Zeichenirrtum)
                            break;
                            case '(':                                          // ( ist oberstes Stackelement
                                stack = stack.substring(0,stack.length()-1);        // POP
                                ksatz = ksatz + ')';                                // ( ) schließen (vermuteter Fehler: Zeichen vergessen)
                                j--;                                                // Zeichen im Ursprungsstring erneut bearbeiten
                            break;
                            case ')':                                          // ) wird nie auf den Stack gelegt --> kann nicht oberstes Element sein!
                                // --- UNMÖGLICHER ZUSTAND --- (wird im Folgenden nicht berücksichtigt)
                            break;
                            }
                        } else {                                            // Stack war leer
                            stack = stack + satz.charAt(j);                     // PUSH
                            ksatz = ksatz + satz.charAt(j);                     // vorbehaltlos das jeweilige Klammerungszeichen anfügen
                        }
                break;
                case '\"':                                                  // " im Ursprungsstring gelesen
                    if (stack.length() > 0) {                               // Stack nicht leer
                        switch (stack.charAt(stack.length()-1)) {
                            case '\'':                                          // ' ist oberstes Stackelement
                                stack = stack.substring(0,stack.length()-1);        // POP
                                ksatz = ksatz + '\'';                               // ' anfügen statt " (vermuteter Fehler: Zeichenirrtum)
                            break;
                            case '\"':
                                stack = stack.substring(0,stack.length()-1);        // POP
                                ksatz = ksatz + satz.charAt(j);                     // " anfügen (korrekter Klammerschluss)
                            break;
                            case '(':
                                stack = stack + '\"';                               // PUSH für die ("-Klammerung
                                ksatz = ksatz + satz.charAt(j);                     // " anfügen
                            break;
                            }
                        } else {                                            // Stack war leer
                            stack = stack + satz.charAt(j);                     // Vorgehen wie oben
                            ksatz = ksatz + satz.charAt(j);
                        }
                break;
                case '(':                                                   // ( im Ursprungsstring gelesen
                    if (stack.length() > 0) {                               // Stack nicht leer
                        switch (stack.charAt(stack.length()-1)) {
                            case '\'':                                          // ' ist oberstes Stackelement
                                stack = stack.substring(0,stack.length()-1);        // POP
                                ksatz = ksatz + '\'';                               // ' ' schließen (vermuteter Fehler: Zeichen vergessen)
                                j--;                                                // Zeichen im Ursprungsstring erneut bearbeiten
                            break;
                            case '\"':
                                stack = stack + '(';                               // PUSH für die "(-Klammerung
                                ksatz = ksatz + satz.charAt(j);                    // ( anfügen
                            break;
                            case '(':
                                stack = stack + '(';                               // PUSH für die verschachtelte (-Klammerung
                                ksatz = ksatz + satz.charAt(j);                    // ( anfügen
                            break;
                            }
                        } else {                                            // Stack war leer
                            stack = stack + satz.charAt(j);                     // Vorgehen wie oben
                            ksatz = ksatz + satz.charAt(j);
                        }
                break;
                case ')':                                                   // ) im Ursprungsstring gelesen
                    if (stack.length() > 0) {                               // Stack nicht leer
                        switch (stack.charAt(stack.length()-1)) {
                            case '\'':                                          // ' ist oberstes Stackelement
                                stack = stack.substring(0,stack.length()-1);        // POP
                                ksatz = ksatz + '\'';                               // ' anfügen statt ) (vermuteter Fehler: Zeichenirrtum)
                            break;
                            case '\"':
                                stack = stack.substring(0,stack.length()-1);        // POP
                                ksatz = ksatz + '\"';                               // " anfügen statt ) (vermuteter Fehler: Zeichenirrtum)
                            break;
                            case '(':
                                stack = stack.substring(0,stack.length()-1);        // POP
                                ksatz = ksatz + satz.charAt(j);                     // ) anfügen (korrekter Klammerschluss)
                            break;
                            }
                        }
                break;
                default: ksatz = ksatz + satz.charAt(j);
            }
        }

        ksatz = ksatz.trim();

        String ez = new String();                   // anfangs leere Variable, in die ggf. Satzendezeichen gespeichert wird
        if (ksatz.endsWith(".") || ksatz.endsWith("!") || ksatz.endsWith("?")) {
            ez = ez + ksatz.charAt(ksatz.length()-1);    // vorhandenes Satzendezeichen speichern
            ksatz = ksatz.substring(0,ksatz.length()-1);            // ksatz um Satzendezeichen verkürzen
        }

        while (stack.length() > 0) {                                // Solange der Stack nicht leer ist ...
            switch (stack.charAt(stack.length()-1)) {               // ... schaut man sich das jeweils oberste Stackelement an.
                case '\'':                                          // ' ist oberstes Stackelement
                    ksatz = ksatz + '\'';                               // ' anfügen
                break;
                case '\"':                                          // " ist oberstes Stackelement
                    ksatz = ksatz + '\"';                               // " anfügen
                break;
                case '(':                                           // ( ist oberstes Stackelement
                    ksatz = ksatz + ')';                                // ) anfügen
                break;
            }
            stack = stack.substring(0,stack.length()-1);            // POP (verkürzt Stack um die gerade geschlossene Klammer)
        }

        ksatz = ksatz + ez;     // ggf. Satzendezeichen wieder anfügen (sonst wird Leerstring angefügt)

        return ksatz;   // Fertig!
    }
} // END CLASS

import java.io.*;
// import java.awt.*;
// import java.awt.event.*;

public class Main{
    static BufferedReader b = null;     // Klassenattribut zur Pufferung jedes IOStreams

    public static String readln() throws java.io.IOException {      // eigene Methode zum Zeilenlesen
        if (b == null) b = new BufferedReader(new InputStreamReader(System.in));
        return b.readLine();
    }

    public static int readbyte() throws java.io.IOException {       // eigene Methode zum Zeichenlesen
        if (b == null) b = new BufferedReader(new InputStreamReader(System.in));
        return b.read();
    }

    public static String man_eingabe() throws java.io.IOException { // Methode zur manuellen Satzeingabe
        System.out.println("Bitte den zu untersuchenden Main eingeben:");
            String s = readln();
            s = readln();
            return s;
    }

    public static String datei_eingabe() throws java.io.IOException { // Methode zum Einlesen der ersten Zeile einer Textdatei
        System.out.println("Dateinamen angeben:");
        String fname = readln();
        fname = readln();
        BufferedReader f = new BufferedReader(new FileReader(fname));
        String s = f.readLine();
        return s;
    }

    public static void ausgabe(String s) throws java.io.IOException {   // Meth. zum Ausgeben der Analyseergebnisse
        Main testsatz = Main(s);                                    // Anlegen eines Main-Objektes namens "testsatz"

        System.out.println("-------------------------------------------------\n" + s + "\n");
        System.out.println("--> nach Korrekturkomplex 1:\n");
        testsatz.satz = testsatz.korrektur_1();                         // Aufruf der ersten Korrekturmethode
                                                                        // (Die Methode korrektur_1() der Klasse Main überschreibt das Attribut Main)

        System.out.println(testsatz.satz);                              // 'neues' Attribut Main von testsatz (korrigierter String) ausgeben
        System.out.println("(" + testsatz.wortzahl + " Woerter, " + testsatz.buchstzahl + " Buchstaben)");
        s = readln();                                                   // Warten auf beliebige Benutzereingabe zum Fortfahren

        System.out.println("-------------------------------------------------\n" + testsatz.satz + "\n");
        System.out.println("--> nach Korrekturkomplex 2:\n");
        testsatz.satz = testsatz.korrektur_2();                         // Aufruf der zweiten Korrekturmethode
        System.out.println(testsatz.satz);                              // 'neues' Attribut Main von testsatz (korrigierter String) ausgeben
        s = readln();

        System.out.println("-------------------------------------------------\n" + testsatz.satz + "\n");
        System.out.println("--> nach Korrekturkomplex 3:\n");
        testsatz.satz = testsatz.korrektur_3();                         // Aufruf der dritten Korrekturmethode
        System.out.println(testsatz.satz);                              // 'neues' Attribut Main von testsatz (korrigierter String) ausgeben
        s = readln();
    }

    public static void main(String args[]) throws java.io.IOException { // Diese Methode wird beim Programmstart aufgerufen
        int c = 0;

        System.out.println("Bitte die Eingabemethode waehlen:\n");      // Hauptmenü ausgeben
        System.out.println(" [1] Main ueber die Tastatur eingeben");    // ASCII-Code: 49
        System.out.println(" [2] Main aus Datei einlesen");             // ASCII-Code: 50
        System.out.println(" [3] Programm beenden\n");                  // ASCII-Code: 51
            while (c < 49 || c > 51) c = readbyte();                    // Eingabeaufforderung wiederholen, wann immer ein ungültiges Zeichen eingeg. wurde
        if (c == 49) ausgabe(man_eingabe());                            // Abfangen der Auswahl "1" (ASCII-Code 49) --> Eingabe manuelle
        if (c == 50) ausgabe(datei_eingabe());                          // Abfangen der Auswahl "2" (ASCII-Code 50) --> Eingabe aus Datei
    }
}

 

[eRaaaa]

[java=35]
Main testsatz = Main(s); // Anlegen eines Main-Objektes
[/code]

ähh, ein Objekt erstellt man immer mit

new

! also new Main(s); ..allerdings gibt es diesen Konstruktor ja gar nicht ??! Du scheinst ja auch nur statische Methoden definiert zu haben... (bzw, willst du da nicht eher ein Objekt von Satz erstellen? DIe Methoden die du da versuchst aufzurufen sind doch in der Satz-Klasse und der Konstruktor mit String würde auch Sinn ergeben ;D )

 

[SlaterB]

> und da schiebt er probleme mit der import.io.java
interessant, da 'import.io' in deinem ganzen Quellcode nicht auftaucht,

nimm den ganzen Code raus, speichere ihn irgendwo anders zwischendurch, fange mit einer einfachen Klasse

public class Satz
{
    public String satz = new String();         // Ursprungsstring (= unkorrigierter Satz)
    public int wortzahl = 0;                    // Zähler für Wörter
    public int buchstzahl = 0;                  // Zähler für Buchstaben

}

an, geht die zu kompilieren?
wenn nein, dann ist das Problem zu 90% Code-kürzer geworden,
ansonsten nach und nach einzeln Konstruktoren und Methoden hinzufügen,
wenn es mit irgendeiner Methode nicht mehr geht, dann versuche das zu klären, ansonsten zumindest alle anderen Methoden wieder löschen,
auch in der neuen Methode vielleicht ein paar der Code-Zeilen gar nicht nötig für das Problem?
so dass ein möglichst kurzes Programm entsteht,
und die genaue Fehlermeldung posten

 

[gman]

Hi,

müsste es in der Main.java nicht:

[JAVA=35]
Satz testsatz = new Satz(s);
[/code]

heissen?

[JAVA=21]"Bitte den zu untersuchenden Main eingeben:"[/code]

zeigt doch schon eigentlich deutlich das du hier die falsche Klasse am Start hast

 

[transcripttom]

Antwort 4 ist die Lösung, boah neee oder. Kein Wunder und ich fummel mir hier gerade ein ab. Tja, Dummheit muß bestraft werden.

Kommt Zeit kommt rat.

Danke Dir nochmal. boah nee, ich könnt mich gerade selber schlagen