Submarino.com.br




Palavras Reservadas

Introdução

Uma palavra reservada é uma palavra que não pode ser usada como nome de variáveis, métodos ou classes. Uma das principais características da linguagem java é que tem um pequeno conjunto de palavras reservadas.

A palavra reservada não é necessariamente uma palavra-chave, ou seja, uma palavra com significado especial na linguagem. Todas as palavras-chave são palavras reservadas, mas o inverso não é verdade.

Até à versão 7 existem 53 palavras reservadas, das quais apenas 51 são realmente utilizadas na prática. Só como exemplo, o C# (versão 4.0) tem 78 palavras reservadas, o C++ (versão C++11) tem 86 palavras reservadas de base e Scala tem apenas 40.

As palavras chave se dividem em categorias conforme o seu propósito. Algumas palavras são usadas em mais de um cenário. O significa da palavra depende do contexto onde é usado. A isso se chamada : carga semântica. Java, por ter poucas palavras chave e propositalmente reaproveitar as palavras sempre que possível tem um carga semântica bastante maior que outras linguagens. Contudo, na prática não é possível confundir os vários significados.

A lista

Esta é a lista de palavras reservadas definidas até a versão 7 da linguagem.

package import new class interface enum abstract final
implements extends instanceof public private protected super this
throw throws try catch finally if else for
do while switch case default break continue return
boolean byte short int long double float char
void strictfp transient volatile synchronized native assert static
goto const true false null

Organização

Os arquivos fonte da linguagem são organizados em pacotes através da palavras package e classes em pacotes diferentes são referenciadas com import.

Classes, Interfaces , Anotações e Enums

Os arquivos fonte da linguagem representam principalmente classes de objetos através de class mas podem também representam interfaces com interface enumerações com enum ou anotações com @interface. Note como a palavra interface tem dois significados conforme é precedida ou não de @.

O palavra class também é usada em conjunto com o nome da classes para definir o literal da classe. Por exemplo String.class é um objeto instância da classe Class de String.

Classes podem ser abstratas se classificadas com abstract. O mesmo vale para métodos dentro da classe. Classes podem ser declaras inextensíveis se classificadas com final. O mesmo vale para métodos dentro da classe. Classes e métodos podem ainda ser considerados estáticos quanto classificados com static.

Classes podem herdar de outras classes com extends e implementar interfaces com implements

Interfaces podem extender outras interfaces com extends.

O operador instanceof pode ser usado para verificar se um objeto representa uma instância de uma certa classe, interface, anotação ou enum.

Controle de Visibilidade

A visibilidade pode ser controlada para atributos, métodos e tipos (classes, anotações, interfaces, enum) com public(visível a todos), protected (visível apenas dentro do mesmo pacote e/ou via herança) e private (invisível a todos os outros).

Modificadores de escopo

Por padrão todos os métodos e atributos são resolvidos no escopo mais próximo. Contudo é por vezes necessário explicitar o escopo da classe com this ao da sua super classes imediatamente superior com super.

As palavras super e this ainda podem ser usadas em construtores para referenciar um outro construtor da mesma classe ou da classe sendo extendida.

Controle de Exceções

Exceções podem ser lançadas com throwe o método pode declarar quais exceções pode lançar com throws.

Exceções podem ser controladas com try em conjunção com catch e finally

Estruturas de Decisão

O fluxo do código pode ser controlado por decisões com if e alternativas com try. Repetições podem ser conseguidas com for, while ou do-while.

Decisões podem ainda ser feitas utilizando a construção de chaveamento switch onde se especificam os casos possíveis com case. Um caso padrão é identificado com default.

Fluxo de repetição e chaveamento podem ser interrompidos com break. Fluxos de repetição podem pular para a próxima iteração com continue.

Fluxos de código que produzem valores podem comandar que o retorno seja executado com return

Tipos primitivos

Java suporta tipos de dados que não são objetos chamados de tipos primitivos. Cada um deles identificado com uma palavra reservada para o nome do tipo: byte, short, int, long, double, float, char e boolean. Um tipo primitivo especial é usado quando não há retorno do método void, embora não seja válido declarar variáveis do tipo void

Reserva Especial

Duas palavras são reservadas por motivos históricos e usá-las em código irá criar erros de compilação: goto e const. goto é reservado exatamente para que ninguém use. const era utilizado para definir constantes em versões iniciais do java (pré lançamento ao publico). No modelo atual constantes são definidas com uma conjunção de palavras, especificamente static e final em sequência

conceitos Avançados

Java provê controle muito crú de threads. Ao trabalhar com threads é importante controlar o acesso sincronizado e isso é conseguido com synchronized. Também no âmbito do uso de threads pode ser útil libertar atributos para serem consultados por diferentes threads, embora esperando coerência na leitura. Isso é conseguido com volatile.

Java provê um mecanismo intrínseco de serialização de objetos para stream de bytes e vice-versa. Por padrão todos os atributos são serializados. Para indicar que um atributo não deve ser serializado é utilizada a palavra transient.

Java provê um mecanismo intrínseco de extensão de funcionalidade onde a implementação real é realizada em código em outra linguagem. Por exemplo C++. Para conseguir isso o método é classificado com native.

Java provê um mecanismo intrínseco de controle de calculo em ponto flutuante e à semelhança de outras linguagens não garante que o mesmo calculo feito em diferentes JVM e diferente máquinas reais dê o mesmo resultado. Contudo é possível forçar que a JVM imponha regras que garantem que o resultado é reprodutível de forma portável. Para isso o método é marcado com strictfp.

Java provê um mecanismo intrínseco de asertivas. Este mecanismo é controlado pela JVM e pode ser ligado e desligado. Para que o programador possa criar uma assertiva é usada a palavra assert.

true, false e null

As palavras true , false e null não são consideradas palavras chave porque são na realidade valores literais, contudo, sendo que não podem ser usados como nome de classe, variável ou método, são consideradas palavras reservadas.

Uma por uma

Lista de palavras reservadas e seus significados

  • abstract - usado para definir que um tipo ou método é abstrato. No caso de métodos, alguma classe na hierarquia descendente terá que prover uma implementação. No caso da classe, significa que não possível invocar new nessa classe e produzir um objeto
  • assert - usado para declarar uma assertiva no código que pode ser ligada ou desligada pela JVM
  • break - usado para interromper um fluxo de repetição ou de escolha.
  • boolean - usado para declarar uma variável ou atributo primitivo do tipo lógico
  • byte - usado para declarar uma variável, ou atributo, primitivo do tipo numérico inteiro com sinal de 8 bits
  • case - usado para declarar uma opção dentro da escolha declarada por switch
  • catch - usado para declarar o escopo de tratamento de exceção, ou exceções, especificas
  • char - usado para declarar uma variável, ou atributo, primitivo do tipo numérico inteiro, sem sinal, de 16 bits
  • class - usado para definir uma classe ou para se referenciar ao literal que representa essa classe
  • continue - usado para avançar um fluxo de repetição para a próxima iteração
  • const - não é usado. A palavra é reservada que não tem qualquer significado semântico. Simplesmente não é possível usar essa palavra no código. O compilador acusará um erro de sintaxe.
  • default - usado para declarar uma opção padrão dentro da escolha declarada por switch que será usada caso nenhuma outra opção seja escolhida.
  • double - usado para declarar uma variável, ou atributo, primitivo do tipo numérico de ponto flutuante de precisão dupla
  • do - usado em conjunção com while para declarar uma repetição de execução de um certo código sendo que a cada fim de execução uma expressão será validada para saber se o código anterior será novamente executado
  • else - usado para declarar uma alternativa de decisão que deve ser tomada e o código a ser executado caso a expressão de avaliação seja falsa. Também utilizado para poder encadear outro if com uma nova expressão de decisão
  • enum - usado para definir uma enumeração
  • extends - usado para indicar que uma interface deverá extender a funcionalidade de outra interface, ou usada para indicar que uma classe deverá extender a funcionalidade de outra classe. Também é usada na declaração de generics para indicar que o tipo genérico deve extender um certo tipo
  • false - representa o valor lógico literal para FALSO
  • final - usado para definir que um tipo ou método, classe atributo ou variável não podem ser redefinidos. A partir da versão 7 é usado dentro de uma estrutura cacth para indicar que a exceção poderá ser relançada
  • finally - usado para declarar o escopo de execução que sempre será executado tenha havido ou não um exceção
  • float - usado para declarar uma variável, ou atributo, primitivo do tipo numérico de ponto flutuante de precisão simples
  • for - usado para declarar uma repetição de execução de um certo código sendo que irá acontecer uma inicialização, um teste e um incremento de uma certa variável ou conjunto de variáveis
  • goto - não é usado. A palavra é reservada apenas para não ser possível utilizar esta palavra no código. Não existe funcionalidade de goto em Java. O compilador acusará um erro de sintaxe.
  • if - usado para declarar uma decisão que deve ser tomada e o código a ser executado caso a expressão de avaliação seja verdadeira
  • implements - usado para indicar que uma interface deverá ser implementa pela classe ou enumeração
  • import - usado para estabelecer de quais pacotes estão sendo usadas as classes que aparecem no corpo do arquivo de fonte
  • instanceof - operador usado para auferir se um objeto é de um certo tipo (classe, interface, enum, anotação), considerando toda a sua hierarquia
  • int - usado para declarar uma variável, ou atributo, primitivo do tipo numérico inteiro com sinal de 32 bits
  • interface - usado para definir uma interface ou para se definir uma anotação quando precedido de @
  • long - usado para declarar uma variável, ou atributo, primitivo do tipo numérico inteiro com sinal de 64 bits
  • native - usado para declarar que a implementação do método será realizada em outra linguagem, e uma chamada nativa ao OS será usada para executar esse código
  • new - operador usado para criar um objeto, instância de uma classe.
  • null - representa o valor literal de "ausência de objeto" em uma variável ou atributo de objeto
  • package - usado para estabelecer a qual pacote o arquivo de fonte, e por conseqüência os seus tipos públicos, pertencem
  • private - usado para indicar que uma tipo ou método não é visível senão a si mesmo ou ao seu tipo imediato
  • protected - usado para indicar que uma tipo ou método é visível apenas aos tipos do mesmo pacote ou a tipo que herdem do tipo corrente.
  • public - usado para indicar que uma tipo ou método é visível a qualquer outro tipo ou método e pode por ele ser invocado
  • return - usado para forçar o retorno de um método, devolvendo ao método chamador um valor ou não
  • short - usado para declarar uma variável, ou atributo, primitivo do tipo numérico inteiro com sinal de 16 bits
  • static - usado para indicar que o método ou tipo definido a seguir não pertence ao escopo do objeto, mas sim ao escopo da classe em si mesma
  • strictfp - usado para declarar que o método deve ser executado levando em consideração regras estritas de reprodutibilidade de calculo
  • super - usado para indicar que o escopo pretendido para a invocação de um método ou acesso a um atributo é o da classe mãe.Também utilizado para fazer referencia a um outro construtor da classe imediatamente superior na hierarquia de herança.
  • switch - usado para declarar uma escolha entre várias opções de execução
  • synchronized - usado para declarar que um certo escopo de código deve ser protegido de acesso concorrente de threads diferentes
  • this - usado para indicar que o escopo pretendido para a invocação de um método ou acesso a um atributo é o do próprio objeto corrente. Também utilizado para fazer referencia a um outro construtor da mesma classe. É usando ainda como forma de referir a instância que encapsula a instância corrente quando em uma classe aninhada
  • throw - usado para lançar uma exceção
  • throws - usado para declarar quais exceções são possíveis de serem lançadas por um método
  • transient - usado para declarar que o atributo não será incluído na serialização do objeto
  • true - representa o valor lógico literal para VERDADEIRO
  • try - usado para declarar o escopo de captura de exceções
  • voidvoid - usado para declarar que o método não terá retorno
  • volatilevolatile - usado para declarar que é seguro o atributo ser acessado por threads diferentes de forma concorrente
  • whilewhile - usado para declarar uma repetição de execução de um certo código sendo que a cada inicio de execução uma expressão será validada para saber se o código seguinte será executado

Referências

[1] Java Reserved Words

URL: Java Reserved Words http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html