View source for Palavras chave da linguagem Java

{| cellspacing="0" cellpadding="0" style="clear:right; margin-bottom: .5em; float: right; padding: .5em 0 .8em 1.4em; background: none;"
|
__TOC__
|}


== abstract ==

=== Classe ===

=== Método ===

== boolean ==

[[Tipos primitivos em Java|Tipo primitivo]].

== break ==

* Utilização em ciclos: ver <code>[[#for|for]]</code> e <code>[[#while|while]]</code>.
* Outros casos: ver <code>[[#switch|switch]]</code>.

== byte ==

[[Tipos primitivos em Java|Tipo primitivo]].

== case ==

Ver <code>[[#switch|switch]]</code>.

== catch ==

Ver <code>[[#try|try]]</code>.

== char ==

[[Tipos primitivos em Java|Tipo primitivo]] que representa um carácter de 16 bits, segundo a norma [[wikipedia:Unicode|Unicode]] (ver também [[wikipedia:UTF-8|UTF-8]]).

== class ==

== continue ==

* Ver <code>[[#for|for]]</code> e <code>[[#while|while]]</code>.

== default ==

Ver <code>[[#switch|switch]]</code>.

== do ==

Ver <code>[[#while|while]]</code>.

== double ==

[[Tipos primitivos em Java|Tipo primitivo]] que representa um valor real em vírgula flutuante de 64 bits, segundo a norma [[wikipedia:IEEE floating-point standard|IEEE 754]].

== else ==

Ver <code>[[#if|if]]</code>.

== extends ==

Ver <code>[[#class|class]]</code>.

== final ==

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

=== Atributos ===

Um atributo declarado <code>final</code> 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).
<java5>
  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; }
  }
</java5>
<java5>
  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; }
  }
</java5>

=== Métodos ===

Um método declarado <code>final</code> numa classe não pode ser redefinido em nenhuma sublasse dessa classe.
<java5>
  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() { /* ... */ }
  }
</java5>

=== Classes ===

Quando aplicado a uma classe, <code>final</code> impede que ela venha a ser especializada.
<java5>
  final class UmaClasse { /* definição da classe */ }
  
  // erro: não se pode derivar de uma classe final
  //class OutraClasse extends UmaClasse { /* ... */ }
</java5>

=== Interfaces ===

As interfaces não podem ser afectadas por <code>final</code>.
<java5>
  // ilegal
  //final interface UmInterface { /* definição da interface */ }
</java5>

== finally ==

Ver <code>[[#try|try]]</code>.

== float ==

[[Tipos primitivos em Java|Tipo primitivo]] que representa um valor real em vírgula flutuante de 32 bits, segundo a norma [[wikipedia:IEEE floating-point standard|IEEE 754]].

== for ==

== if ==

== implements ==

Ver <code>[[#interface|interface]]</code>.

== import ==

== int ==

[[Tipos primitivos em Java|Tipo primitivo]] que representa um valor inteiro de 32 bits.

== interface ==

== long ==

[[Tipos primitivos em Java|Tipo primitivo]] que representa um valor inteiro de 64 bits.

== new ==

Operador.

== package ==

== private ==

== protected ==

== public ==

== return ==

== short ==

[[Tipos primitivos em Java|Tipo primitivo]] que representa um valor inteiro de 16 bits.

== static ==

== super ==

== switch ==

== synchronized ==

== 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 <code>this</code> como forma de desambiguar as variáveis no construtor.
<java5>
 class A {
   int x;
   A(int x) {
     this.x = x;
   }
 }
</java5>

O seguinte exemplo mostra o uso como auto-referência: o objecto passa-se a si próprio como argumento de uma operação:
<java5>
  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)
    }
  }
</java5>

=== Sintaxe de Construção ===

Num construtor, esta palavra reservada pode ser utilizada para chamar explicitamente outro construtor da mesma classe. Quando é utilizado desta forma, <code>this</code> 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 */
    }
  }
-->
  <B>class</B> A {
    <FONT COLOR="#000080">A</FONT>(<FONT COLOR="#800000">int</FONT> i) { <I><FONT COLOR="#808080">/* qualquer coisa */</FONT></I> }
    <FONT COLOR="#000080">A</FONT>(<FONT COLOR="#800000">float</FONT> f, <FONT COLOR="#800000">int</FONT> i) {
      <B>this</B>(i);               <I><FONT COLOR="#808080">// chamada ao primeiro construtor</FONT></I>
      <I><FONT COLOR="#808080">/* resto do segundo construtor */</FONT></I>
    }
  }

== throw ==

== throws ==

== try ==

== void ==

[[Tipos primitivos em Java|Tipo primitivo]] que representa a ausência de valor retorno de um método.

== volatile ==

== while ==

[[category:Java]]
[[category:OOP]]
[[category:Teaching]]