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.

continue

• Ver for e while.

default

Ver switch.

do

Ver while.

double

Tipo primitivo.

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.

implements

Ver interface.

int

Tipo primitivo.

long

Tipo primitivo.

new

Operador.

short

Tipo primitivo.

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.