|
|
| (7 intermediate revisions by the same user not shown) |
| Line 1: |
Line 1: |
| {| cellspacing="0" cellpadding="0" style="clear:right; margin-bottom: .5em; float: right; padding: .5em 0 .8em 1.4em; background: none;"
| | #REDIRECT [[ist:Palavras chave da linguagem Java]] |
| |
| |
| __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).
| |
| | |
| 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 <code>final</code> 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, <code>final</code> 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 <code>final</code>.
| |
| | |
| // ilegal
| |
| //final interface UmInterface { /* definição da interface */ }
| |
| | |
| == 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.
| |
| <!--
| |
| class A {
| |
| int x;
| |
| A(int x) {
| |
| this.x = x;
| |
| }
| |
| }
| |
| -->
| |
| <B>class</B> A {
| |
| <FONT COLOR="#800000">int</FONT> x;
| |
| <FONT COLOR="#000080">A</FONT>(<FONT COLOR="#800000">int</FONT> x) {
| |
| <B>this</B>.<FONT COLOR="#000080">x</FONT> = 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, <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]]
| |