Revision as of 15:22, 28 September 2005 (view source) Root (talk | contribs) ← Older edit		Latest revision as of 17:22, 23 October 2013 (view source) Root (talk | contribs)
(51 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;"
		+	|
		+	__TOC__
		+	|}
		+
		+
		+	== abstract ==
		+
		+	=== Classe ===
		+
		+	=== Método ===
		+
	== boolean ==		== boolean ==
−	Tipo primitivo.	+	[[Tipos primitivos em Java|Tipo primitivo]].
	== break ==		== break ==
		+
		+	* Utilização em ciclos: ver <code>[[#for|for]]</code> e <code>[[#while|while]]</code>.
		+	* Outros casos: ver <code>[[#switch|switch]]</code>.
	== byte ==		== byte ==
−	Tipo primitivo.	+	[[Tipos primitivos em Java|Tipo primitivo]].
	== case ==		== case ==
		+
		+	Ver <code>[[#switch|switch]]</code>.
	== catch ==		== catch ==
		+
		+	Ver <code>[[#try|try]]</code>.
	== char ==		== char ==
−	Tipo primitivo.	+	[[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 ==		== class ==
	== continue ==		== continue ==
		+
		+	* Ver <code>[[#for|for]]</code> e <code>[[#while|while]]</code>.
	== default ==		== default ==
		+
		+	Ver <code>[[#switch|switch]]</code>.
	== do ==		== do ==
		+
		+	Ver <code>[[#while|while]]</code>.
	== double ==		== double ==
−	Tipo primitivo.	+	[[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 ==		== else ==
		+
		+	Ver <code>[[#if|if]]</code>.
	== extends ==		== extends ==
		+
		+	Ver <code>[[#class|class]]</code>.
	== final ==		== 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 ==		== finally ==
		+
		+	Ver <code>[[#try|try]]</code>.
	== float ==		== float ==
−	Tipo primitivo.	+	[[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 ==		== for ==
Line 46:		Line 140:
	== implements ==		== implements ==
		+
		+	Ver <code>[[#interface|interface]]</code>.
	== import ==		== import ==
Line 51:		Line 147:
	== int ==		== int ==
−	Tipo primitivo.	+	[[Tipos primitivos em Java|Tipo primitivo]] que representa um valor inteiro de 32 bits.
	== interface ==		== interface ==
Line 57:		Line 153:
	== long ==		== long ==
−	Tipo primitivo.	+	[[Tipos primitivos em Java|Tipo primitivo]] que representa um valor inteiro de 64 bits.
	== new ==		== new ==
Line 75:		Line 171:
	== short ==		== short ==
−	Tipo primitivo.	+	[[Tipos primitivos em Java|Tipo primitivo]] que representa um valor inteiro de 16 bits.
	== static ==		== static ==
		+
		+	== super ==
	== switch ==		== switch ==
	== synchronized ==		== 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.
		+	<java5>
		+	class A {
		+	A(int i) { /* qualquer coisa */ }
		+	A(float f, int i) {
		+	this(i);              // chamada ao primeiro construtor
		+	/* resto do segundo construtor */
		+	}
		+	}
		+	</java5>
		+
		+	== throw ==
	== throws ==		== throws ==
Line 89:		Line 226:
	== void ==		== void ==
−	Tipo primitivo.	+	[[Tipos primitivos em Java|Tipo primitivo]] que representa a ausência de valor retorno de um método.
		+
		+	== volatile ==
	== while ==		== while ==
−	[[category:OOP]]	+	[[category:Ensino]]
		+	[[category:PO]]
	[[category:Java]]		[[category:Java]]

---

Latest revision as of 17:22, 23 October 2013

Contents 1 abstract 1.1 Classe 1.2 Método 2 boolean 3 break 4 byte 5 case 6 catch 7 char 8 class 9 continue 10 default 11 do 12 double 13 else 14 extends 15 final 15.1 Atributos 15.2 Métodos 15.3 Classes 15.4 Interfaces 16 finally 17 float 18 for 19 if 20 implements 21 import 22 int 23 interface 24 long 25 new 26 package 27 private 28 protected 29 public 30 return 31 short 32 static 33 super 34 switch 35 synchronized 36 this 36.1 Referência 36.2 Sintaxe de Construção 37 throw 38 throws 39 try 40 void 41 volatile 42 while

abstract

Classe

Método

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 também UTF-8).

class

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). <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 final 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, final 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 final. <java5>

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

</java5>

finally

Ver try.

float

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

for

if

implements

Ver interface.

import

int

Tipo primitivo que representa um valor inteiro de 32 bits.

interface

long

Tipo primitivo que representa um valor inteiro de 64 bits.

new

Operador.

package

private

protected

public

return

short

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 this 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, this pode ocorrer apenas uma vez e deve aparecer como a primeira instrução do construtor. <java5>

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

</java5>

throw

throws

try

void

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

volatile

while