c







Este capítulo apresenta as características básicas da linguagem, como identificadores, palavras chave, valores literais,
tipos de dados e operadores.

c







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:


 


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

c 







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.

c 






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 = > „nt
3. 0L = > long
4. 0 = > „nt

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

c  



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 = > iloat

2. 100.00d = > `ouble
3. 0 = > iloat
4. 0f = > iloat
5. 0d = > `ouble

c  c


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


- 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.

c  


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.


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

c  

!"

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. * m ort = 0;
3. * „nt = 0;
4. * long = 0;
5. * iloat = 0.0;
6. * `ouble = 0.0;
7. * boolean = ialme;
8. * Y ar = ` \ u0000 ';
9. * 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.

c c
#!

!

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. ubl„Y Ylamm Atribuição {

2. ubl„Y mtat„Y o„` main (String [] args) {
3. „nt x = 1;
4. „nt y = 5;
5. }
6. }

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

c 
$


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

1. „nt x = 1; // literal inteiro

2. Y ar u = 'a'; // literal char
3. boolean b = true; // literal boolean
4. `ouble 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. „nt x = 01;

2. „nt x = 0931;
3. „nt x = 021;

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

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

2. „nt vinte_e_nove = 0x1D; // 29 (decimal)
3. „nt vinte_e_nove = 0x1D; // 29 (decimal)
4. „nt valor = 0xBAFAFA; // 12253946 (decimal)
5. „nt 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. Y ar a = 'A'; // letra A

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








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. „nt y = 10;

2. nbsp; 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; „nt x = („nt) 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;

c '
(!




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.

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.

c )
(!




*+


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. „nmtanYeoi Verif Instância x „nmtanYeoi X x é instância da classe X

c ,
(!

-


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.

c .
(
!
!


/"
 

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. ubl„Y Ylamm OperadorAtribuicaoComposto {

2. ubl„Y mtat„Y o„` main (String [] args) {
3. „nt x = 1;
4. x + = 5;
5. }
6. }

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. ubl„Y Ylamm OperadorAtribuicaoComposto {

2. ubl„Y mtat„Y o„` main (String [] args) {
3. „nt 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. }
c
!0

!
!

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. <>< = > = „nmtanYeoi
6. = =! =
7. &
8. ^
9. |
10.&&
11.| |
12.?:
13.= * = / = % = + = - = << = >> = >>> = & = | =


!
!
!
"

/"

! 


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];

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. ubl„Y Ylamm DeclarandoVariáveis {

2. „nt atributo = 9; // Declarando uma variável global => Atributo.
3.
4. ubl„Y o„` main(String[] args) {
5. byte bt; // Declaração simples
6. m ort sht1, sht2, sht3; // Declaração múltipla
7. „nt i = 9; // Declaração e inicialização
8. iloat 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. }

 
# /&
!
1 


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.

 
!2



O comando if executa um trecho de código apenas uma vez, dependendo de sua condição. A sintaxe segue a sintaxe
abaixo.

1. „i ( <condição> ) {
2. <comandos>
3. } elme {
4. <comandos>
5. }

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. ubl„Y Ylamm ExemploIf {

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

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.

  
!2
-


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. m
„tY ( <expressão> ) {

2. Yame <valor1>:<comandos 1>
3. [break;]
4. Yame <valor2>:<comandos 2>
5. [break;]
6. Yame <valor3>:<comandos 3>
7. [break;]
8. Yame <valor4>:<comandos 4>
9. [break;]
10. ...
11. `eiault: <comandos `eiault>
12.}

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. ubl„Y Ylamm ExemploSwitch {

2. ubl„Y mtat„Y o„` main(String[] args) {
3. „nt i = 2;
4. // Switch que irá imprimir na tela o valor 2
5. m
„tY (i) {
6. Yame 1 : System.out.println("Valor de i é 1");
7. break;
8. Yame 2 : System.out.println("Valor de i é 2");
9. break;
10. Yame 3 : System.out.println("Valor de i é 3");
11. break;
12. `eiault: System.out.println("Default");
13. }
14.
15. // Switch que irá imprimir na tela o valor "Vitor"
16. String nome = "Vitor";
17. m
„tY (nome.hashcode()) {
18. Yame "Vitor".hashCode() : System.out.println("Valor de nome é Vitor");
19. break;
20. Yame "Paulo".hashCode() : System.out.println("Valor de nome é Paulo");
21. break;
22. `eiault: System.out.println("Default");
23. }
24. }
25.}

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.

  c
!2
+

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.

  c
$/

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.

 c
!2


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. ior (<expressão inicial>; <condição>; <incremento>) {

2. <comandos>
3. }

Exemplos:

1. ubl„Y Ylamm ExemploFor {

2. ubl„Y mtat„Y o„` main(String[] args) {
3. ior („nt i=0; i<10; i++) {
4. System.out.println("Contador é " + i);
5. }
6.
7. ior (;;) {
8. System.out.println("Laço infinito.");
9. }
10. }
11.}

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.

 c 
!2
-


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.
„le (<condição>) {

2. <comandos>
3. }

Exemplos:

1. ubl„Y Ylamm ExemploWhile {

2. ubl„Y mtat„Y o„` main(String[] args) {
3. „nt i=0;
 4.
„le(i++<10) {
5. System.out.println("Contador é " + i);
6. }
7.
8.
„le(true) {
9. System.out.println("Laço infinito.");
10. }
11. }
12.}

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.

 c c
!2
!
-


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. `o {
2. <comandos>
3. }
„le (<condição>);

Exemplos:

1. ubl„Y Ylamm ExemploDoWhile {

2. ubl„Y mtat„Y o„` main(String[] args) {
3. „nt i=0;
4. `o {
5. System.out.println("Contador é " + i);
6. }
„le(++i<10)
7.
8. `o {
9. System.out.println("Laço infinito.");
10. }
„le(true);
11. }
12.}

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.

 
! 2
3




É 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. „nt i = 0;
2.
„le (true) {
3. System.out.println(i);
4. „i ( i++ >= 10 )
5. break;
6. }
 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. ior („nt i = -10; i<10; i++) {

2. „i ( i == 0 )
3. Yont„nue;
4. System.out.println(i);
5. }

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


(
/"

(4

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
6

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?

 

!




 

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. ubl„Y Ylamm Pessoa {

2. String nome;
3. Date nascimento;
4. `ouble dinheiroNaCarteira;
5.
6. ubl„Y Pessoa(String nome, Date nasc) {
7. t „m.nome = nome;
8. t „m.nascimento = nasc;
9. }
10.
11. ubl„Y o„` gastar(`ouble valor) {
12. dinheiroNaCarteira -= valor;
13. }
14.
15. ubl„Y o„` receber(`ouble valor) {
16. dinheiroNaCarteira += valor;
17. }
18.}

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. ubl„Y Ylamm GerenciadorDePessoas {

2. ubl„Y mtat„Y o„` 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. ne
SimpleDateFormat("dd/MM/yyyy");
8.
9. // Cria um Objeto de Pessoa.
10. Pessoa pVitor;
11. pVitor = ne
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 = ne
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.}

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.

 c
7!

!

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. ubl„Y Acesso total Acesso total Acesso total.
4.
5. r„ ate Não aplicável Acesso pela classe Acesso pela classe
6.
7. roteYte` Não aplicável Acesso pelo pacote Acesso pelo pacote
8.
9. `eiault Somente pacote Acesso pelo pacote Acesso pelo pacote
10.
11.abmtraYt Não instância Deve ser sobrescrito Não aplicável.
12.
13.i„nal Sem herança Não pode ser sobrescrito CONSTANTE..
14.
15.mtat„Y Não aplicável Acesso pela classe Acesso pela classe
16.
17.nat„ e Não aplicável Indica código nativo Não aplicável
18.
19.tranm„ent Não aplicável Não aplicável Cache
20.
21.synchonized Não aplicável Sem acesso simultâneo. Não aplicável

 
7!

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 `o método>
3. }

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. ubl„Y o„` gastar(`ouble valor) { // Corpo
3. dinheiroNaCarteira -= valor;
4. }

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;

 
#

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. ubl„Y „nteriaYe Impressao {

2. ubl„Y o„` imprimir();
3. }
4.
5. ubl„Y Ylamm Pessoa „leentm Impressao {
6. r„ ate String nome;
7. ...
8. ubl„Y o„` imprimir() {
9. Impressora imp = ne
Impressora("LPT1");
10. imp.print("Pessoa: " + nome);
11. ...
12. }
13.}
14.
15.ubl„Y Ylamm Documento „leentm Impressao {
16. r„ ate String número;
17. ...
18. ubl„Y o„` imprimir() {
19. Impressora imp = ne
Impressora("LPT1");
20. imp.print("Documento: " + número);
21. ...
22. }
23.}

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.


 %
8 


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 n i stanciada. Para ser utilizada
como instância, uma classe abstrata deve ser estendida por uma classe não abstrata.

1. ubl„Y abmtraYt Ylamm Veículo{

2. r„ ate String nome;
3. r„ ate String marca;
4. r„ ate String modelo;
5.
6. // sets e gets
7.
8. ubl„Y abmtraYt o„` andar();
9. }
10.
11.ubl„Y Ylamm Carro exten`m Veículo {
12. ubl„Y o„` andar() {
13. acelerar();
14. }
15.
16. r„ ate o„` acelerar() {
17. ...
18. }
19.}
20.
21.ubl„Y Ylamm Bicicleta exten`m Veículo {
22. ubl„Y o„` andar() {
23. pedalar();
24. }
25.
26. r„ ate o„` pedalar() {
27. ....
28. }
29.}

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.

 '





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. ubl„Y Ylamm Pai {

2. ubl„Y „nt lançar(„nt numero) {
3. return 6 \% numero;
4. }
5. }
6.
 7. ubl„Y Ylamm Filho exten`m Pai {
8. r„ ate „nt numero;
9. ...
10. ubl„Y „nt lançar(„nt numero) {
11. „i (numero == 0) {
12. return t „m.numero; // retorna o atributo da classe
13. }
14. muer.lançar(numero); // Chave o lançar da classe pai.
15. }
16.}

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);

 )
9 


9+

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. ubl„Y o„` print( „nt i ) { ... }
3. ubl„Y o„` print( iloat f ) { ... }
4. ubl„Y o„` print( String s) { ... }
5. ...

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. ubl„Y Ylamm Pai {

2. ubl„Y „nt lançar(„nt numero) {
3. return 6 \% numero;
4. }
5. }
6.
7. ubl„Y Ylamm Filho exten`m Pai {
8. ubl„Y „nt lançar(„nt numero) {
9. „i (numero == 0) {
10. return t „m.numero; // retorna o atributo da classe
11. }
12. muer.lançar(numero); // Chama o lançar da classe pai.
13. }
14.}

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.

  ,
 

 "
!
(4

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 = ne
Filho();
3. ...

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 = ne
Filho();
3. ...
4. Filho objFilho = (Filho)objeto;
5. ...

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.

 ,
(!

 

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

1. ...
2. ubl„Y o„` write(Collection c) {
3. „i (c „nmtanYeoi List)
4. write((List) c);
5. elme
6. write((Set) c);
7. }
8. ...

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. } YatY (<Exceção>) {
4. <comandos>
5. } YatY (<Outra Exceção>) {
6. <comandos>
7. } i„nally {
8. <comandos>
9. }

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.

%
# /"
-

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. ubl„Y o„` salvaObjeto(Cliente c) {
3. try {
4. abreTransação();
5. incluiNoBanco(c); // throws SQLException
6. commitTransação();
7. } YatY (SQLException e) {
8. System.out.println("Erro ao salvar um cliente. " + e.getMessage());
9. }
10.}

1. ubl„Y o„` incluiNoBanco(Cliente c) t ro
m SQLException {

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

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

% 
$/!

:/"

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. ubl„Y o„` setNome(String nome) {

2. „i (nome == null || nome.equals("")) {
3. t ro
ne
IllegalArgumentException("Nome deve ser preenchido").
4. }
5. t „m.nome = nome;
6. }
 a a
##(9
189
8;$89

a a##(
1(
($;7a

public static void main(String[] args) {

// TODO code application logic here

int comprimento;

int largura;

int altura;

Scanner teclado = new Scanner(System.in);

System.out.println("digite um comprimento");

comprimento = teclado.nextInt();

System.out.println("digite uma largura");

largura = teclado.nextInt();

System.out.println("digite uma altura");

altura = teclado.nextInt();

int volume;

volume = comprimento * largura * altura ;

System.out.println("volume = " + volume + " metros");

a a
##(
18
a7a
8;
8

public static void main(String[] args) {

// TODO code application logic here

Scanner teclado = new Scanner(System.in);

System.out.println("Digite uma temperatura");

int n;

n = teclado.nextInt();

if (n> 30) {System.out.println("calor");}

else if (n>22) {System.out.println("moderado");}

else if (n>=10) {System.out.println("frio");}

if (n <10){System.out.println("muito frio");}

}
 8

(;
#78

public static void main(String[] args) {

Scanner teclado = new Scanner (System.in);

System.out.println(" introduza o numero");

int n = teclado.nextInt();

if (n%2 == 0)

System.out.println("o valor " + n + " é par");

else

System.out.println("o valor " + n + " é impar");

9(78(
#(
78#9
(8

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);

// somar enquento os preços são positivos

//um preço <=0 indica o fim da lista de produto

int soma = 0;

int conta = 0;

System.out.println(" digite o preço do novo produto ");

int preco = teclado.nextInt();

while (preco > 0) {

soma = soma + preco;

conta = conta + 1;

System.out.println(" soma parcial = " + soma);

System.out.println("digite novo produto");

preco = teclado.nextInt(); }

System.out.println(" total = " + soma + " de " + conta + " produtos");

 8

(;
#78

(9## (
a
a8# (

public static void main(String[] args) {

// TODO code application logic here

Scanner teclado = new Scanner(System.in);

System.out.println(" introduza o numero");

int n = teclado.nextInt();

if (n > 0) {

System.out.println("o valor " + n + " é positivo");

if (n % 2 == 0) { System.out.println("o valor " + n + " é par"); }

else { System.out.println("o valor " + n + " é impar"); }

else if (n == 0) {System.out.println("o valor " + n + " é nulo");}

else {// (n < 0);

System.out.println("o valor é negativo");}




:



!
+
!


.

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);

int max = 0;

int x = 0;

System.out.println(" digite um numero ");

x = teclado.nextInt();

while (x > 0) {

if (max < x) {

max = x ; }

System.out.println("Digite um novo numero");

x = teclado.nextInt(); }

System.out.println("o valor maximo digitado = " + max);

}
 



+



!
+
!


.

public static void main(String[] args)

Scanner teclado = new Scanner(System.in);

// criar um array de 6 inteiros - chave

int[] chave = new int[6];

// preencher a chave com numeros aleatorios

for (int i = 0; i < chave.length; i++) {

chave[i] = (int) (Math.random() * 49) + 1; }

// criar opcao

int opcao = -1;

do {

// imprimir o menu

System.out.println(" 0 -Sair");

System.out.println(" 1 -Adivinhar");

System.out.println("opcao -> ");

// ler a opcao

opcao = teclado.nextInt();

switch (opcao) {

case 0:

System.out.println("Sair");

break;

case 1: {

System.out.println("Adivinhar seis numeros inteiros diferentes");

// criar um array de 6 inteiros -a

int[] a = new int[6];

// para i = 0 ; i < 6 ; i++ faz

for (int i = 0; i < a.length; i++) {

// ler a[i]

a[i] = teclado.nextInt();

// pesquisar a[i] na chave do totoloto

boolean encontrou = false;

 for (int j = 0; j < chave.length; j++) {

if (a[i] == chave[j]) {

encontrou = true;

if (encontrou) {System.out.println(" Encontrou " + a[i] + " na chave do totoloto ");

} else {System.out.println(" Nao encontrou " + a[i] + " na chave do totoloto ");

break;

default:

System.out.println("Digite uma opcao entre 0 e 1");

break; }

} while (opcao != 0);

// imprimir a chave (for ...)

System.out.println("A chave e ");

for (int i = 0; i < chave.length; i++) {

System.out.println(" " + chave[i]);








!

!





public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);

int soma = 0;

int conta = 0;

int media = 0;

System.out.println(" digite um numero ");

int x = teclado.nextInt();

while (x > 0) {

if (x % 2 == 0) {
 soma = soma + x;

conta = conta + 1; }

System.out.println(" soma parcial = " + soma);

System.out.println("digite novo numero");

x = teclado.nextInt(); }

media = soma / conta;

System.out.println(" Somatorio = "

+ soma + " de " + conta + " contagem = " + " e media =" + media);

(($((

public static void main(String[] args)

Scanner teclado = new Scanner(System.in);

// criar um array de 6 inteiros - chave

int[] chave = new int[6];

// preencher a chave com numeros aleatorios

for (int i = 0; i < chave.length; i++) {

chave[i] = (int) (Math.random() * 49) + 1; }

// criar opcao

int opcao = -1;

do {

// imprimir o menu

System.out.println(" 0 -Sair");

System.out.println(" 1 -Adivinhar");

System.out.println("opcao -> ");

// ler a opcao

opcao = teclado.nextInt();

switch (opcao) {

case 0:

System.out.println("Sair");

break;
 case 1: {

System.out.println("Adivinhar seis numeros inteiros diferentes");

// criar um array de 6 inteiros -a

int[] a = new int[6];

// para i = 0 ; i < 6 ; i++ faz

for (int i = 0; i < a.length; i++) {

// ler a[i]

a[i] = teclado.nextInt();

// pesquisar a[i] na chave do totoloto

boolean encontrou = false;

for (int j = 0; j < chave.length; j++) {

if (a[i] == chave[j]) {

encontrou = true;

if (encontrou) {

System.out.println(" Encontrou " + a[i] + " na chave do totoloto ");}

else {

System.out.println(" Nao encontrou " + a[i] + " na chave do totoloto "); }

break;

default:

System.out.println("Digite uma opcao entre 0 e 1");

break; }

while (opcao != 0);

// imprimir a chave (for ...)

System.out.println("A chave e ");

for (int i = 0; i < chave.length; i++) {

System.out.println(" " + chave[i]); }