1. Errores al declarar una clase
Falta de modificadores de acceso (package-private por defecto)
En Java, si no indicas explícitamente el modificador de acceso de una clase, esta queda accesible solo dentro del paquete actual. Esto se llama package-private o «acceso por defecto». Por ejemplo:
// Archivo Book.java
class Book {
String title;
}
Esa clase no se puede usar desde otro paquete. Si quieres que la clase sea accesible en todas partes (y a menudo así debe ser para los modelos principales), usa el modificador public:
public class Book {
String title;
}
¿Por qué es importante?
Si te olvidas de poner public, luego te preguntarás durante un buen rato por qué alguna Library de otro paquete no ve tu clase.
No coincidencia entre el nombre de la clase y el del archivo
En Java el nombre del archivo con la clase debe coincidir con el nombre de la clase public dentro de ese archivo (¡respetando mayúsculas y minúsculas!). Por ejemplo:
// Archivo Book.java
public class Book {
// ...
}
Si llamas al archivo book.java (con inicial minúscula) o, peor aún, BooK.java, el compilador mostrará un error. Esta es una de las razones por las que la IDE se queja cuando renombras la clase pero olvidas renombrar el archivo.
Errores en la sintaxis de la declaración: llaves olvidadas, colocación incorrecta de métodos y campos
Java es un lenguaje estricto. Si olvidas alguna llave o declaras un método dentro de otro método (¡eso no está permitido!), el compilador te llamará la atención de inmediato.
Ejemplo de declaración incorrecta:
public class User
String name; // ¡Ups! Faltan las llaves de la clase
public void printName() {
System.out.println(name);
}
}
Versión correcta:
public class User {
String name;
public void printName() {
System.out.println(name);
}
}
Recuerda:
- Todos los campos y métodos se declaran únicamente dentro de las llaves de la clase.
- Los métodos no pueden anidarse unos dentro de otros (en algunos lenguajes se permiten métodos anidados, pero no en Java).
2. Errores al crear objetos
Intentar usar un objeto antes de inicializarlo (NullPointerException)
El error más común de todos los tiempos es intentar acceder a un objeto que aún no se ha creado. En Java, las variables de tipo de referencia valen null por defecto.
Ejemplo:
User user;
System.out.println(user.name); // NullPointerException!
¿Por qué?
La variable user está declarada, pero no inicializada. Al intentar acceder a un campo o método, obtendrás un NPE (NullPointerException).
Enfoque correcto:
User user = new User();
System.out.println(user.name); // Ahora todo está bien (si el campo no es null)
Errores al invocar el constructor (parámetros no coincidentes, ausencia de constructor por defecto)
Si una clase solo tiene constructor con parámetros, intentar crear un objeto sin parámetros dará un error de compilación.
public class Book {
String title;
public Book(String title) {
this.title = title;
}
}
Book book = new Book(); // ¡Error! No existe un constructor sin parámetros
Solución: o bien añadir un constructor sin parámetros, o bien pasar siempre los valores necesarios:
Book book = new Book("Java para principiantes");
Crear múltiples objetos en lugar de reutilizarlos
A veces, los principiantes crean un objeto nuevo cada vez que necesitan acceder a él en lugar de usar el que ya está creado.
Book book = new Book("Java para principiantes");
System.out.println(book.title);
book = new Book("Java para principiantes"); // ¿Para qué? ¡Ya había un objeto igual!
System.out.println(book.title);
No es un error de compilación, pero es una mala práctica: pierdes la referencia al objeto anterior y gastas memoria innecesariamente.
3. Mejores prácticas: cómo evitar errores comunes
Indica siempre los modificadores de acceso de forma explícita
No te olvides de escribir public, private o protected: no solo es por seguridad, también por la legibilidad del código. La IDE te lo puede sugerir, pero es mejor adquirir el hábito desde el principio.
Ejemplo:
public class User {
private String name;
// ...
}
Cuida la nomenclatura de las clases
- El nombre de la clase va en mayúscula inicial, estilo CamelCase: Book, LibraryUser, BookManager.
- El nombre del archivo debe ser exactamente el mismo que el de la clase.
Usa constructores para inicializar los campos obligatorios
Si un objeto tiene campos que deben estar rellenos al crearlo, añade un constructor con parámetros. Eso te protegerá de errores en el uso.
Ejemplo:
public class User {
private String name;
public User(String name) {
this.name = name;
}
}
Ahora no se puede crear User sin nombre: el compilador no lo permitirá.
4. Poniendo en práctica: construimos una miniaplicación «Biblioteca»
Sigamos desarrollando nuestra aplicación de aprendizaje. Supongamos que tenemos una clase Book y una clase Library, que gestiona los libros.
Ejemplo de declaración correcta de una clase
// Archivo Book.java
public class Book {
private String title;
private String author;
// Constructor con parámetros
public Book(String title, String author) {
this.title = title;
this.author = author;
}
// Getters
public String getTitle() {
return title;
}
public String getAuthor() {
return author;
}
}
Ejemplo de creación correcta de un objeto
Book book = new Book("Java para principiantes", "John Doe");
System.out.println(book.getTitle() + " - " + book.getAuthor());
Ejemplo de clase gestora
// Archivo 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());
}
}
}
Uso en main
public class Main {
public static void main(String[] args) {
Library library = new Library();
Book book1 = new Book("Java para principiantes", "John Doe");
Book book2 = new Book("POO en pocas palabras", "Ivan Ivanov");
library.addBook(book1);
library.addBook(book2);
library.printAllBooks();
}
}
5. Ilustraciones y esquemas
Esquema: ¿dónde declarar qué?
+-----------------------------+
| Book.java |
|-----------------------------|
| public class Book { |
| private String title; | <--- campos (solo dentro de la clase)
| ... |
| public Book(...) {...} | <--- constructor (dentro de la clase)
| public String getTitle()| <--- métodos (dentro de la clase)
| } |
+-----------------------------+
+-----------------------------+
| Main.java |
|-----------------------------|
| public class Main { |
| public static void main |
| // Creación de objetos|
| Book book = new Book|
| } |
+-----------------------------+
6. Análisis de errores típicos
Error 1: No coincidencia entre el nombre de la clase y el del archivo
// Archivo: Libraryuser.java
public class LibraryUser { // ¡Nombre de clase con U mayúscula, archivo con minúscula!
// ...
}
class LibraryUser is public, should be declared in a file named LibraryUser.java
Error 2: Intento de usar un objeto no inicializado
Book book;
System.out.println(book.getTitle()); // NullPointerException!
Error 3: Te olvidaste de las llaves
public class Book
private String title; // Los campos suelen ser private para la encapsulación
// ...
}
';' expected
Error 4: Declarar un método dentro de otro método
public class User {
public void printName() {
void sayHello() {
System.out.println("Hello!"); // ¡No se puede declarar un método dentro de otro método!
}
}
}
illegal start of type
GO TO FULL VERSION