Java Sintaxe e Estrutura

Toda língua tem gramática. No português, uma vírgula fora do lugar raramente impede alguém de entender a frase; no Java, impede o programa de existir. A sintaxe é o conjunto de regras de escrita do Java: onde vai cada símbolo, quais nomes valem, o que diferencia maiúscula de minúscula. Nesta aula você aprende as regras que valem para todo programa e as convenções que fazem o seu código parecer escrito por um programador Java.

A ideia: regras e costumes

Na escrita, há dois tipos de regra. As da gramática são obrigatórias: "eu vai" está errado. As de estilo são costumes: começar uma carta com "Prezada Ana" não é obrigatório, mas todo mundo espera.

O Java é igual:

• Regras de sintaxe são obrigatórias. Quebrou uma, o javac recusa o programa com um erro.
• Convenções são costumes da comunidade Java: o código compila sem elas, mas fica estranho e difícil de ler para outros programadores.

Esta aula marca cada item como regra ou convenção.

A estrutura de um programa

Todo programa Java tem a mesma organização, em camadas, como bonecas russas:

arquivo Loja.java
└── classe Loja                       public class Loja { … }
    └── método main                   public static void main(String[] args) { … }
        ├── instrução                 String cliente = "Ana";
        ├── instrução                 int macas = 3;
        └── instrução                 System.out.println(…);

public class Loja {
    public static void main(String[] args) {
        String cliente = "Ana";
        int macas = 3;
        System.out.println("Cliente: " + cliente);
        System.out.println("Maçãs: " + macas);
    }
}

$ java Loja.java
Cliente: Ana
Maçãs: 3

Instruções só podem ficar dentro de métodos (regra). Um System.out.println solto dentro da classe, fora do main, não compila. O significado de cada palavra da moldura está em Olá, Mundo; variáveis como cliente e macas, em Variáveis.

O ponto e vírgula ; (regra)

Toda instrução termina com ;. Não importa se ela ocupa meia linha ou três: o Java não olha para o fim da linha, olha para o ;.

Por isso, uma instrução comprida pode ser quebrada em várias linhas, e várias instruções podem ficar na mesma linha:

public class Main {
    public static void main(String[] args) {
        System.out.println("Uma instrução "
                + "em duas linhas");
        System.out.println("Oi"); System.out.println("Tudo numa linha");
    }
}

$ java Main.java
Uma instrução em duas linhas
Oi
Tudo numa linha

As duas formas compilam. A primeira é útil para linhas muito compridas. A segunda é permitida, mas a convenção é uma instrução por linha, para ler fácil.

Sem o ;, o javac não sabe onde a instrução termina:

$ javac Main.java
Main.java:3: error: ';' expected
        int nota = 8
                    ^
1 error

Repare: o ^ aponta para logo depois do 8, onde o ; deveria estar, e a linha citada (3) é a da instrução sem ;. O que não leva ponto e vírgula: a linha que abre uma classe ou um método (termina em {) e as chaves }.

Blocos e chaves { } (regra)

As chaves agrupam código num bloco. A classe tem um bloco; cada método, outro; mais tarde, cada if e cada laço terão o seu. Toda { precisa da sua }, e elas se fecham na ordem inversa da abertura: a última aberta é a primeira fechada.

Falta de chave e chave sobrando dão erros diferentes:

public class Main {
    public static void main(String[] args) {
        String nome = "Ana";
        System.out.println(nome);
    }
}}

$ javac Main.java
Main.java:6: error: class, interface, annotation type, enum, record, method or field expected
}}
 ^
1 error

A primeira } da linha 6 fechou a classe. Depois dela, fora de qualquer classe, o Java só aceita começar outra coisa (uma classe, uma interface…), e encontrou mais uma }. A aula Lendo Erros do javac mostra o caso da chave faltando.

Maiúsculas e minúsculas importam (regra)

Para o Java, System, system e SYSTEM são três nomes completamente diferentes, tanto quanto "casa" e "cama". Isso se chama ser sensível a maiúsculas (em inglês, case-sensitive). Cada troca dá um erro diferente:

A mensagem do primeiro é curiosa: "o pacote system não existe". Com minúscula, o Java não reconhece a classe System e tenta entender system.out como um pacote (uma pasta de classes, veja Pacotes e import). Por isso a mensagem fala de pacote, e não de letra errada.

A mesma regra vale para os seus nomes. Duas variáveis que diferem só na maiúscula são duas variáveis diferentes:

int nota = 7;
int Nota = 9;                              // outra variável!
System.out.println(nota + " e " + Nota);   // mostra: 7 e 9

Compila, mas é uma armadilha para quem lê. Não faça isso de propósito.

public class Main {
    public static void main(String[] args) {
        string nome = "Ana";
        system.out.println("Olá, " + nome + "!");
        System.out.Println("Seu pedido: 3 maçãs");
    }
}

public class Main {
    public static void main(String[] args) {
        String nome = "Ana";
        System.out.println("Olá, " + nome + "!");
        System.out.println("Seu pedido: 3 maçãs");
    }
}

Espaços, quebras de linha e recuo

Fora dos textos entre aspas, o Java trata espaços, tabs e quebras de linha como simples separadores ((regra)): um espaço ou dez dá na mesma. Até isto compila e funciona:

System . out . println ( "espaços em volta do ponto" ) ;

Mas um espaço dentro de um nome quebra o nome em dois:

$ javac Main.java
Main.java:3: error: ';' expected
        Sys tem.out.println("Oi");
               ^
1 error

O Java leu Sys e tem.out.println(...) como duas coisas separadas e esperava um ; entre elas. Dentro das aspas, ao contrário, cada espaço conta e aparece na tela.

Recuo (indentação) (convenção)

O recuo no começo das linhas não muda nada para o Java, mas muda tudo para quem lê. Compare o mesmo programa, que compila igual:

public class Main { public static void main(String[] args) { System.out.println("Oi"); System.out.println("Tudo numa linha"); } }

public class Main {
    public static void main(String[] args) {
        System.out.println("Oi");
        System.out.println("Tudo numa linha");
    }
}

As convenções de formatação do Java:

• 4 espaços a cada nível de bloco (o main fica 4 espaços para dentro da classe; as instruções, 8).
• A { fica no fim da linha que abre o bloco, não sozinha na linha de baixo.
• A } fica sozinha, alinhada com o começo da linha que abriu o bloco.
• Uma instrução por linha.
• Espaço dos dois lados de = e +: int total = a + b;.

Editores de código e IDEs fazem o recuo sozinhos (veja Editores e IDEs). Com o recuo certo, uma chave faltando salta aos olhos.

public class Main {
public static void main(String[] args) {
      System.out.println("Loja da Ana");   System.out.println("Aberta das 8h às 18h");
        System.out.println(   "Volte sempre!"   );
 }
        }

Identificadores: as regras dos nomes (regra)

Um identificador é qualquer nome que você cria: de classe, de variável, de método. As regras:

Os erros de nome são confusos, porque o javac não diz "nome inválido": ele tenta entender o código de outra forma e reclama do que não fez sentido. Três exemplos reais:

$ javac Main.java              « int 2notas = 10;
Main.java:3: error: not a statement
        int 2notas = 10;
        ^
Main.java:3: error: ';' expected
        int 2notas = 10;
           ^
2 errors

$ javac Main.java              « int class = 10;
Main.java:3: error: not a statement
        int class = 10;
        ^
Main.java:3: error: ';' expected
        int class = 10;
           ^
Main.java:3: error: <identifier> expected
        int class = 10;
                 ^
3 errors

$ javac Main.java              « int nota-final = 10;
Main.java:3: error: ';' expected
        int nota-final = 10;
                ^
Main.java:3: error: illegal start of type
        int nota-final = 10;
                       ^
2 errors

No último, o Java leu nota-final como "nota menos final": o hífen é o sinal de subtração. Quando um erro aparece numa linha que declara um nome, desconfie do nome. A mensagem <identifier> expected ("esperava um identificador") é a pista mais direta.

public class Main {
    public static void main(String[] args) {
        int 2notas = 15;
        int nota-extra = 2;
        System.out.println("Total: " + (2notas + nota-extra));
    }
}

public class Main {
    public static void main(String[] args) {
        int duasNotas = 15;
        int notaExtra = 2;
        System.out.println("Total: " + (duasNotas + notaExtra));
    }
}

Convenções de nomes (convenção)

Dentro das regras, você pode escolher qualquer nome. Mas os programadores Java seguem um padrão tão firme que um nome fora dele parece erro. O padrão depende do que está sendo nomeado:

camelCase vem de camel, "camelo": as maiúsculas no meio parecem corcovas (precoTotalDoPedido). PascalCase homenageia a linguagem Pascal, que popularizou o estilo. Por causa dessas convenções, só de olhar você sabe que String é uma classe, nome é uma variável e MAX_ALUNOS é uma constante (veja Constantes).

Bons nomes

• Diga o que é: precoTotal é melhor que pt, x ou valor2.
• Métodos fazem coisas: comece com um verbo: calcularMedia, mostrarRecibo.
• Uma língua só: o guia nomeia em português (nota, cliente); muitas empresas usam inglês. O importante é não misturar (notaFinal com totalPrice).
• Evite _ e $ em nomes comuns: o $ é usado pelo próprio Java em nomes que ele gera, e o _ sozinho é palavra reservada.

Palavras reservadas

Algumas palavras têm significado fixo no Java e não podem ser usadas como nomes: as palavras reservadas (keywords, "palavras-chave"). Você já conhece algumas:

Todas são escritas em minúsculas. Há ainda palavras "reservadas só em certos lugares", como var, record e yield: elas têm significado especial em alguns pontos do código, mas ainda podem ser nomes de variável (o guia testou int var = 3; e int record = 4;: compilam). Não use, para não confundir. A lista completa, com o que cada uma faz, está na Referência de Palavras-chave.

Referência

Exercícios

Resumo

• Programa = classe ⊃ métodos ⊃ instruções. Instruções só dentro de métodos e rodam de cima para baixo.
• Toda instrução termina em ;; o fim da linha não importa para o Java.
• Chaves agrupam blocos e precisam fechar na ordem certa.
• Maiúsculas importam: System ≠ system, nota ≠ Nota.
• Espaços e quebras de linha são livres fora das aspas; dentro de um nome, quebram o nome.
• Nomes: letras, dígitos, _ e $, sem começar com dígito, sem palavras reservadas.
• Convenções: PascalCase para classes, camelCase para variáveis e métodos, MAIÚSCULAS_COM_SUBLINHADO para constantes, recuo de 4 espaços.