Você está na página 1de 41

3.

Características Básicas

Este capítulo apresenta as características básicas da linguagem, como identificadores,


palavras chave, valores literais, tipos de dados e operadores.

3.1 Palavras chave e valores literais

Java possui 49 palavras chave, todas elas são escritas em minúsculas:

byte - short - int - long - char - boolean - double - float - public - private - protected -
static - abstract - final - strictfp - transient - synchronized - native - void - class -
interface - implements - extends - if - else - do - default - switch - case - break -
continue - assert - const - goto - throws - throw - new - catch - try - finally - return - this
- package - import - instaceof - while - for - volatile - super

Possui três identificadores que são valores literais:

null, false, true

Cada uma dessas palavras serão vistas mais adiante no tutorial.

3.2 Tipos primitivos

Existem somente oito tipos primitivos em Java, todo o resto é objeto. Estes tipos
ficaram na linguagem pela sua velocidade de interação, e por isso não foram
transformados em Objetos. Como não são objetos a sua declaração já cria a variável em
memória não necessitando de construtores.

Nesta seção os tipos Array e String não são tratados, pois não são considerados tipos
primitivos. Ambos são classes e serão tratadas no capítulo sobre classes.

3.2.1 Numéricos inteiros

Todos esses tipos possuem uma representação interna em complemento de dois. O valor
default para esses atributos é 0 e cada vez que se usar uma constante numérica no
código fonte ela será um int a não ser que se coloque a constante? L? no final do
número.

• byte - Tamanho de 8 bits com sinal. Valores de - 128 a + 127.


• short - Tamanho de 16 bits com sinal. Valores de - 32.768 a + 32.767.
• int - Tamanho de 32 bits com sinal. Valores de - 2.147.483.648 a +
2.147.483.647.
• long - Tamanho de 64 bits com sinal. Valores de - 9.223.372.036.854.775.808 a
+ 9.223.372.036.854.775.807.
Exemplo:

1. 100L = > long


2. 100 = > int
3. 0L = > long
4. 0 = > int

100L = > long


100 = > int
0L = > long
0 = > int

Não existe os tipos unsigned, long int ou short int em Java.

3.2.2 Ponto flutuante

Os pontos flutuantes seguem a representação IEEE 754, sendo que 0.0 é o valor default.
No código fonte, tudo o número com decimais será um float a não ser que o caractere ?
d ? ou ? D ? estejam no final do número.

• float - Tamanho de 32 bits com sinal. Valores de - 1.40239846E-45 a +


3.40282347E + 38 (com nove dígitos significativos de precisão).
• double - Tamanho de 64 bits com sinal. Valores de - 4.94065645841246544E-
324 a + 1.79769313486231570E + 308 (com 18 dígitos significativos de
precisão).

Exemplo:

1. 100.0 = > float


2. 100.00d = > double
3. 0 = > float
4. 0f = > float
5. 0d = > double
100.0 = > float
100.00d = > double
0 = > float
0f = > float
0d = > double

3.2.3 Caractere

O caractere guarda o valor traduzido de um código ASCII. Seu valor default é o código
zero, \ 0;

char - Caractere Unicode com tamanho 16 bits sem sinal. Valores possíveis 0 a 65535

O char também pode ser representado por um numero inteiro de 16 bits sem sinal, ou
seja, pode-se atribuir à uma variável char o valor 100 ou o valor 65535, pois se está
operando com os valores da tabela Unicode que representam caracteres de qualquer
idioma.

3.2.4 Booleano

Tipos boleanos identificam verdadeiro ou falso e podem ser utilizados diretamente em


expressões de retorno para testes como if, switch, while e for., porém não podem ser
comparados com variáveis ou constantes numéricas como em C.

boolean - Valor indicando true ou false. Tamanho de 8 bit.

3.2.5 Valores padrão

Abaixo segue uma lista com os valores padrões de todos os tipos primitivos, sendo que
não é necessário inicializar as variáveis com esses valores, a máquina virtual cuidará
desse trabalho.

1. * byte = 0;
2. * short = 0;
3. * int = 0;
4. * long = 0;
5. * float = 0.0;
6. * double = 0.0;
7. * boolean = false;
8. * char = ` \ u0000 ';
9. * Object = null;
* byte = 0;
* short = 0;
* int = 0;
* long = 0;
* float = 0.0;
* double = 0.0;
* boolean = false;
* char = ` \ u0000 ';
* Object = null;

Um objeto, como veremos mais adiante, é inicializado com valor null, pois ele necessita
que a instância seja criada explicitamente, o que não ocorre em tipos primitivos.

3.3 Identificadores

Os identificadores em Java iniciam com uma letra, um sublinhado ? _ ? ou um sinal de


dólar " $ " e podem possuir números após o primeiro caractere da palavra. Pela premissa
de ser case-sensitive existe uma diferenciação entre letras maiúsculas e minúsculas.
Identificadores válidos são: identificador, meu_Carro, MeuCarro2, _atributo, $bola
_2seg

Identificadores usados para determinar nomes de variáveis, atributos de classe ou de


instância, parâmetros e métodos.
3.4 O operador de atribuição

O sinal de atribuição em Java é o " = " igual ao " = " do C e ao ": = " do Delphi. Vale
deixar gravado que a comparação é feita com " = = " como no C. Uma atribuição é feita
com a seguinte sintaxe:

1. =;

=;

Veja o exemplo:
1. public class Atribuição {
2. public static void main (String [] args) {
3. int x = 1;
4. int y = 5;
5. }
6. }

public class Atribuição {


public static void main (String [] args) {
int x = 1;
int y = 5;
}
}

No exemplo é atribuído as variáveis inteiras x e y os valores 1 e 5 respectivamente.

3.5 Literais

O valor literal é um valor escrito no código fonte e identificado como de um tipo


primitivo.

1. int x = 1; // literal inteiro


2. char u = 'a'; // literal char
3. boolean b = true; // literal boolean
4. double d = 002.11d; // literal double

int x = 1; // literal inteiro


char u = 'a'; // literal char
boolean b = true; // literal boolean
double d = 002.11d; // literal double
Há três maneiras de representar literais numéricos inteiros em Java:

- octal (base 8). Representado com um 0 na frente de cada valor numérico. Exemplo:

1. int x = 01;
2. int x = 0931;
3. int x = 021;

int x = 01;
int x = 0931;
int x = 021;

- hexadecimal (base 16). Representado com um 0x na frente de cada valor numérico.


Exemplo:

1. int quinze = 0xF; // 15 (decimal)


2. int vinte_e_nove = 0x1D; // 29 (decimal)
3. int vinte_e_nove = 0x1D; // 29 (decimal)
4. int valor = 0xBAFAFA; // 12253946 (decimal)
5. int valor = 0XBaFaFa; / / 12253946 (decimal)

int quinze = 0xF; // 15 (decimal)


int vinte_e_nove = 0x1D; // 29 (decimal)
int vinte_e_nove = 0x1D; // 29 (decimal)
int valor = 0xBAFAFA; // 12253946 (decimal)
int valor = 0XBaFaFa; / / 12253946 (decimal)

- decimal (base 10). Representado normalmente como o primeiro exemplo.

Caracteres também possuem representação especial. Todo o caractere se encontra entre


aspas simples, porém pode-se atribuir um valor inteiro ao caractere sem precisar de uma
conversão explícita. Alguns exemplos são:

1. char a = 'A'; // letra A


2. char b = '&'; // caractere &
3. char c = '\u004D'; // letra M (Unicode)
4. char d = '\n'; // Pula de linha
5. char e = '\t'; // Tab
6. char f = '\r'; // Retorno de carro
7. char g = '\b'; // Backspace
8. char h = '\f'; // FormFeed
9. char i = '\\'; // Barra
10. char j = '\''; // Apostrofo
11. char k = '\"'; // Aspas duplas
12. char l = 65; // char recebe o valor de um int
13. char m = (char) -1; // fora do intervalo, conversão explícita
14. char n = (char) 100000; // fora do intervalo, conversão explícita

char a = 'A'; // letra A


char b = '&'; // caractere &
char c = '\u004D'; // letra M (Unicode)
char d = '\n'; // Pula de linha
char e = '\t'; // Tab
char f = '\r'; // Retorno de carro
char g = '\b'; // Backspace
char h = '\f'; // FormFeed
char i = '\\'; // Barra
char j = '\''; // Apostrofo
char k = '\"'; // Aspas duplas
char l = 65; // char recebe o valor de um int
char m = (char) -1; // fora do intervalo, conversão explícita
char n = (char) 100000; // fora do intervalo, conversão explícita

3.6 Conversões entre tipos primitivos

Existem duas maneiras de fazer conversões de tipos:

1. Conversão implícita, quando o tamanho de uma variável é maior que o tamanho da


variável ou o valor que está sendo atribuído. Exemplo:

1. int y = 10;
2. nbsp; long x = y;
int y = 10;
long x = y;

O tamanho de int é menor que o de long, portanto é perfeitamente aceitável.

2. Conversão explícita, quando o tamanho de uma variável é menor que o tamanho da


variável ou o valor que está sendo atribuído. Exemplo:

1. long y = 10L;
2. nbsp; int x = (int) y;

long y = 10L;
int x = (int) y;

O tamanho de long é maior que o de int, portanto necessita indicar uma conversão. Esta
indicativa é feita pelo tipo da variável, que irá receber o valor, entre parênteses: (int). Se
esta informação não for colocada, ocorreria um erro de compilação indicando tipos
incompatíveis. Outra forma é usar as constantes de identificação de tipos para fazer uma
conversão explícita, como em: long y = 10L;

3.7 Operadores aritméticos

Operadores aritméticos são aqueles que efetuam operações aritméticas em um ou mais


tipos primitivos. A seguir são apresentados os operadores aritméticos unários, que
atuam sobre um único identificador.
1. Op Nome Uso Descrição
2. ++ Incremento var++ / ++var Retorna e adiciona / adiciona e retorna.
3. -- Decremento var-- / --var Retorna e subtrai / subtrai e retorna.
4. - Negativo -var Inverte o sinal da variável
5. + Positivo +var Não tem efeito.

Op Nome Uso Descrição


++ Incremento var++ / ++var Retorna e adiciona / adiciona e retorna.
-- Decremento var-- / --var Retorna e subtrai / subtrai e retorna.
- Negativo -var Inverte o sinal da variável
+ Positivo +var Não tem efeito.

Abaixo estão os operadores aritméticos que atuam sobre duas variáveis.

1. Op Nome Uso Descrição


2. + Adição x + y Soma x com y.
3. - Subtração x - y Subtrai y de x.
4. * Multiplicação x * y Multiplica x por y.
5. / Divisão x / y Divide x por y.
6. % Resto x % y Resto da divisão de x por y.

Op Nome Uso Descrição


+ Adição x + y Soma x com y.
- Subtração x - y Subtrai y de x.
* Multiplicação x * y Multiplica x por y.
/ Divisão x / y Divide x por y.
% Resto x % y Resto da divisão de x por y.

3.8 Operadores relacionais e lógicos

Os operadores relacionais e lógicos são utilizados em testes e condições de entrada em


um fluxo do programa. Abaixo estão todos eles relacionados.
1. Op Nome Uso Descrição
2. > Maior que x>y x maior que y.
3. >= Maior ou igual a x >= y x maior ou igual a y.
4. < Menor que x<y x menor que y
5. <= Menor ou igual a x <= y x menor ou igual a y.
6. == Igual a x == y x igual a y.
7. != Diferente de x != y x diferente de y.
8. ! NÃO lógico (NOT) !y contrário de y.
9. && E lógico (AND) x && y x e y.
10. || OU lógico (OR) x ||y x ou y.
11. instanceof Verif Instância x instanceof X x é instância da classe X

Op Nome Uso Descrição


> Maior que x >y x maior que y.
>= Maior ou igual a x >= y x maior ou igual a y.
< Menor que x <y x menor que y
<= Menor ou igual a x <= y x menor ou igual a y.
== Igual a x == y x igual a y.
!= Diferente de x != y x diferente de y.
! NÃO lógico (NOT) !y contrário de y.
&& E lógico (AND) x && y x e y.
|| OU lógico (OR) x ||y x ou y.
instanceof Verif Instância x instanceof X x é instância da classe X

3.9 Operadores bitwise

Os operadores bitwise são aqueles que alteram o valor das variáveis em operações
lógicas diretamente no processador, tornando-as muito mais performáticas. Estas
operações são geralmente chamadas de ? tratamento por bits ? pois são operações que
comparam e modificam a variável bit por bit.

1. Op Nome Uso Descrição


2. ~ Inversão ~x Inversão dos bits de x.
3. & E lógico x & y AND bit a bit entre x e y.
4. | OU lógico x | y OR bit a bit entre x e y.
5. ^ OU excl. lógico x ^ y XOR bit a bit entre x e y.
6. << Desloc. a esq. x << y Desloc. a dir os bits de x, y vezes.
7. >> Desloc. a dir. x >> y Desloca a direita os bits de x, y vezes.
8. >>> Desloc. a dir. x >>> y Preenche zero a esquerda de x, y vezes.
Op Nome Uso Descrição
~ Inversão ~x Inversão dos bits de x.
& E lógico x & y AND bit a bit entre x e y.
| OU lógico x | y OR bit a bit entre x e y.
^ OU excl. lógico x ^ y XOR bit a bit entre x e y.
<< Desloc. a esq. x << y Desloc. a dir os bits de x, y vezes.
>> Desloc. a dir. x >> y Desloca a direita os bits de x, y vezes.
>>> Desloc. a dir. x >>> y Preenche zero a esquerda de x, y vezes.

3.10 O operador de atribuição composto

Já foi apresentado o operador de atribuição " = ". Porém este operador pode funcionar
em conjunto com outros operadores reduzindo o tempo de processamento de
determinadas chamadas. O operador de atribuição composto junta um operador
aritmético ou de bitwise com o operador de atribuição. É sempre utilizado na sintaxe var
= var como no exemplo abaixo:

1. public class OperadorAtribuicaoComposto {


2. public static void main (String [] args) {
3. int x = 1;
4. x + = 5;
5. }
6. }

public class OperadorAtribuicaoComposto {


public static void main (String [] args) {
int x = 1;
x + = 5;
}
}

Neste exemplo a variável inteira x é inicializada com 1 e na linha seguinte é realizado


uma operação composta: A soma e atribuição. Esta instrução é semelhante a esta: x = x
+ 5;. O resultado em x será 6. Outros exemplos são:

1. public class OperadorAtribuicaoComposto {


2. public static void main (String [] args) {
3. int x = 1; // Atribui 1 a x
4. x += 5; // Equivalente a x = x + 5; x é igual a 6
5. x *= 2; // Equivalente a x = x * 2; x é igual a 12
6. x /= 2; // Equivalente a x = x / 2; X é igual a 6
7. x -= 3; // Equivalente a x = x - 3; x é igual a 3
8. x %= 5; // Equivalente a x = x % 5; x é igual a 3
9. x |= 4; // Equivalente a x = x | 4; x é igual a 7
10. x ^= 1; / / Equivalente a x = x ^ 1; x é igual a 6
11. x &= 255; / / Equivalente a x = x & 255; x é igual a 6
12. x <<= 2; / / Equivalente a x = x << 2; x é igual a 24
13. x >>= 4; // Equivalente a x = x > > 3; x é igual a 1
14. x >>>= 7; / / Equivalente a x = x > > > 7; x é igual a 0
15. }
16. }

public class OperadorAtribuicaoComposto {


public static void main (String [] args) {
int x = 1; // Atribui 1 a x
x += 5; // Equivalente a x = x + 5; x é igual a 6
x *= 2; // Equivalente a x = x * 2; x é igual a 12
x /= 2; // Equivalente a x = x / 2; X é igual a 6
x -= 3; // Equivalente a x = x - 3; x é igual a 3
x %= 5; // Equivalente a x = x % 5; x é igual a 3
x |= 4; // Equivalente a x = x | 4; x é igual a 7
x ^= 1; / / Equivalente a x = x ^ 1; x é igual a 6
x &= 255; / / Equivalente a x = x & 255; x é igual a 6
x <<= 2; / / Equivalente a x = x << 2; x é igual a 24
x >>= 4; // Equivalente a x = x > > 3; x é igual a 1
x >>>= 7; / / Equivalente a x = x > > > 7; x é igual a 0
}

3.11 Precedência de operadores

Tabela de precedência de operadores em ordem decrescente, ou seja, o que está mais


acima, ocorre antes.
Precedência

1. + + - - + - ! (cast)
2. * / %
3. + -
4. << >> >>>
5. <>< = > = instanceof
6. = =! =
7. &
8. ^
9. |
10. &&
11. | |
12. ?:
13. = * = / = % = + = - = << = >> = >>> = & = | =
+ + - - + - ! (cast)
*/%
+-
<< >> >>>
<>< = > = instanceof
= =! =
&
^
|
&&
||
?:
= * = / = % = + = - = << = >> = >>> = & = | =

4 Comandos de decisão, repetição e desvio

Este capítulo apresentará o extremamente necessário para a construção de qualquer


sistema em Java. Declaração de variáveis, comandos de decisão, repetição e desvio de
fluxo no programa. 4.1 Declaração e Inicialização de Variáveis
A declaração de variáveis em Java pode ser feita em qualquer local do código fonte
desde que esteja dentro de uma classe. Quando a declaração da variável é feita
globalmente, ou seja, na estrutura da classe, é dita que a variável é um atributo, caso
contrário ela continua sendo chamada de variável. O escopo ou a vida de uma variável
em Java dura de acordo com o bloco onde ela foi declarada. A variável é criada no
primeiro acesso a ela e destruída após o interpretador sair do bloco de execução ao qual
ela pertence.

Em Java a declaração de variáveis é feita pelo tipo e depois um identificador. A


declaração muitas vezes é acompanhada pela inicialização a qual acrescenta o sinal de
atribuição e um valor literal ou variável.

A declaração de uma variável é feita no formato:

1. Tipo identificador [= valor_inicial];

Tipo identificador [= valor_inicial];

Observando o exemplo 4.1 pode-se identificar várias maneiras de declarar inicializar


tipos primitivos e objetos. Na linha 3 existe uma declaração simples, ela está criando
uma variável byte e o valor de bt será 0. Na linha 4 há a declaração de três variáveis do
tipo short: sht1, sht2 e sht3. Todas as três serão inicializadas com zero. Na linha 5 existe
a declaração de um inteiro i e a sua inicialização atribuindo o valor 9 para a variável. Na
linha 6 há duas variáveis sendo criadas: f1 e f2, ambas receberão o mesmo valor 98.76.
Na última linha existe a declaração de uma variável de tipo complexa String. String é a
classe que armazena uma cadeia de caracteres sem tamanho definido em Java. No
exemplo, ela está sendo inicializada com a cadeia " TESTE ". Exemplo:

1. public class DeclarandoVariáveis {


2. int atributo = 9; // Declarando uma variável global => Atributo.
3.
4. public void main(String[] args) {
5. byte bt; // Declaração simples
6. short sht1, sht2, sht3; // Declaração múltipla
7. int i = 9; // Declaração e inicialização
8. float f1, f2 = 98.76 // Declaração e inicialização múltipla
9. String str = "TESTE" // Declaração e criação de um objeto String
10. }
11. }

public class DeclarandoVariáveis {


int atributo = 9; // Declarando uma variável global => Atributo.

public void main(String[] args) {


byte bt; // Declaração simples
short sht1, sht2, sht3; // Declaração múltipla
int i = 9; // Declaração e inicialização
float f1, f2 = 98.76 // Declaração e inicialização múltipla
String str = "TESTE" // Declaração e criação de um objeto String
}
}

4.2 Instruções de Desvio

Linguagens de alto nível implementam várias estruturas de controle do fluxo do


programa para facilitar o desenvolvimento de programas e promover um melhor estilo
de programação. Os comandos de seleção e repetição são mais empíricos do que os
comandos tradicionais em linguagem de máquina.

Java possui duas instruções de desvio condicionais mais uma palavra reservada que não
deve ser usada. Todas elas existem em várias outras linguagens e plataformas.

4.2.1 Comando: if

O comando if executa um trecho de código apenas uma vez, dependendo de sua


condição. A sintaxe segue a sintaxe abaixo.
1. if ( <condição> ) {
2. <comandos>
3. } else {
4. <comandos>
5. }

if ( <condição> ) {
<comandos>
} else {
<comandos>
}

A condição é uma expressão da linguagem java e pode ser qualquer conjunto de


operações que retornem um valor booleano. Ex: (i > = 0) ou (a = = 5 & & b! = 5 | | c = =
a) O " comandos 1 " e " comandos 2 " são um conjunto de um ou mais comandos da
linguagem Java. No caso de ser apenas um comando o uso de {} não é necessário.

Se a condição for verdadeira o interpretador executará o " comandos 1 " caso contrário
o bloco " comandos 2 " será executado. Exemplo:

1. public class ExemploIf {


2. public static void main(String[] args) {
3. int i = 8;
4. // If que dirá se o valor do i é igual a 1 ou igual a dois.
5. if (i \% 2)
6. System.out.println("Oito é divisível por dois");
7. else
8. System.out.println("Oito não é divisível por dois");
9.
10. // Verifica se o nome é Vitor.
11. String nome = "Vitor";
12. if (nome.equals("Vitor")) {
13. System.out.println("Nome é Vitor");
14. } else {
15. System.out.println("Nome não é Vitor");
16. }
17. }
18. }

public class ExemploIf {


public static void main(String[] args) {
int i = 8;
// If que dirá se o valor do i é igual a 1 ou igual a dois.
if (i \% 2)
System.out.println("Oito é divisível por dois");
else
System.out.println("Oito não é divisível por dois");

// Verifica se o nome é Vitor.


String nome = "Vitor";
if (nome.equals("Vitor")) {
System.out.println("Nome é Vitor");
} else {
System.out.println("Nome não é Vitor");

No primeiro if do exemplo é testado se o valor de i é divisível por 2, ou seja, se valor de


i é par. Se for divisível, é impresso o texto Oito é divisível por dois, caso contrário é
impresso o texto Oito não é divisível por dois na linha de comando.

No segundo exemplo é feito um teste para saber se a variável String nome é igual a
Vitor. Em comparação de objetos sempre usa-se o método equals. Se o valor de nome
for Vitor é impresso Nome é Vitor, caso contrário é impresso Nome não é Vitor.

4.2.2 Comando: switch

O comando switch é o mesmo do C e é semelhante ao case do Delphi. Permite


selecionar o bloco de código a ser executado baseado no teste lógico de uma expressão.
O switch é a forma evoluída para o if, podendo tratar mais de dois blocos de execução.

Sintaxe:

1. switch ( <expressão> ) {
2. case <valor1>:<comandos 1>
3. [break;]
4. case <valor2>:<comandos 2>
5. [break;]
6. case <valor3>:<comandos 3>
7. [break;]
8. case <valor4>:<comandos 4>
9. [break;]
10. ...
11. default: <comandos default>
12. }
sw itch ( <expressão> ) {
case <valor1>:<comandos 1>
[break;]
case <valor2>:<comandos 2>
[break;]
case <valor3>:<comandos 3>
[break;]
case <valor4>:<comandos 4>
[break;]
...
default: <comandos default>
}

O comando switch executa a expressão e compara o valor encontrado com os valores: , ,


, etc. Quando encontra a igualdade ele executa o bloco de comandos daquele valor. A
execução continuará até o final do switch ou até que ele encontre um break;. Exemplos:

1. public class ExemploSwitch {


2. public static void main(String[] args) {
3. int i = 2;
4. // Switch que irá imprimir na tela o valor 2
5. switch (i) {
6. case 1 : System.out.println("Valor de i é 1");
7. break;
8. case 2 : System.out.println("Valor de i é 2");
9. break;
10. case 3 : System.out.println("Valor de i é 3");
11. break;
12. default: System.out.println("Default");
13. }
14.
15. // Switch que irá imprimir na tela o valor "Vitor"
16. String nome = "Vitor";
17. switch (nome.hashcode()) {
18. case "Vitor".hashCode() : System.out.println("Valor de nome é Vitor");
19. break;
20. case "Paulo".hashCode() : System.out.println("Valor de nome é Paulo");
21. break;
22. default: System.out.println("Default");
23. }
24. }
25. }
public class ExemploSw itch {
public static void main(String[] args) {
int i = 2;
// Sw itch que irá imprimir na tela o valor 2
sw itch (i) {
case 1 : System.out.println("Valor de i é 1");
break;
case 2 : System.out.println("Valor de i é 2");
break;
case 3 : System.out.println("Valor de i é 3");
break;
default: System.out.println("Default");
}

// Sw itch que irá imprimir na tela o valor "Vitor"

Não é necessário utilizar as chaves ({}) para delimitar um bloco de comandos, pois o
interpretador executará todos eles até encontrar um break ou o switch finalizar.

A única limitação do switch é que a deve retornar um valor numérico inteiro, qualquer
um de seus quatro tipos primitivos. O switch não funciona com String, float, char e
boolean por exemplo. E é por este motivo que no segundo switch do exemplo é
utilizado o método hashcode (), que retorna um código inteiro único para cada String
diferente.

4.2.3 Comando: goto

Há um consenso entre os desenvolvedores de software de que instruções goto devem ser


usadas somente para criar estruturas de controle, de seleção ou repetição, caso elas não
existam na linguagem trabalhada. E é exatamente por isso que, embora a palavra goto
seja uma palavra reservada do Java, ela não pode ser utilizada, o compilador Java
acusará erro se encontrá-la no código.

Os especialistas afirmam que o goto polui o código fonte e se não for utilizado
adequadamente pode se tornar um problema maior do que o próprio software.

4.3 Laços

Laços controlam uma repetição de execução de acordo com uma condição imposta. Em
Java, assim como tantas outras linguagens, existem três tipos de laço: for, while e do..
while.

4.3.1 Comando: for

O comando for cria um laço de repetição no fluxo do programa baseado em três


parâmetros:

• expressão inicial: Onde é executado apenas uma vez, na entrada do laço.


• condição: É executado a cada iteração do laço e determina quando o programa
deve sair do mesmo. Caso a condição seja verdadeira, repete-se os do laço uma
vez, caso seja falsa, o programa pula para a próxima instrução seguinte ao laço.
• incremento: É uma operação normal, executada a cada iteração. Geralmente é
usada para incrementar contadores ou configurar variáveis.

Sintaxe:

1. for (<expressão inicial>; <condição>; <incremento>) {


2. <comandos>
3. }

for (<expressão inicial> <condição> <incremento>) {


<comandos>
}

Exemplos:

1. public class ExemploFor {


2. public static void main(String[] args) {
3. for (int i=0; i<10; i++) {
4. System.out.println("Contador é " + i);
5. }
6.
7. for (;;) {
8. System.out.println("Laço infinito.");
9. }
10. }
11. }
public class ExemploFor {
public static void main(String[] args) {
for (int i=0; i<10; i++) {
System.out.println("Contador é " + i);
}

for (;;) {
System.out.println("Laço infinito.");
}
}
}

O primeiro for do exemplo acima irá apresentar 10 mensagens indicando o contador de


0 até 9. Quando o valor do inteiro i ser igual a 10 o interpretador java alternará o fluxo
para o início do outro for.

No segundo for do exemplo o código entra num laço infinito, ou seja o programa não
termina, sequer sairá do laço, já que não existe condição para que tal evento ocorra.

4.3.2 Comando: while

O comando while é utilizada quando não se quer que o corpo do laço seja
necessariamente executado. A expressão de comparação é avaliada antes que o laço seja
executado, enquanto ela for verdadeira os são repetidos.

Sintaxe:

1. while (<condição>) {
2. <comandos>
3. }

w hile (<condição>) {
<comandos>
}

Exemplos:
1. public class ExemploWhile {
2. public static void main(String[] args) {
3. int i=0;
4. while(i++<10) {
5. System.out.println("Contador é " + i);
6. }
7.
8. while(true) {
9. System.out.println("Laço infinito.");
10. }
11. }
12. }

public class ExemploWhile {


public static void main(String[] args) {
int i=0;
w hile(i++<10) {
System.out.println("Contador é " + i);
}

w hile(true) {
System.out.println("Laço infinito.");
}
}
}

Assim como nos exemplos com o comando for, o primeiro exemplo imprime contadores
de 0 até 9 e o segundo é um laço infinito, pois o resultado da condição sempre será
verdadeiro.

4.3.3 Comando: do.. while

O comando do.. while é utilizada quando se quer que o corpo do laço seja executado
pelo menos uma vez. A expressão de comparação é avaliada depois que o laço foi
executado, enquanto ela for verdadeira os são repetidos.

Sintaxe:

1. do {
2. <comandos>
3. } while (<condição>);
do {
<comandos>
} w hile (<condição>);

Exemplos:

1. public class ExemploDoWhile {


2. public static void main(String[] args) {
3. int i=0;
4. do {
5. System.out.println("Contador é " + i);
6. } while(++i<10)
7.
8. do {
9. System.out.println("Laço infinito.");
10. } while(true);
11. }
12. }

public class ExemploDoWhile {


public static void main(String[] args) {
int i=0;
do {
System.out.println("Contador é " + i);
} w hile(++i<10)

do {
System.out.println("Laço infinito.");
} w hile(true);
}
}

Assim como nos exemplos anteriores, o primeiro exemplo do comando do.. while
imprime contadores de 0 até 9 e o segundo é um laço infinito, pois o resultado da
condição sempre será verdadeiro. Embora a diferença entre os dois comandos while
sejam mínimas, cada uma é utilizada em uma determinada ocasião.

4.4 Comandos: break e continue


É a declaração de desvio usada para sair de um laço antes do normal. O tipo determina
para onde é transferido o controle. O break é transfere o controle para o final de uma
construção de laço (for, do, while ou switch). O laço vai encerrar independentemente de
seu valor de comparação e a declaração após o laço será executada. Exemplo:

1. int i = 0;
2. while (true) {
3. System.out.println(i);
4. if ( i++ >= 10 )
5. break;
6. }

int i = 0;
w hile (true) {
System.out.println(i);
if ( i++ >= 10 )
break;
}

Este exemplo imprime os valores da variável i de 0 até 9.

A declaração continue faz com que a execução do programa volte imediatamente para o
início do laço, porém para a próxima interação. O continue faz o interpretador pular
para a próxima iteração e obriga-o a testar a condição. Exemplo:

1. for (int i = -10; i<10; i++) {


2. if ( i == 0 )
3. continue;
4. System.out.println(i);
5. }
for (int i = -10; i<10; i++) {
if ( i == 0 )
continue;
System.out.println(i);
}

No exemplo, é impresso os valores de - 10 até 9 pulando o número zero.

Chegamos ao final de mais uma etapa. Na próxima veremos um pouco sobre Orientação
a Objetos.

• Java?

Home > Artigos > Java em Geral >

Tutorial Java 3: Orientação a Objetos


Publicado por Tutoriais Admin em 21/06/2010 - 205.712 visualizações

comentários: 4

Sugestão de Livro do JavaFree para os iniciantes em Java

5. Orientação a Objetos
Java é uma linguagem orientada a objetos e, com isso, não é possível desenvolver
nenhum programa sem seguir tal paradigma. Um sistema orientado a objetos é
composto por um conjunto de classes e objetos bem definidos que interagem entre si, de
modo a gerar o resultado esperado.

5.1 O que é?

O avanço das tecnologias na área de análise, projeto, desenvolvimento e qualidade de


software permite que aplicações mais flexíveis e poderosas sejam construídas. A
necessidade de integrar estas aplicações criou uma nova metodologia de análise e
desenvolvimento: a Orientação à Objetos.

A Orientação à Objetos modela o mundo real com classes e instâncias. Cada classe é a
estrutura de uma variável, ou seja, um tipo de dado. Nela, são declarados atributos e
métodos que poderão ser executados ou acessados nas instâncias da mesma classe. As
classes possuem uma função muito importante na modelagem orientada a objetos, elas
dividem o problema, modularizam a aplicação e baixam o nível de acoplamento do
software.

Variáveis de uma classe são chamadas de instâncias de classe. Por exemplo: Se existe
uma classe Pessoa existe a instância (variável) pessoa que é do tipo Pessoa. Um Objeto,
ou instância, é uma entidade cujas informações podem incluir desde suas características
até suas atividades, ou seja, uma abstração de um domínio de um problema.

Abaixo há uma série de definições sobre a arquitetura de orientação a objetos em Java.

• Pacote: Conjunto de classes e demais arquivos que possuem interesses comuns


ou atuam com dependências entre si. Fisicamente são pastas do sistema
operacional.
• Instância, objeto: Uma variável do tipo de uma classe.
• Construtor: Responsável por iniciar a criação e inicialização de uma instância de
classe.
• Método: Funções referenciados aquela classe.
• Modificador de acesso: Descreve que outras classes podem ter acesso a classe
que está se criando. Também é usado para indicar que uma classe pode ser
acessada de fora de seu pacote.
• Hierarquia de classes: Um grupo de classes que estão relacionadas por herança.
• Superclasse: É a classe que é estendida por uma determinada classe.
• Subclasse: É a classe que estende determinada classe.
• Classe base: A classe de determinada hierarquia que é uma superclasse de todas
as outras classes. A classe? pai de todas?

5.2 Criando a primeira classe

Nesta apostila já foram criadas várias classes demonstrando outras funcionalidades da


linguagem. Nos exemplos anteriores todo o código que continha um public class
declarava uma classe. Porém, os exemplos anteriores tinham propósitos de explicar cada
tópico, e portanto não faziam muito sentido. Neste exemplo, será construído uma classe
Pessoa, que manterá os dados e as ações relativas aos dados de pessoa.

1. public class Pessoa {


2. String nome;
3. Date nascimento;
4. double dinheiroNaCarteira;
5.
6. public Pessoa(String nome, Date nasc) {
7. this.nome = nome;
8. this.nascimento = nasc;
9. }
10.
11. public void gastar(double valor) {
12. dinheiroNaCarteira -= valor;
13. }
14.
15. public void receber(double valor) {
16. dinheiroNaCarteira += valor;
17. }
18. }

public class Pessoa {


String nome;
Date nascimento;
double dinheiroNaCarteira;

public Pessoa(String nome, Date nasc) {


this.nome = nome;
this.nascimento = nasc;
}

public void gastar(double valor) {


dinheiroNaCarteira -= valor;
}

public void receber(double valor) {

A classe pública Pessoa acima possui três variáveis, também chamados de atributos de
instância: nome, nascimento, dinheiroNaCarteira. Esses atributos serão criados a cada
nova instância de Pessoa que existir no sistema. Há, também, dois métodos: gastar
(double valor) e receber (double valor). Eles retiram e incluem dinheiro na carteira da
Pessoa respectivamente.

Entre eles existe a definição de um construtor: public Pessoa (String nome, Date nasc).
O construtor é um método sem retorno, invocado quando ocorre a criação de um
Objeto. Esta classe pessoa só pode ser criada passando dois parâmetros: o nome e a data
de nascimento. Se este método não existisse, o java criaria um construtor padrão, sem
parâmetros, para que a classe possa ser instanciada.

Algumas classes precisam evitar ser instanciadas, para ter essa proteção cria-se um
construtor privado que não recebe parâmetro e também não possui corpo. É construído
para evitar que o Java crie o construtor default.

Não é necessário definição de atributos, métodos ou construtores para que uma classe
possa ser compilada. A declaração abaixo é válida, o javac compila corretamente e
pode-se criá-la na aplicação, mesmo que sem nenhum método, construtor ou atributo:

public class NãoFazNada { }

O código abaixo usa a classe Pessoa como um exemplo de aplicação Orientada a


Objetos.

1. public class GerenciadorDePessoas {


2. public static void main(String args[]) {
3. // Cria uma classe que formata datas.
4. // É capaz de formatar de String para uma
5. // Date e de um Date para um String.
6. SimpleDateFormat formatador =
7. new SimpleDateFormat("dd/MM/yyyy");
8.
9. // Cria um Objeto de Pessoa.
10. Pessoa pVitor;
11. pVitor = new Pessoa("Vitor Fernando Pamplona",
12. formatador.parse("07/11/1983"));
13.
14. // Vitor Recebeu 1000 reais
15. // Inclui R$ 1000 na carteira da
16. // pessoa p criada na linha anterior
17. pVitor.receber(1000.00);
18.
19. // Cria um outro objeto de pessoa, o João
20. Pessoa pJoão = new Pessoa("João da Silva",
21. formatador.parse("18/02/1970"));
22.
23. // João recebeu R$ 500 e gastou R$ 100
24. pJoão.receber(500.00);
25. pJoão.gastar(100.00);
26. }
27. }
public class GerenciadorDePessoas {
public static void main(String args[]) {
// Cria uma classe que formata datas.
// É capaz de formatar de String para uma
// Date e de um Date para um String.
SimpleDateFormat formatador =
new SimpleDateFormat("dd/MM/yyyy");

// Cria um Objeto de Pessoa.


Pessoa pVitor;
pVitor = new Pessoa("Vitor Fernando Pamplona",
formatador.parse("07/11/1983"));

// Vitor Recebeu 1000 reais


// Inclui R$ 1000 na carteira da

Primeiramente é criado um formatador de datas para que se possa converter uma data
formatada em String em um tipo Date do Java. Este formatador é uma instância da
classe SimpleDateFormat e, como qualquer outra criação de objeto, usa o comando new
para criar uma instância.

Na linha seguinte, existe a declaração da variável pVitor que é da classe Pessoa. Esta
variável ainda não está criada, portanto o valor que ali se encontra é null. Após, é criado
a variável, ou melhor, a instância da classe Pessoa, com escopo do método. Esta
instância já é inicializada com o nome Vitor Fernando Pamplona e a data de nascimento
07 / 11 / 1983. Na linha abaixo é invocado o método receber da classe Pessoa passando
como parâmetro o double 1000.00.

5.3 Modificadores

Em Java existem uma série de palavras-chave que se comportam como modificadores


de classes, métodos e atributos. Alguns desses modificadores já foram usados nesta
apostila como a palavra-chave public, por exemplo. Um modificador pode ser utilizado
antes da palavra class, antes do retorno de um método ou antes da declaração de um
atributo.

Abaixo segue uma tabela com todos os modificadores de acesso do Java. A ordem de
declaração dos modificadores não importa.

1. Palavra-chave Em uma classe Em um m étodo Em um atributo


2.
3. public Acesso total Acesso total Acesso total.
4.
5. private Não aplicável Acesso pela classe Acesso pela classe
6.
7. protected Não aplicável Acesso pelo pacote Acesso pelo pacote
8.
9. default Somente pacote Acesso pelo pacote Acesso pelo pacote
10.
11. abstract Não instância Deve ser sobrescrito Não aplicável.
12.
13. final Sem herança Não pode ser sobrescrito CONSTANTE..
14.
15. static Não aplicável Acesso pela classe Acesso pela classe
16.
17. native Não aplicável Indica código nativo Não aplicável
18.
19. transient Não aplicável Não aplicável Cache
20.
21. synchonized Não aplicável Sem acesso simultâneo. Não aplicável

Palavra-chave Em uma classe Em um m étodo Em um atributo

public Acesso total Acesso total Acesso total.

private Não aplicável Acesso pela classe Acesso pela classe

protected Não aplicável Acesso pelo pacote Acesso pelo pacote

default Somente pacote Acesso pelo pacote Acesso pelo pacote

abstract Não instância Deve ser sobrescrito Não aplicável.

final Sem herança Não pode ser sobrescrito CONSTANTE..

static Não aplicável Acesso pela classe Acesso pela classe

5.4 Métodos

Um método em Java é uma sub-rotina semelhante as funções de C e Pascal. Os métodos


têm um retorno e podem conter parâmetros. A Sintaxe de um método é a seguinte:

1. [modif] <retorno> <nome> ([<tipo param>],[...]) {


2. <corpo do método>
3. }

[modif] <retorno> <nome> ([<tipo param>],[...]) {


<corpo do método>
}

Ao declarar um método é possível adicionar modificadores, vistos na seção anterior,


antes de informar o tipo de retorno. O modificador estático declara que o método terá
um determinado tipo de comportamento dentro do programa orientado a objetos. Na
declaração de um método os modificadores precedem o tipo de retorno, que precede o
nome do método e a lista de parâmetros. O corpo do método é colocado entre chaves.

Buscando o exemplo da classe pessoa:

1. //<modif> <ret> <nome> <parametro>


2. public void gastar(double valor) { // Corpo
3. dinheiroNaCarteira -= valor;
4. }

//<modif> <ret> <nome> <parametro>


public void gastar(double valor) { // Corpo
dinheiroNaCarteira -= valor;
}

O corpo do método pode conter declarações de variáveis e comandos. As variáveis não


ficam restritas a declaração somente antes dos comandos, como acontece em C ou em
um local pré-determinado como em Pascal, ao contrário, podem ser declaradas em
qualquer lugar. O tipo de retorno de um método pode ser primitivo ou de referência, ou
como no método main, pode ser void, ou seja, não retorna nada.

Em Java todos os argumentos são passados por valor. Não existe passagem por
referência. Se for variável primitiva o valor da variável é passada no parâmetro e pode
ser alterada a vontade dentro da função que nada sofrerá a variável externa. Com
objetos o que muda é que o valor passado no parâmetro da função é a referência para o
objeto, ou seja, se um objeto for alterado dentro da função, o objeto externo também
será alterado, exceto nas instruções objeto = null;

5.5 Interfaces

Interfaces foram concebidas para criar um modelo de implementação aumentando o


baixo acoplamento entre determinadas partes de um software. Uma interface não pode
possuir atributos de instância e nem métodos com implementação, mas pode possuir
atributos de estáticos (de classe) e cabeçalhos de métodos que deverão ser
desenvolvidos nas classes que implementarão a interface.

Muitas vezes as interfaces representam ações ou papéis para as classes. Um exemplo


comum de interface é a Serializable que se encontra dentro do pacote java.io e é muito
utilizada em aplicações corporativas. Quando uma classe implementa Serializable ela
não precisa implementar nenhum método definido na interface, mas com esta ação o
programador indica ao java que a classe pode ser serializada, transformada em um
conjunto de bits para serem armazenados ou transmitidos. A serialização de uma
instância armazena todos os seus dados e consegue criar um objeto semelhante na
desserialização.

O uso de interfaces é semelhante ao de classes como mostrado abaixo.

1. public interface Impressao {


2. public void imprimir();
3. }
4.
5. public class Pessoa implements Impressao {
6. private String nome;
7. ...
8. public void imprimir() {
9. Impressora imp = new Impressora("LPT1");
10. imp.print("Pessoa: " + nome);
11. ...
12. }
13. }
14.
15. public class Documento implements Impressao {
16. private String número;
17. ...
18. public void imprimir() {
19. Impressora imp = new Impressora("LPT1");
20. imp.print("Documento: " + número);
21. ...
22. }
23. }

public interface Impressao {


public void imprimir();
}

public class Pessoa implements Impressao {


private String nome;
...
public void imprimir() {
Impressora imp = new Impressora("LPT1");
imp.print("Pessoa: " + nome);
...
}
}

public class Documento implements Impressao {

No exemplo acima é possível identificar uma interface Impressão que é implementada


pela classe Pessoa e pela classe Documento. Essas duas classes foram obrigadas a
implementar o método public void imprimir () definido na interface. Se isso não
acontecesse o javac, o compilador do java, não permitiria a compilação das classes.
Para implementar uma interface, usa-se a palavra-chave implements seguida do nome
da interface, ou interfaces, visto que não há limite para quantidade de classes em
implementação.

É correto afirmar que as classes ganharam um papel, uma ação de impressão, e estão
aptas a executar todos os ítens necessários para realizar tal tarefa.

5.6 Abstract Class

Uma classe abstrata é quase uma interface, com a exceção que ela pode conter
implementações. Uma classe abstrata é usada para manter alguma programação nas
classes ? Pai ?, porém não pode ser instanciada. Para ser utilizada como instância, uma
classe abstrata deve ser estendida por uma classe não abstrata.

1. public abstract class Veículo{


2. private String nome;
3. private String marca;
4. private String modelo;
5.
6. // sets e gets
7.
8. public abstract void andar();
9. }
10.
11. public class Carro extends Veículo {
12. public void andar() {
13. acelerar();
14. }
15.
16. private void acelerar() {
17. ...
18. }
19. }
20.
21. public class Bicicleta extends Veículo {
22. public void andar() {
23. pedalar();
24. }
25.
26. private void pedalar() {
27. ....
28. }
29. }
public abstract class Veículo{
private String nome;
private String marca;
private String modelo;

// sets e gets

public abstract void andar();


}

public class Carro extends Veículo {


public void andar() {
acelerar();
}

Como é possível observar no exemplo acima, a classe Veículo não pode ser instanciada
por ser abstrata, e ela ganhou esta característica por conter métodos abstratos, no caso o
método andar (). Por este motivo, foram criadas duas classes estendendo Veículo: Carro
e Bicicleta. Ambas implementam a sua maneira de andar.

Para criar uma extensão de qualquer classe, usa-se a palavra-chave extends. O Java não
permite a herança múltipla, como em C, portanto não é possível estender de duas ou
mais classes. A solução deste problema é trabalhar com interfaces.

5.7 this e super

Estas duas palavras-chave da linguagem são aplicadas a métodos não estáticos, ou seja,
de instância. A this é utilizada para referenciar variáveis ou métodos da instância atual e
o super é utilizada para associar a métodos da classe ? pai ?. Por exemplo:

1. public class Pai {


2. public int lançar(int numero) {
3. return 6 \% numero;
4. }
5. }
6.
7. public class Filho extends Pai {
8. private int numero;
9. ...
10. public int lançar(int numero) {
11. if (numero == 0) {
12. return this.numero; // retorna o atributo da classe
13. }
14. super.lançar(numero); // Chave o lançar da classe pai.
15. }
16. }
public class Pai {
public int lançar(int numero) {
return 6 \% numero;
}
}

public class Filho extends Pai {


private int numero;
...
public int lançar(int numero) {
if (numero == 0) {
return this.numero; // retorna o atributo da classe
}
super.lançar(numero); // Chave o lançar da classe pai.
}

A classe Pai possui um método lançar retornando um inteiro. A classe filho, que estende
de Pai foi criada para tratar uma divisão por zero que poderá ocorrer na classe Pai.
Portanto, se for zero, retorna um número predefinido como atributo na classe Filho,
caso contrário retorna o resultado do cálculo da classe Pai. Este é um excelente exemplo
de polimorfismo e sobrescrita de métodos que veremos a seguir.

O Java associa automaticamente a todas as variáveis e métodos referenciados com a


palavra this. Por isso, na maioria dos casos torna-se redundante o uso em todas as
variáveis da palavra this. Existem casos em se faz necessário o uso da palavra this. Por
exemplo, você pode necessitar chamar apenas uma parte do método passando uma
instância do argumento do objeto. (Chamar um classe de forma localizada);

5.8 Sobrescrita e Sobrecarga

O Java permite que você tenha métodos com o mesmo nome, mas com assinaturas
diferentes, isto chama-se sobrecarga. O interpretador determinará qual método deve ser
invocado pelo tipo de parâmetro passado. Os trecho abaixo é válido para uma
compilação Java.

1. ...
2. public void print( int i ) { ... }
3. public void print( float f ) { ... }
4. public void print( String s) { ... }
5. ...
...
public void print( int i ) { ... }
public void print( float f ) { ... }
public void print( String s) { ... }
...

Quando você escreve o código para chamar um desses métodos, a chamada deverá
coincidir com tipos de dados da lista de parâmetros de algum dos métodos.

Diferente da sobrecarga, a sobrescrita acontece quando um método existe em uma


classe ? pai ? e é reescrito na classe ? filha ? para alterar o comportamento. A assinatura
do método deve ser igual na classe ? pai ? e na classe ? filha ?. Como um exemplo
abaixo está o código desenvolvido na seção this e super.

1. public class Pai {


2. public int lançar(int numero) {
3. return 6 \% numero;
4. }
5. }
6.
7. public class Filho extends Pai {
8. public int lançar(int numero) {
9. if (numero == 0) {
10. return this.numero; // retorna o atributo da classe
11. }
12. super.lançar(numero); // Chama o lançar da classe pai.
13. }
14. }
public class Pai {
public int lançar(int numero) {
return 6 \% numero;
}
}

public class Filho extends Pai {


public int lançar(int numero) {
if (numero == 0) {
return this.numero; // retorna o atributo da classe
}
super.lançar(numero); // Chama o lançar da classe pai.
}
}

O método public int lançar (int numero) existe na classe filha e na pai, o primeiro a ser
invocado é o Filho, e, via a palavra chave super, o interpretador chamará o método pai.
Caso não houver o comando super.lançar (numero); o método pai não seria invocado.

5.9 Cast ou conversão de Objetos

O cast ou a conversão de objetos em java é realizada de duas maneiras, de acordo com a


conversão de tipos primitivos: implícito e explícito. Primeiramente, toda a classe ?
filha ? pode ser associada a uma declaração de class ou interface ? pai ?. Esta é a forma
implícita, pois não necessita de nenhum recurso para ser efetuado, como no exemplo
abaixo:

1. ...
2. Pai objeto = new Filho();
3. ...

...
Pai objeto = new Filho();
...

No exemplo, o objeto filho é declarado como uma instância de Pai. O inverso deste caso
ocorre quando tem-se um objeto ? pai ? e sabe-se que ele é uma instância de
determinada classe ? filho ?. Esta forma é a explícita, pois é necessário informar ao
compilador, qual a classe que deseja-se fazer o cast.
1. ...
2. Pai objeto = new Filho();
3. ...
4. Filho objFilho = (Filho)objeto;
5. ...

...
Pai objeto = new Filho();
...
Filho objFilho = (Filho)objeto;
...

No exemplo, o objeto é declarado como sendo instância de Pai, mas é criado uma
instância de Filho. Na linha seguinte, é associado a uma variável declarada como Filho
o valor de objeto, que foi declarado como Pai mas é possível saber que ele é um Filho.

5.9.1 Operador instanceof

O operador instanceof é utilizado para casts explícitos que não se tem conhecimento da
classe real do objeto. Por exemplo:

1. ...
2. public void write(Collection c) {
3. if (c instanceof List)
4. write((List) c);
5. else
6. write((Set) c);
7. }
8. ...
...
public void w rite(Collection c) {
if (c instanceof List)
w rite((List) c);
else
w rite((Set) c);
}
...

No exemplo, a instância de Collection é testada para verificar se é um List ou um Set.


De acordo com o valor dela, é chamada uma função write usando sobrecarga de
métodos.
6 Tratamento de Exceções

As exceções em Java são classes que herdam de java.lang.Throwable. Basicamente


existem três tipos de exceções que são herdadas de Throwable:

• Error: Exceção grave que normalmente não pode ser tratado, como falhas físicas
e condições anormais de funcionamento.
• Exception: Exceções genéricas que devem ser tratadas utilizando declarações
throws ou criar o tratamento para a exceção com try catch.
• RuntimeException: São exceções que podem ser lançadas durante a execução da
JVM. Podem ser tratadas, porém não precisam ser tratadas com throws ou com
try catch

Em Java pode-se escolher onde se quer tratar a exceção. Se for para tratar no mesmo
método que ela ocorreu, usa-se a instrução:

1. try {
2. <comandos>
3. } catch (<Exceção>) {
4. <comandos>
5. } catch (<Outra Exceção>) {
6. <comandos>
7. } finally {
8. <comandos>
9. }
try {
<comandos>
} catch (<Exceção>) {
<comandos>
} catch (<Outra Exceção>) {
<comandos>
} finally {
<comandos>
}

A instrução try, como seu nome já fala, tenta executar um bloco de comandos. Ao
ocorrer qualquer erro a JVM passará o controle para um dos catch, o que mais se
apropriar para a exceção lançada.

Se a JVM não encontrar um catch apropriado e se houver uma cláusula finally ela é
executada, se não houver um finally o Java repassa a exceção para o método que
chamou este, e assim continua até que a exceção seja simplesmente lançada na tela para
o usuário.

6.1 Instrução throws

As classes que herdam de Exception precisam ser mapeadas como possibilidade de erro
no código Java. Quem controla essa obrigatoriedade é o compilador. Por exemplo, a
classe java.sql.SQLException é utilizada para tratamento nas exceções de SQL quanto
conecta-se a um banco de dados. Esta classe precisa ser obrigatoriamente testada, caso
contrário o programa não compila.

Para tratá-la pode-se usar a instrução try no mesmo método, porém, as vezes, é
necessário que essa execução seja tratada no método que chamou este. Neste caso,
coloca-se a instrução throws na assinatura do método afirmando para o compilador que
os métodos que chamarem este devem tratar SQLException obrigatoriamente.

1. ....
2. public void salvaObjeto(Cliente c) {
3. try {
4. abreTransação();
5. incluiNoBanco(c); // throws SQLException
6. commitTransação();
7. } catch (SQLException e) {
8. System.out.println("Erro ao salvar um cliente. " + e.getMessage());
9. }
10. }
....
public void salvaObjeto(Cliente c) {
try {
abreTransação();
incluiNoBanco(c); // throw s SQLException
commitTransação();
} catch (SQLException e) {
System.out.println("Erro ao salvar um cliente. " + e.getMessage());
}
}

1. public void incluiNoBanco(Cliente c) throws SQLException {


2. ...
3. banco.execute("INSERT INTO CLIENTE (....) values (....)");
4. ...
5. }

public void incluiNoBanco(Cliente c) throw s SQLException {


...
banco.execute("INSERT INTO CLIENTE (....) values (....)");
...
}

No exemplo, o compilador obriga que a função salvaObjeto trate a exceção


SQLException.

6.2 Lançando uma exceção

Para lançar uma exceção usa-se a instrução throw, diferente de throws visto na seção
anterior. No exemplo abaixo o parâmetro nome da função setNome necessita estar
preenchido e ser diferente de. Caso isso não aconteça é lançada uma exceção da classe
IllegalArgumentException. Como a java.lang.IllegalArgumentException herda de
RunTimeException ela não precisa ser tratada, mas se ocorrer aparecerá o erro para o
usuário.

1. public void setNome(String nome) {


2. if (nome == null || nome.equals("")) {
3. throw new IllegalArgumentException("Nome deve ser preenchido").
4. }
5. this.nome = nome;
6. }

public void setNome(String nome) {


if (nome == null || nome.equals("")) {
throw new IllegalArgumentException("Nome deve ser preenchido").
}
this.nome = nome;
}

É isso aí. Espero que tenham gostado do tutorial, pois deu um trabalhão para escrever
isso tudo! hehe. Se quiser continuar a aprender sobre java, leia os tutoriais para
certificação de SCJP do Kuesley nos links abaixo: Tutoriais para Certificação Java