1. Erros na declaração de classe
Ausência de modificadores de acesso (package-private por padrão)
Em Java, se você não especifica explicitamente um modificador de acesso em uma classe, ela fica acessível apenas dentro do pacote atual. Isso é chamado de package-private ou “acesso padrão”. Por exemplo:
// Arquivo Book.java
class Book {
String title;
}
Essa classe não pode ser usada a partir de outro pacote. Se você quiser que a classe esteja disponível em todos os lugares (e, na maioria das vezes, é isso que se deseja para os modelos principais), use o modificador public:
public class Book {
String title;
}
Por que isso é importante?
Se você esquecer de colocar public, depois vai ficar se perguntando por que alguma Library de outro pacote não enxerga sua classe.
Incoerência entre o nome da classe e o nome do arquivo
Em Java, o nome do arquivo com a classe deve corresponder ao nome da classe pública dentro desse arquivo (com diferenciação de maiúsculas e minúsculas!). Por exemplo:
// Arquivo Book.java
public class Book {
// ...
}
Se você nomear o arquivo como book.java (com inicial minúscula) ou, pior ainda, BooK.java, o compilador emitirá um erro. É uma das razões pelas quais a IDE gosta tanto de reclamar quando você renomeia a classe, mas esquece de renomear o arquivo.
Erros na sintaxe de declaração: chaves esquecidas, posicionamento incorreto de métodos e campos
Java é uma linguagem estrita. Se você esquecer alguma chave ou, por engano, declarar um método dentro de outro método (isso não é permitido!), o compilador reclamará imediatamente.
Exemplo de declaração incorreta:
public class User
String name; // Ops! Faltaram as chaves da classe
public void printName() {
System.out.println(name);
}
}
Versão correta:
public class User {
String name;
public void printName() {
System.out.println(name);
}
}
Lembre-se:
- Todos os campos e métodos são declarados apenas dentro das chaves da classe.
- Métodos não podem ser aninhados uns dentro dos outros (em algumas linguagens métodos aninhados são permitidos, mas não em Java!).
2. Erros ao criar objetos
Tentar usar um objeto antes de inicializá-lo (NullPointerException)
O erro mais comum de todos os tempos é tentar acessar um objeto que ainda não foi criado. Em Java, variáveis de tipo de referência são, por padrão, iguais a null.
Exemplo:
User user;
System.out.println(user.name); // NullPointerException!
Por quê?
A variável user foi declarada, mas não inicializada. Ao tentar acessar um campo ou método, você receberá um NPE (NullPointerException).
Abordagem correta:
User user = new User();
System.out.println(user.name); // Agora está tudo ok (se o campo não for null)
Erros na chamada do construtor (parâmetros incompatíveis, ausência de construtor padrão)
Se a classe tiver apenas um construtor com parâmetros, tentar criar um objeto sem parâmetros levará a um erro de compilação.
public class Book {
String title;
public Book(String title) {
this.title = title;
}
}
Book book = new Book(); // Erro! Não há construtor sem parâmetros
Solução: ou adicione um construtor sem parâmetros, ou sempre passe os valores necessários:
Book book = new Book("Java para iniciantes");
Criar múltiplos objetos em vez de reaproveitar
Às vezes iniciantes criam um novo objeto toda vez que precisam acessá-lo, em vez de usar o que já foi criado.
Book book = new Book("Java para iniciantes");
System.out.println(book.title);
book = new Book("Java para iniciantes"); // Por quê? Esse objeto já existia!
System.out.println(book.title);
Isso não é um erro de compilação, mas é um sinal de mau estilo — você perde a referência ao objeto antigo e consome memória desnecessariamente.
3. Boas práticas: como evitar armadilhas
Sempre declare explicitamente os modificadores de acesso
Não tenha preguiça de escrever public, private ou protected — isso não é só sobre segurança, mas também sobre legibilidade do código. A IDE, claro, ajuda, mas é melhor criar o hábito desde o início.
Exemplo:
public class User {
private String name;
// ...
}
Cuide da nomenclatura das classes
- Nome da classe — com inicial maiúscula, estilo CamelCase: Book, LibraryUser, BookManager.
- Nome do arquivo — exatamente igual ao nome da classe.
Use construtores para inicializar campos obrigatórios
Se um objeto tem campos que precisam ser preenchidos na criação, adicione um construtor com parâmetros. Isso evita erros na fase de uso.
Exemplo:
public class User {
private String name;
public User(String name) {
this.name = name;
}
}
Agora não é possível criar User sem nome — o compilador não permitirá.
4. Aplicando o conhecimento: construindo um mini‑aplicativo “Biblioteca”
Vamos continuar evoluindo nosso aplicativo de estudo. Suponha que temos a classe Book e a classe Library, que gerencia os livros.
Exemplo de declaração correta de classe
// Arquivo Book.java
public class Book {
private String title;
private String author;
// Construtor com 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;
}
}
Exemplo de criação correta de objeto
Book book = new Book("Java para iniciantes", "John Doe");
System.out.println(book.getTitle() + " - " + book.getAuthor());
Exemplo de classe‑gerenciadora
// Arquivo 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 no main
public class Main {
public static void main(String[] args) {
Library library = new Library();
Book book1 = new Book("Java para iniciantes", "John Doe");
Book book2 = new Book("POO de forma simples", "Ivan Ivanov");
library.addBook(book1);
library.addBook(book2);
library.printAllBooks();
}
}
5. Ilustrações e diagramas
Diagrama: onde declarar o quê?
+-----------------------------+
| Book.java |
|-----------------------------|
| public class Book { |
| private String title; | <--- campos (apenas dentro da classe)
| ... |
| public Book(...) {...} | <--- construtor (dentro da classe)
| public String getTitle()| <--- métodos (dentro da classe)
| } |
+-----------------------------+
+-----------------------------+
| Main.java |
|-----------------------------|
| public class Main { |
| public static void main |
| // Criação de objetos|
| Book book = new Book|
| } |
+-----------------------------+
6. Análise de erros típicos
Erro 1: Incoerência entre o nome da classe e o arquivo
// Arquivo: Libraryuser.java
public class LibraryUser { // Nome da classe com U maiúsculo, arquivo com u minúsculo!
// ...
}
class LibraryUser is public, should be declared in a file named LibraryUser.java
Erro 2: Tentativa de usar um objeto não inicializado
Book book;
System.out.println(book.getTitle()); // NullPointerException!
Erro 3: Esqueceu as chaves
public class Book
private String title; // Campos geralmente são private para encapsulamento
// ...
}
';' expected
Erro 4: Declaração de método dentro de método
public class User {
public void printName() {
void sayHello() {
System.out.println("Hello!"); // Não é permitido declarar método dentro de método!
}
}
}
illegal start of type
GO TO FULL VERSION