Errori nella dichiarazione di classi e oggetti

1. Errori nella dichiarazione della classe

Assenza dei modificatori di accesso (package-private per impostazione predefinita)

In Java, se non specifichi esplicitamente un modificatore di accesso per una classe, essa diventa accessibile solo all’interno del pacchetto corrente. Questo si chiama package-private o “accesso predefinito”. Per esempio:

// File Book.java
class Book {
    String title;
}

Una classe del genere non può essere usata da un altro pacchetto. Se vuoi che la classe sia accessibile ovunque (e spesso è proprio ciò che serve per i modelli principali), usa il modificatore public:

public class Book {
    String title;
}

Perché è importante?
Se ti dimentichi di mettere public, potresti chiederti a lungo perché una certa Library di un altro pacchetto non vede la tua classe.

Incoerenza tra nome della classe e nome del file

In Java il nome del file che contiene una classe deve coincidere con il nome della classe public all’interno di quel file (attenzione alle maiuscole/minuscole!). Per esempio:

// File Book.java
public class Book {
    // ...
}

Se chiami il file book.java (con l’iniziale minuscola) o, peggio ancora, BooK.java, il compilatore restituirà un errore. È uno dei motivi per cui l’IDE “si arrabbia” quando rinomini una classe ma ti dimentichi di rinominare il file.

Errori nella sintassi della dichiarazione: parentesi graffe mancanti, posizionamento errato di metodi e campi

Java è un linguaggio rigoroso. Se dimentichi una parentesi graffa o dichiari accidentalmente un metodo dentro un altro metodo (non si può!), il compilatore te lo segnalerà immediatamente.

Esempio di dichiarazione errata:

public class User
    String name; // Ops! Mancano le parentesi graffe della classe

    public void printName() {
        System.out.println(name);
    }
}

Versione corretta:

public class User {
    String name;

    public void printName() {
        System.out.println(name);
    }
}

Ricordate:

• Tutti i campi e i metodi si dichiarano solo all’interno delle parentesi graffe della classe.
• I metodi non possono essere annidati l’uno dentro l’altro (in alcuni linguaggi è consentito, ma non in Java!).

2. Errori nella creazione degli oggetti

Tentativo di usare un oggetto prima della sua inizializzazione (NullPointerException)

L’errore più comune di sempre è provare ad accedere a un oggetto che non è ancora stato creato. In Java le variabili di tipo riferimento sono per impostazione predefinita uguali a null.

Esempio:

User user;
System.out.println(user.name); // NullPointerException!

Perché?
La variabile user è dichiarata ma non inizializzata. Se provi ad accedere a un campo o a un metodo, otterrai una NPE (NullPointerException).

Approccio corretto:

User user = new User();
System.out.println(user.name); // Ora va tutto bene (se il campo non è null)

Errori nella chiamata del costruttore (parametri non corrispondenti, assenza del costruttore predefinito)

Se una classe ha solo un costruttore con parametri, tentare di creare un oggetto senza parametri porterà a un errore di compilazione.

public class Book {
    String title;

    public Book(String title) {
        this.title = title;
    }
}

Book book = new Book(); // Errore! Non esiste un costruttore senza parametri

Soluzione: aggiungi un costruttore senza parametri oppure passa sempre i valori necessari:

Book book = new Book("Java per principianti");

Creazione multipla di oggetti invece di riutilizzarli

A volte i principianti creano un nuovo oggetto ogni volta che devono accedervi, invece di usare quello già creato.

Book book = new Book("Java per principianti");
System.out.println(book.title);

book = new Book("Java per principianti"); // Perché? Esisteva già un oggetto uguale!
System.out.println(book.title);

Non è un errore di compilazione, ma è un cattivo stile: perdi il riferimento al vecchio oggetto e sprechi memoria.

3. Best practice: come evitare le trappole

Indicate sempre esplicitamente i modificatori di accesso

Non abbiate paura di scrivere public, private o protected — non è solo una questione di sicurezza, ma anche di leggibilità del codice. L’IDE ovviamente ti aiuterà, ma è meglio creare subito la buona abitudine.

Esempio:

public class User {
    private String name;
    // ...
}

Fate attenzione alla denominazione delle classi

• Il nome della classe — con iniziale maiuscola, stile CamelCase: Book, LibraryUser, BookManager.
• Il nome del file — esattamente come il nome della classe.

Usate i costruttori per inizializzare i campi obbligatori

Se un oggetto ha campi che devono essere valorizzati alla creazione, aggiungi un costruttore con parametri. Questo ti protegge da errori in fase d’uso.

Esempio:

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }
}

Ora non si può creare User senza nome — il compilatore non lo permetterà.

4. Mettiamo in pratica: costruiamo una mini‑applicazione «Biblioteca»

Continuiamo a sviluppare la nostra applicazione didattica. Supponiamo di avere una classe Book e una classe Library, che gestisce i libri.

Esempio di dichiarazione corretta di una classe

// File Book.java
public class Book {
    private String title;
    private String author;

    // Costruttore con parametri
    public Book(String title, String author) {
        this.title = title;
        this.author = author;
    }

    // Getter
    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }
}

Esempio di creazione corretta di un oggetto

Book book = new Book("Java per principianti", "John Doe");
System.out.println(book.getTitle() + " - " + book.getAuthor());

Esempio di classe manager

// File 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());
        }
    }
}

Utilizzo in main

public class Main {
    public static void main(String[] args) {
        Library library = new Library();
        Book book1 = new Book("Java per principianti", "John Doe");
        Book book2 = new Book("OOP in parole semplici", "Ivan Ivanov");

        library.addBook(book1);
        library.addBook(book2);

        library.printAllBooks();
    }
}

5. Illustrazioni e schemi

Schema: dove dichiarare cosa?

+-----------------------------+
|         Book.java           |
|-----------------------------|
| public class Book {         |
|     private String title;   |  <--- campi (solo all'interno della classe)
|     ...                     |
|     public Book(...) {...}  |  <--- costruttore (dentro la classe)
|     public String getTitle()|  <--- metodi (dentro la classe)
| }                           |
+-----------------------------+

+-----------------------------+
|        Main.java            |
|-----------------------------|
| public class Main {         |
|     public static void main |
|         // Creazione degli oggetti|
|         Book book = new Book|
| }                           |
+-----------------------------+

6. Analisi degli errori tipici

Errore 1: Incoerenza tra nome della classe e del file

// File: Libraryuser.java
public class LibraryUser { // Nome della classe con U maiuscola, file con minuscola!
    // ...
}

class LibraryUser is public, should be declared in a file named LibraryUser.java

Errore 2: Tentativo di utilizzare un oggetto non inizializzato

Book book;
System.out.println(book.getTitle()); // NullPointerException!

Errore 3: Dimenticate le parentesi graffe

public class Book
    private String title; // I campi di solito si rendono private per l'incapsulamento
    // ...
}

';' expected

Errore 4: Dichiarazione di un metodo dentro un altro metodo

public class User {
    public void printName() {
        void sayHello() {
            System.out.println("Hello!"); // Non si può dichiarare un metodo dentro un altro metodo!
        }
    }
}

illegal start of type