Palavras chave da linguagem Java

boolean

Tipo primitivo.

break

• Utilização em ciclos: ver for e while.
• Outros casos: ver switch.

byte

Tipo primitivo.

case

Ver switch.

catch

Ver try.

char

Tipo primitivo que representa um carácter de 16 bits, segundo a norma Unicode (ver UTF-8)

continue

• Ver for e while.

default

Ver switch.

do

Ver while.

double

Tipo primitivo que representa um valor real em vírgula flutuante de 64 bits, segundo a norma IEEE 754.

else

Ver if.

extends

Ver class.

final

A palavra chave final implica que a entidade à qual é aplicada é de alguma forma imutável.

Atributos

Um atributo declarado final não pode ser alterado, só podendo ser iniciado (i.e., valor definido por omissão ou pelo construtor - neste caso, apenas se não tiver sido definido por omissão).

 class A {
   // valor de _i não foi iniciado explicitamente
   final int _i;
   // ok: _i fica com o valor final 3
   A() { _i = 3; }
   // erro: não se pode alterar um atributo final
   //void f() { _i = 4; }
 }

 class B {
   // _i já tem, por omissão, o valor 3
   final int _i = 3;
   // erro: não se pode alterar um atributo final
   //B() { _i = 3; }
   // erro: não se pode alterar um atributo final
   //void f() { _i = 4; }
 }

Métodos

Um método declarado final numa classe não pode ser redefinido em nenhuma sublasse dessa classe.

 class X {
   void f() { /* qualquer coisa */}
 }
 
 class Y extends X {
   // ok: redefinição de X.f()
   final void f() { /* ... */ }
 }
 
 class Z extends Y {
   // erro: f() é final em Y
   //void f() { /* ... */ }
 }

Classes

Quando aplicado a uma classe, final impede que ela venha a ser especializada.

 final class UmaClasse { /* definição da classe */ }
 
 // erro: não se pode derivar de uma classe final
 //class OutraClasse extends UmaClasse { /* ... */ }

Interfaces

As interfaces não podem ser afectadas por final.

 // ilegal
 //final interface UmInterface { /* definição da interface */ }

finally

Ver try.

float

Tipo primitivo que representa um valor real em vírgula flutuante de 32 bits, segundo a norma IEEE 754.

implements

Ver interface.

int

Tipo primitivo que representa um valor inteiro de 32 bits.

long

Tipo primitivo que representa um valor inteiro de 64 bits.

new

Operador.

short

Tipo primitivo que representa um valor inteiro de 16 bits.

this

Referência

Referência para o objecto "actual", i.e., para o objecto no contexto do qual se executa o código onde aparece a referência. O exemplo seguinte, embora não siga as regras de nomenclatura, ilustra o uso de this como forma de desambiguar as variáveis no construtor.

 class A {
   int x;
   A(int x) {
     this.x = x;
   }
 }

O seguinte exemplo mostra o uso como auto-referência: o objecto passa-se a si próprio como argumento de uma operação:

 class A {
   void f(A a) { /* operação sobre um "a" do tipo "A" */ }
   void g() {
     f(this);  // operação sobre objecto do tipo "A" (o próprio)
   }
 }

Sintaxe de Construção

Num construtor, esta palavra reservada pode ser utilizada para chamar explicitamente outro construtor da mesma classe. Quando é utilizado desta forma, this pode ocorrer apenas uma vez e deve aparecer como a primeira instrução do construtor.

 class A {
   A(int i) { /* qualquer coisa */ }
   A(float f, int i) {
     this(i);               // chamada ao primeiro construtor
     /* resto do segundo construtor */
   }
 }

void

Tipo primitivo que representa a ausência de valor retorno de um método.