Sintaxe Java

A sintaxe Java é o que dá forma a um arquivo .java: onde as instruções terminam, como blocos de código são agrupados, quais palavras têm significado especial para o compilador e quais caracteres são permitidos em um nome. Essas regras são verificadas em tempo de compilação — o javac se recusa a produzir um arquivo .class até que todas sejam satisfeitas — portanto, aprendê-las cedo poupa muitos erros confusos mais tarde.

Este capítulo aborda as regras que você usará no restante do livro: a estrutura de um arquivo fonte, instruções, blocos, identificadores, palavras-chave, comentários, sensibilidade a maiúsculas e espaço em branco.

Um arquivo fonte Java completo

Todo programa Java independente precisa de pelo menos uma classe com um método main. Aqui está o arquivo mínimo:

public class App {
    public static void main(String[] args) {
        System.out.println("Hello, syntax!");
    }
}

Três coisas acontecem na página:

• A declaração de classe public class App { ... } envolve tudo dentro de uma classe.
• A declaração de método public static void main(String[] args) { ... } é o ponto de entrada do programa.
• A instrução System.out.println(...) realiza o trabalho.

O arquivo deve ser salvo como App.java porque a classe pública se chama App. Esta é uma regra rígida: um arquivo fonte pode conter no máximo uma classe public, e o nome do arquivo deve corresponder exatamente ao nome dessa classe, incluindo maiúsculas e minúsculas. Veja Java Hello World para o ciclo completo de compilação e execução.

Instruções terminam com ponto e vírgula

Uma instrução Java é um comando que diz ao programa para fazer algo. Cada instrução termina com um ponto e vírgula:

int score = 0;
score = score + 5;
System.out.println(score);

Como o ponto e vírgula — e não a quebra de linha — é o que encerra uma instrução, você pode distribuir uma instrução longa por várias linhas ou (de forma menos legível) colocar várias instruções em uma única linha:

int total = 1 + 2 + 3
          + 4 + 5;        // one statement, two lines
int a = 1; int b = 2;     // two statements, one line

Esquecer o ponto e vírgula é o erro mais comum de iniciantes. O compilador apontará a linha em que percebeu o problema, que geralmente é a linha depois daquela onde o ponto e vírgula está faltando — portanto, quando você vir "';' expected", verifique a linha acima da indicada.

Blocos agrupam instruções

Chaves { e } agrupam instruções em um bloco. Corpos de classes, corpos de métodos, corpos de laços e corpos de if são todos blocos:

public class Counter {        // class block opens
    public static void main(String[] args) {   // method block opens
        for (int i = 0; i < 3; i++) {          // loop block opens
            System.out.println(i);
        }                                       // loop block closes
    }                                           // method block closes
}                                               // class block closes

O recuo não faz parte da sintaxe (o compilador ignora espaços em branco), mas todo leitor espera quatro espaços por bloco aninhado. A maioria das IDEs formata isso automaticamente ao salvar.

Identificadores

Um identificador é qualquer nome que você escolhe — para uma classe, um método, uma variável, uma constante. As regras:

• Começa com uma letra, _ ou $.
• Após o primeiro caractere, pode também conter dígitos.
• Sensível a maiúsculas e minúsculas: total e Total são nomes diferentes.
• Não pode ser uma palavra-chave reservada (class, int, return, etc.).
• Sem limite de comprimento.

Válido: total, lineCount, _temp, $jquery, userName2. Inválido: 2lines (começa com dígito), line-count (hífen), class (palavra-chave).

Essas são as regras que o compilador impõe. Além delas, Java tem fortes convenções de nomenclatura que o compilador ignora, mas que todo desenvolvedor Java espera:

• Classes usam UpperCamelCase — BankAccount, HttpServer.
• Métodos e variáveis usam lowerCamelCase — accountBalance, parseInput.
• Constantes usam UPPER_SNAKE_CASE — MAX_SIZE.

Segui-las não é opcional na prática. O capítulo Java Variables aprofunda a nomenclatura e a declaração de dados.

Palavras-chave

Java reserva cerca de 50 palavras para a própria linguagem. Você não pode usá-las como identificadores. As que você verá com mais frequência:

abstract  case      do        finally    int         private     synchronized  throws
assert    catch     double    float      interface   protected   this          transient
boolean   char      else      for        long        public      throw         try
break     class     enum      if         new         return      void          while
byte      continue  extends   import     null        short       volatile      switch

Além de algumas palavras-chave contextuais adicionadas no Java moderno, que só têm significado especial em certas posições (var, yield, record, sealed, permits).

Sensibilidade a maiúsculas e minúsculas

Java é sensível a maiúsculas e minúsculas em tudo — nomes de classes, nomes de métodos, variáveis, palavras-chave. System não é o mesmo que system, e if não é o mesmo que If. O compilador informará "cannot find symbol" se você digitar um nome incorretamente.

Espaço em branco e quebras de linha

Espaços, tabulações e quebras de linha entre tokens são equivalentes. O compilador não se importa se você escrever:

int x=1+2;

ou:

int x = 1 + 2;

Use o que for mais legível; a folha de estilo padrão (e o formatador da sua IDE) fornecerá a resposta certa.

O único lugar onde o espaço em branco importa é dentro de literais de string e caractere: "Hello world" e "Helloworld" são valores diferentes, e os espaços entre eles são mantidos exatamente como digitados.

Comentários

Um comentário é texto que o compilador ignora completamente. Java tem três formas:

// line comment — runs to the end of the line

/* block comment —
   can span multiple lines */

/**
 * Javadoc comment — a block comment whose first character
 * is an extra asterisk. Tools generate API docs from these.
 */

Use comentários para explicar o porquê de algo ser feito, não para repetir o que o código obviamente faz. O capítulo Java Comments aborda cada forma e quando utilizá-la.

Um programa que exercita as regras

Observe que toda instrução termina com ;, os corpos de classe e método são blocos { ... }, os nomes x, y e product são identificadores válidos, e o arquivo seria salvo como Demo.java.

O que vem a seguir

O próximo capítulo, Java Output, aborda os três métodos de impressão (print, println, printf) que você usará para inspecionar o que seus programas estão fazendo. Em seguida, Java Data Types explica quais tipos de valores seus identificadores podem conter.

Prática