1. Fehler bei der Klassendeklaration
Fehlende Zugriffsmodifikatoren (package-private standardmäßig)
In Java gilt: Wenn Sie keinen Zugriffsmodifikator an einer Klasse explizit angeben, ist sie nur innerhalb des aktuellen Pakets sichtbar. Das nennt man package-private oder „Standardzugriff“. Zum Beispiel:
// Datei Book.java
class Book {
String title;
}
Eine solche Klasse kann nicht aus einem anderen Paket verwendet werden. Wenn die Klasse überall zugänglich sein soll (und das ist für zentrale Modelle oft sinnvoll), verwenden Sie den Modifikator public:
public class Book {
String title;
}
Warum ist das wichtig?
Wenn Sie public vergessen, fragen Sie sich später lange, warum irgendeine Library aus einem anderen Paket Ihre Klasse nicht sieht.
Nichtübereinstimmung von Klassenname und Dateiname
In Java muss der Dateiname mit dem Namen der public‑Klasse in dieser Datei übereinstimmen (Groß-/Kleinschreibung beachten!). Zum Beispiel:
// Datei Book.java
public class Book {
// ...
}
Wenn Sie die Datei book.java (mit kleinem Anfangsbuchstaben) oder, noch schlimmer, BooK.java nennen, meldet der Compiler einen Fehler. Das ist einer der Gründe, warum die IDE „meckert“, wenn Sie eine Klasse umbenennen, aber die Datei nicht entsprechend anpassen.
Fehler in der Deklarationssyntax: vergessene geschweifte Klammern, falsche Platzierung von Methoden und Feldern
Java ist eine strenge Sprache. Wenn Sie irgendwo eine geschweifte Klammer vergessen oder versehentlich eine Methode innerhalb einer anderen Methode deklarieren (das ist nicht erlaubt!), weist der Compiler Sie sofort zurecht.
Beispiel einer fehlerhaften Deklaration:
public class User
String name; // Ups! Die geschweiften Klammern der Klasse fehlen
public void printName() {
System.out.println(name);
}
}
Korrekte Variante:
public class User {
String name;
public void printName() {
System.out.println(name);
}
}
Merken Sie sich:
- Alle Felder und Methoden werden nur innerhalb der geschweiften Klammern der Klasse deklariert.
- Methoden dürfen nicht ineinander verschachtelt sein (in manchen Sprachen ist das erlaubt, in Java nicht!).
2. Fehler bei der Objekterzeugung
Versuch, ein Objekt vor seiner Initialisierung zu verwenden (NullPointerException)
Der häufigste Fehler überhaupt – der Zugriff auf ein Objekt, das noch nicht erstellt wurde. In Java sind Referenzvariablen standardmäßig null.
Beispiel:
User user;
System.out.println(user.name); // NullPointerException!
Warum?
Die Variable user ist deklariert, aber nicht initialisiert. Beim Zugriff auf ein Feld oder eine Methode erhalten Sie eine NPE (NullPointerException).
Richtiger Ansatz:
User user = new User();
System.out.println(user.name); // Jetzt ist alles okay (falls das Feld nicht null ist)
Fehler beim Aufruf des Konstruktors (Parameter stimmen nicht überein, kein Standardkonstruktor vorhanden)
Hat eine Klasse nur einen Konstruktor mit Parametern, führt der Versuch, ein Objekt ohne Parameter zu erstellen, zu einem Kompilierfehler.
public class Book {
String title;
public Book(String title) {
this.title = title;
}
}
Book book = new Book(); // Fehler! Es gibt keinen parameterlosen Konstruktor
Lösung: Entweder einen parameterlosen Konstruktor hinzufügen oder stets die erforderlichen Werte übergeben:
Book book = new Book("Java für Dummies");
Mehrfache Objekterstellung statt Wiederverwendung
Manche Einsteiger erstellen jedes Mal ein neues Objekt, wenn sie es brauchen, anstatt ein bereits erstelltes zu verwenden.
Book book = new Book("Java für Dummies");
System.out.println(book.title);
book = new Book("Java für Dummies"); // Wozu? Ein solches Objekt gab es schon!
System.out.println(book.title);
Das ist kein Kompilierfehler, aber ein Zeichen für schlechten Stil – Sie verlieren die Referenz auf das alte Objekt und verschwenden zusätzlichen Speicher.
3. Best Practices: wie man Stolperfallen vermeidet
Geben Sie Zugriffsmodifikatoren immer ausdrücklich an
Scheuen Sie sich nicht, public, private oder protected zu schreiben – das dient nicht nur der Sicherheit, sondern auch der Lesbarkeit des Codes. Die IDE hilft zwar, aber es ist besser, sich die Gewohnheit gleich anzueignen.
Beispiel:
public class User {
private String name;
// ...
}
Achten Sie auf die Benennung von Klassen
- Klassenname – mit großem Anfangsbuchstaben, Stil CamelCase: Book, LibraryUser, BookManager.
- Dateiname – exakt wie der Klassenname.
Verwenden Sie Konstruktoren zur Initialisierung obligatorischer Felder
Wenn ein Objekt Felder hat, die zwingend bei der Erstellung gesetzt werden müssen, fügen Sie einen Konstruktor mit Parametern hinzu. Das schützt vor Fehlern bei der Verwendung.
Beispiel:
public class User {
private String name;
public User(String name) {
this.name = name;
}
}
Jetzt kann kein User ohne Namen erstellt werden – der Compiler lässt das nicht zu.
4. Wissen anwenden: Wir bauen eine Mini‑Anwendung „Bibliothek“
Lassen Sie uns unsere Übungsanwendung weiterentwickeln. Nehmen wir eine Klasse Book und eine Klasse Library, die Bücher verwaltet.
Beispiel einer korrekten Klassendeklaration
// Datei Book.java
public class Book {
private String title;
private String author;
// Konstruktor mit Parametern
public Book(String title, String author) {
this.title = title;
this.author = author;
}
// Getter
public String getTitle() {
return title;
}
public String getAuthor() {
return author;
}
}
Beispiel einer korrekten Objekterzeugung
Book book = new Book("Java für Dummies", "John Doe");
System.out.println(book.getTitle() + " - " + book.getAuthor());
Beispiel einer Manager‑Klasse
// Datei Library.java
import java.util.ArrayList;
public class Library {
private ArrayList<Book> books = new ArrayList<>();
public void addBook(Book book) {
books.add(book);
}
public void printAllBooks() {
for (Book book : books) {
System.out.println(book.getTitle() + " - " + book.getAuthor());
}
}
}
Verwendung in main
public class Main {
public static void main(String[] args) {
Library library = new Library();
Book book1 = new Book("Java für Dummies", "John Doe");
Book book2 = new Book("OOP leicht erklärt", "Ivan Ivanov");
library.addBook(book1);
library.addBook(book2);
library.printAllBooks();
}
}
5. Abbildungen und Schemata
Schema: Wo deklariert man was?
+-----------------------------+
| Book.java |
|-----------------------------|
| public class Book { |
| private String title; | <--- Felder (nur innerhalb der Klasse)
| ... |
| public Book(...) {...} | <--- Konstruktor (innerhalb der Klasse)
| public String getTitle()| <--- Methoden (innerhalb der Klasse)
| } |
+-----------------------------+
+-----------------------------+
| Main.java |
|-----------------------------|
| public class Main { |
| public static void main |
| // Objekterzeugung |
| Book book = new Book|
| } |
+-----------------------------+
6. Analyse typischer Fehler
Fehler 1: Klassenname und Dateiname stimmen nicht überein
// Datei: Libraryuser.java
public class LibraryUser { // Klassenname mit großem U, Datei mit kleinem!
// ...
}
class LibraryUser is public, should be declared in a file named LibraryUser.java
Fehler 2: Versuch, ein nicht initialisiertes Objekt zu verwenden
Book book;
System.out.println(book.getTitle()); // NullPointerException!
Fehler 3: Geschweifte Klammern vergessen
public class Book
private String title; // Felder werden für die Kapselung üblicherweise private gemacht
// ...
}
';' expected
Fehler 4: Methodendeklaration innerhalb einer Methode
public class User {
public void printName() {
void sayHello() {
System.out.println("Hello!"); // Eine Methode darf nicht innerhalb einer Methode deklariert werden!
}
}
}
illegal start of type
GO TO FULL VERSION