Aula3

1.061 visualizações

Publicada em

Curso de Programação OO com Java no IBTA

Publicada em: Tecnologia
0 comentários
1 gostou
Estatísticas
Notas
  • Seja o primeiro a comentar

Sem downloads
Visualizações
Visualizações totais
1.061
No SlideShare
0
A partir de incorporações
0
Número de incorporações
7
Ações
Compartilhamentos
0
Downloads
0
Comentários
0
Gostaram
1
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Aula3

  1. 1. Programação Orientada a Objetos com Java Aula 3 professor: Fábio Kimura e-mail: fkimura@yahoo.com
  2. 2. <ul><li>Agenda </li></ul><ul><li>Operadores e expressões </li></ul><ul><li>Estruturas de Decisão </li></ul><ul><li>Estruturas de Repetição </li></ul><ul><li>Comentários de código </li></ul><ul><li>Exercícios </li></ul><ul><li>Trabalho valendo nota </li></ul>
  3. 3. <ul><li>Operadores e Expressões </li></ul><ul><li>Operadores nos permitem fazer cálculos ou comparações em etapas. </li></ul><ul><li>Expressões permitem executar tarefas computacionais compostas de funções e operadores </li></ul><ul><li>Operadores </li></ul>
  4. 4. <ul><li>Operadores Aritméticos </li></ul><ul><li>soma (+); </li></ul><ul><li>subtração (-); </li></ul><ul><li>multiplicação (*); </li></ul><ul><li>divisão (/); </li></ul><ul><li>resto da divisão (%); </li></ul><ul><li>incremento (++), operador unário definido apenas para operandos inteiros, podendo ocorrer antes da variável (pré-incremento) ou após a variável (pós-incremento); </li></ul><ul><li>decremento (--), operador unário definido apenas para operandos inteiros, podendo ocorrer antes da variável (pré-decremento) ou após a variável (pós-decremento). </li></ul><ul><li>Operadores </li></ul>
  5. 5. <ul><li>Exemplos </li></ul><ul><li>public static void main(String[] args) { </li></ul><ul><li>int x = 0; </li></ul><ul><li>System.out.println(x++); </li></ul><ul><li>System.out.println(++x); </li></ul><ul><li>} </li></ul><ul><li>Operadores </li></ul><ul><li>public static void main(String[] args) { </li></ul><ul><li>int x = 0; </li></ul><ul><li>int y = 2/x; </li></ul><ul><li>} </li></ul><ul><li>public static void main(String[] args) { </li></ul><ul><li>double x = 0; </li></ul><ul><li>double y = 2/x; </li></ul><ul><li>System.out.println(y); </li></ul><ul><li>} </li></ul>
  6. 6. <ul><li>Operadores Lógicos </li></ul><ul><li>complemento (~), operador unário que reverte os valores dos bits na representação interna; </li></ul><ul><li>OR bit-a-bit (|), operador binário que resulta em um bit 1 se pelo menos um dos bits na posição era 1; </li></ul><ul><li>AND bit-a-bit (&), operador binário que resulta em um bit 0 se pelo menos um dos bits na posição era 0; </li></ul><ul><li>XOR bit-a-bit (^), operador binário que resulta em um bit 1 se os bits na posição eram diferentes; </li></ul><ul><li>Operadores </li></ul>
  7. 7. <ul><li>Operadores Condicionais </li></ul><ul><li>E lógico ( && ), retorna true se as duas expressões booleanas forem verdadeiras; </li></ul><ul><li>OU lógico ( || ), retorna true se uma das duas expressões forem verdadeiras; </li></ul><ul><li>maior (>), retorna true se o primeiro valor for exclusivamente maior que o segundo; </li></ul><ul><li>maior ou igual (>=), retorna true se o primeiro valor for maior que ou igual ao segundo; </li></ul><ul><li>Operadores </li></ul>
  8. 8. <ul><li>Operadores Condicionais </li></ul><ul><li>menor (<), retorna true se o primeiro valor for exclusivamente menor que o segundo; </li></ul><ul><li>menor ou igual (<=), retorna true se o primeiro valor for menor que ou igual ao segundo; </li></ul><ul><li>igual (==), retorna true se o primeiro valor for igual ao segundo; </li></ul><ul><li>diferente (!=), retorna true se o primeiro valor não for igual ao segundo. </li></ul><ul><li>Operadores </li></ul>
  9. 9. <ul><li>Precedência de Operadores </li></ul><ul><li>Regras de precedência: </li></ul><ul><ul><li>1. Operações entre parênteses; </li></ul></ul><ul><ul><li>2. Incremento e Decremento; </li></ul></ul><ul><ul><li>3. Multiplicação e divisão, executados da esquerda para a direita; </li></ul></ul><ul><ul><li>4. Adição e subtração, executados da esquerda para a direita; </li></ul></ul><ul><li>Operadores </li></ul>
  10. 10. <ul><li>Operadores de Atribuição </li></ul><ul><li>Atribuição: = </li></ul><ul><li>Atribuição composta: +=, -=, *-, /= </li></ul><ul><li>Operadores </li></ul><ul><li>public static void main(String[] args) { </li></ul><ul><li>int x = 1 + 1; </li></ul><ul><li>x += 10; </li></ul><ul><li>x -= 2; </li></ul><ul><li>x /= 2; </li></ul><ul><li>x *= 3; </li></ul><ul><li>System.out.println(“x=“ + x); </li></ul><ul><li>} </li></ul>
  11. 11. <ul><li>Exemplos: </li></ul><ul><li>Operadores </li></ul><ul><li>public static void main(String[] args) { </li></ul><ul><li>int x = 2; </li></ul><ul><li>x *= 2 + 1; </li></ul><ul><li>System.out.println(“x=“ + x); </li></ul><ul><li>} </li></ul><ul><li>public static void main(String[] args) { </li></ul><ul><li>short s = 1; </li></ul><ul><li>s++; </li></ul><ul><li>s += 5; </li></ul><ul><li>s = s + 5; </li></ul><ul><li>System.out.println(“s=“ + s); </li></ul><ul><li>} </li></ul>
  12. 12. Um problema simples – imprimir os números da Sena!   public class Sena {   public static void main(String args[]) { System.out.println(&quot;1,2,3,4,5,6,7,8,9,10,16..,60&quot;); } } Será que não tem uma forma mais fácil? <ul><li>Estruturas de Repetição </li></ul>
  13. 13. <ul><li>Execução de tarefas ou funções repetidas: </li></ul><ul><ul><li>1. Facilitar a codificação; </li></ul></ul><ul><ul><li>2. Permitir a computação de iterações; </li></ul></ul><ul><li>Estruturas: </li></ul><ul><ul><li>while – ( enquanto – faça ) </li></ul></ul><ul><ul><li>do ... while – ( faça – enquanto) </li></ul></ul><ul><ul><li>for – ( para cada – faça ) </li></ul></ul><ul><li>Todas são “keywords” </li></ul><ul><li>Estruturas de Repetição </li></ul>
  14. 14. while – projetado para: testar uma condição inicial; executar um bloco de código dentro do laço; <ul><li>Estruturas de Repetição - while </li></ul>
  15. 15. sintaxe: while (condicao booleana) { /* bloco de código que será repetido até que a condição booleana seja false */ } <ul><li>Estruturas de Repetição - while </li></ul>
  16. 16. sintaxe: while (condicao booleana) // linha de código que será repetida até que a condição booleana seja false <ul><li>Estruturas de Repetição - while </li></ul>
  17. 17. Um problema simples – imprimir os números da Sena! Mais fácil? Mais Difícil?   public class Sena {   public static void main(String args[]) { System.out.println(&quot;Números da Sena&quot;); int i=1; while(i <= 60) { System.out.print(i+&quot;,&quot;); i++; } System.out.println(); }  } <ul><li>Estruturas de Repetição - while </li></ul>
  18. 18. Um problema simples – imprimir os números da Sena! Mais fácil? Mais Difícil?   public class Sena {   public static void main(String args[]) { System.out.println(&quot;Números da Sena&quot;); int i=1; while(i <= 60) { System.out.print(i+&quot;,&quot;); i++; } System.out.println(); }  } <ul><li>Estruturas de Repetição - while </li></ul>“ Execute o que estiver compreendido no bloco de código do while enquanto i seja menor ou igual a 60 ”.
  19. 19. do .. while – projetado para: executar um bloco de código dentro do laço; testar uma condição no fim do laço; <ul><li>Estruturas de Repetição - do .. while </li></ul>
  20. 20. sintaxe: do { /* bloco de código que será repetido até que a condição booleana seja false */ } while ( condicao booleana ); <ul><li>Estruturas de Repetição - do .. while </li></ul>do // linha de código que será repetida até que a condição booleana seja false while ( condicao booleana );
  21. 21. Um problema simples – imprimir os números da Sena! Mais fácil? Mais Difícil? public class Sena {   public static void main(String args[]) { System.out.println(&quot;Números da Sena&quot;); int i=1; do { System.out.print(i+&quot;,&quot;); i++; } while(i < 60); System.out.println(); }  } <ul><li>Estruturas de Repetição - do .. while </li></ul>
  22. 22. public class Sena {   public static void main(String args[]) { System.out.println(&quot;Números da Sena&quot;); int i=1; do { System.out.print(i+&quot;,&quot;); i++; } while(i < 60); System.out.println(); }  } <ul><li>Estruturas de Repetição - do .. while </li></ul>Entendendo com funciona! “ Execute o que estiver compreendido no bloco de código do while enquanto i seja menor ou igual a 60 ”.
  23. 23. for – projetado para: testar uma condição inicial; executar uma declaração; executar um bloco de código dentro do laço; e no fim de uma repetição, executar uma expressão. <ul><li>Estruturas de Repetição - for </li></ul>
  24. 24. sintaxe: for ( [declaração] ; [condição booleana] ; [expressão] ) { /* bloco de código que será repetido até que a condição booleana seja false antes da execução iniciar o próximo laço a expressão será executada. */ } <ul><li>Estruturas de Repetição - for </li></ul>for ( [declaração] ; [condição booleana] ; [expressão] ) // linha de código que será repetida até que a condição seja false
  25. 25. Um problema simples – imprimir os números da Sena! Mais fácil? Mais Difícil?   public class Sena {   public static void main(String args[]) { System.out.println(&quot;Números da Sena&quot;); for ( int i=1; i <= 60; i++ ) { System.out.print(i+&quot;,&quot;); } System.out.println(); }   } <ul><li>Estruturas de Repetição - for </li></ul>
  26. 26.   public class Sena {   public static void main(String args[]) { System.out.println(&quot;Números da Sena&quot;); for ( int i=1; i <= 60; i++ ) { System.out.print(i+&quot;,&quot;); } System.out.println(); }   } “ Execute o que estiver compreendido no bloco de código do for até que o i seja menor ou igual a 60 , e antes de começar o próximo laço, incremente 1 em i ”. Entendendo com funciona! <ul><li>Estruturas de Repetição - for </li></ul>
  27. 27. <ul><li>Exercício </li></ul><ul><li>Crie uma classe Numeros.java que possui 3 métodos: </li></ul><ul><li>imprimirSequencia() : </li></ul><ul><li>Imprime todos os números de 150 a 300. </li></ul><ul><li>imprimirSoma() : </li></ul><ul><li>Imprime a soma de 1 até 1000. </li></ul><ul><li>imprimirMultiplos() : </li></ul><ul><li>Imprime todos os múltiplos de 3, entre 1 e 100. </li></ul><ul><li>Crie uma classe TesteNumeros.java que invoca os 3 métodos da classe acima. </li></ul>
  28. 28. <ul><li>Execução de testes condicionais para: </li></ul><ul><ul><li>Implementar a tomada de decisões; </li></ul></ul><ul><ul><li>Permitir a construção de algoritmos de escolha; </li></ul></ul><ul><li>Estruturas: </li></ul><ul><ul><li>if/else – (se) </li></ul></ul><ul><ul><li>switch/case – (escolha para) </li></ul></ul><ul><li>Todas são “keywords” </li></ul><ul><li>Estruturas de Decisão </li></ul>
  29. 29. <ul><li>Estruturas de Decisão - Representação </li></ul>
  30. 30. <ul><li>Estruturas de Decisão - Representação </li></ul>
  31. 31. if – projetado para comparar: expressões, variáveis e condições booleanas e decidir o fluxo da execução; <ul><li>Estruturas de Decisão - if </li></ul>
  32. 32. sintaxe: if ( expressão booleana ) { /* bloco de código que será executado se a expressão booleana valer true. */ } [else { /* bloco de código que será executado se a expressão booleana valer false. */ }] <ul><li>Estruturas de Decisão - if </li></ul>
  33. 33. sintaxe: if ( expressão booleana ) // linha de código que será executada se a expressão booleana valer true. else // linha de código que será executada se a expressão booleana valer false. <ul><li>Estruturas de Decisão - if </li></ul>
  34. 34. sintaxe: if ( expressão booleana ) { /* bloco de código que será executado se a expressão booleana valer true. */ } else if ( expressão booleana2) { /* bloco de código que será executado se a expressão booleana2 valer true. */ } else { /* bloco de código que será executado se a expressão booleana e a expressao booleana2 valerem false. */ } <ul><li>Estruturas de Decisão - if </li></ul>
  35. 35. Um problema simples – comparar idades! Mais fácil? Mais Difícil? if ( idade >= 0 && idade < 16 ) { /* executara este bloco de codigo se a idade for maior ou igual a zero E a idade for menor que 16 */ } else if ( idade >= 17 && idade < 18 ) { /* executara este bloco de codigo se a idade for maior ou igual a 17 E a idade for menor que 18 */ } else { /* executara este bloco de código se a idade for maior ou igual a 18 */ } <ul><li>Estruturas de Decisão </li></ul>
  36. 36. Um problema simples – comparar valores! Mais fácil? Mais Difícil? if ( x == 0 || y == 0 ) { /* executara este bloco de código se x OU y forem igual a zero */ } else { /* executará este bloco de código se x E y forem diferentes de zero */ } <ul><li>Estruturas de Decisão </li></ul>
  37. 37. <ul><li>Operadores SHORT-CIRCUIT </li></ul>Os operadores lógicos OR ( || ) e AND ( && ) São usados para testar condições compostas facilitando a construção da estrutura if/else e são chamados de SHORT-CIRCUIT <ul><li>Estruturas de Decisão – Operadores short-circuit </li></ul>
  38. 38. switch – projetado para: tratamento de casos específicos; a partir de um único teste, é escolhido um ponto de entrada nas opções; usamos o break para interromper sua execução; <ul><li>Estruturas de Decisão – switch </li></ul>
  39. 39. sintaxe: switch ( variavel ) { case (inteiro): // caso o valor da variavel seja igual // ao do inteiro, inicia aqui case (inteiro): // caso o valor da variavel seja igual // ao do inteiro, inicia aqui default: // caso não seja nenhum acima, inicia aqui } <ul><li>Estruturas de Decisão – switch </li></ul>
  40. 40. sintaxe: switch ( variavel ) { case (inteiro): // caso o valor da variável seja igual // ao do inteiro, inicia aqui break; // para aqui. case (inteiro): // caso o valor da variável seja igual // ao do inteiro, inicia aqui } <ul><li>Estruturas de Decisão – switch </li></ul>
  41. 41. Um problema simples – comparar valores! int x = VALOR; switch ( x ) { case 1: // código A case 10: // código B case 100: // código C default: // código D } quando x = 1, linhas executadas: A,B,C e D; quando x = 10, linhas executadas: B,C e D; quando x = 100, linhas executadas: C e D; qualquer valor de x, diferente de 1, 10 e 100, D. <ul><li>Estruturas de Decisão – switch </li></ul>
  42. 42. Um problema simples – comparar valores! int x = VALOR; switch ( x ) { case 1: // código A break; case 10: // código B case 100: // código C break; default: // código D } quando x = 1, linhas executadas: A; quando x = 10, linhas executadas: B e C; quando x = 100, linhas executadas: C; qualquer valor de x, diferente de 1, 10 e 100, D. <ul><li>Estruturas de Decisão – switch </li></ul>
  43. 43. <ul><li>Exercícios </li></ul>Crie uma classe Fatorial que possui um método: public int calcular(int n) { ... } Que calcule e imprima o fatorial de um int n. O fatorial de um número n é n * (n - 1) * (n – 2) ... até 1 O fatorial de 0 é 1 O fatorial de 1 é 1 * (0!) = 1 O fatorial de 2 é 2 * (1!) = 2 O fatorial de 3 é 3 * (2!) = 6 O fatorial de 4 é 4 * (3!) = 24 A seguir crie uma classe TesteFatorial que teste a classe acima pedindo n do console: S ystem.out.println(“Digite o valor de n:”); Scanner scanner = new Scanner(System.in); int n = scanner .nextInt(); A seguir calcule o fatorial de 20, 30, 40 e 50. Comente os resultados.
  44. 44. <ul><li>Arrays </li></ul><ul><li>O que é um Array? </li></ul><ul><li>É um contêiner de variáveis que tem uma quantidade fixa de valores do mesmo tipo; </li></ul><ul><li>O tamanho de um array é estabelecido quando ela é criada. Depois da criação seu tamanho é fixo e não pode ser alterado; </li></ul><ul><li>É possível declarar arrays de tipo primitivo e de classe; </li></ul><ul><li>Todo array inicia em 0 (zero). </li></ul><ul><li>Exemplo: uma array com 10 elementos. </li></ul>
  45. 45. <ul><li>Arrays </li></ul>public class ArrayDemo { public static void main(String[] args) { int[] anArray; // declara uma array de inteiros anArray = new int[5]; // aloca memória para 5 inteiros anArray[0] = 100; // inicializa o primeiro elemento anArray[1] = 200; // inicializa o segundo elemento anArray[2] = 300; // etc. anArray[3] = 400; anArray[4] = 500; System.out.println(&quot;Elemento do índice 0: &quot; + anArray[0]); System.out.println(&quot;Elemento do índice 1: &quot; + anArray[1]); System.out.println(&quot;Elemento do índice 2: &quot; + anArray[2]); System.out.println(&quot;Elemento do índice 3: &quot; + anArray[3]); System.out.println(&quot;Elemento do índice 4: &quot; + anArray[4]); } }
  46. 46. <ul><li>Arrays </li></ul>public class ArrayDemo2 { public static void main(String[] args) { int[] anArray = {100, 200, 300, 400, 500}; for (int i = 0; i < anArray.length; i++) { System.out.println(&quot;Elemento do índice: &quot; + i + “ : ” + anArray[i]); } } } public class ArrayDemo3 { public static void main(String[] args) { int[] anArray = {100, 200, 300, 400, 500}; for (int a: anArray) { System.out.println(&quot;Elemento do array: &quot; + a); } } }
  47. 47. <ul><li>Arrays </li></ul>Declarando uma array Exemplo: int[] anArray; //declaração de uma de inteiros Outros exemplos: byte[] anArrayOfBytes; short[] anArrayOfShorts; long[] anArrayOfLongs; float[] anArrayOfFloats; double[] anArrayOfDoubles; boolean[] anArrayOfBooleans; char[] anArrayOfChars; String[] anArrayOfStrings; Object[] anArrayOfObjects;
  48. 48. <ul><li>Arrays </li></ul>Declarar, Criar, Inicializar e Acessar uma array. Declarar: int[] anArray; Criar: anArray = new int[10]; //cria uma Array Inicializar: anArray[0] = 100; //inicializa o primeiro elemento anArray[1] = 200; //inicializa o segundo elemento Acessar: System.out.println(&quot;Elemento 1 no índice 0: &quot; + anArray[0]); System.out.println(&quot;Elemento 2 no índice 1: &quot; + anArray[1]); System.out.println(&quot;Elemento 3 no índice 2: &quot; + anArray[2]); Declarar, Criar e Inicializar: int[] anArray = {100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
  49. 49. <ul><li>Arrays </li></ul>Arrays Multidimensionais String[][] names = {{&quot;Mr. &quot;, &quot;Mrs. &quot;, &quot;Ms. &quot;}, {&quot;Smith&quot;, &quot;Jones&quot;}}; System.out.println(names[0][0] + names[1][0]); //Mr. Smith System.out.println(names[0][2] + names[1][1]); //Ms. Jones int bidimensionalMatrix[][] = new int[10][10]; int tridimensionalMatrix[][][] = new int[10][10][10];
  50. 50. <ul><li>Exercícios </li></ul><ul><li>Crie uma classe Baralho que possui um atributo cartas que é um array de 52 ints, com um respectivo método accessor. </li></ul><ul><li>Crie um método preencher() que preenche o array com valores de 1 a 52. </li></ul><ul><li>Crie um método embaralhar() que embaralhe o array de ints utilizando o seguinte algoritmo: </li></ul><ul><li>Para cada posição i do array, troque o valor da posição i pelo valor da posição j, onde j é uma posição aleatória do array. </li></ul><ul><li>Repita os passos acima para todas as posições do array </li></ul><ul><li>Para efetuar o passo 1: </li></ul><ul><li>int j = new java.util.Random().nextInt(cartas.length); </li></ul><ul><li>int temp = cartas[j]; </li></ul><ul><li>cartas[j] = cartas[i]; </li></ul><ul><li>cartas[i] = temp; </li></ul><ul><li>A seguir crie uma classe TesteBaralho que teste a classe acima embaralhando e exibindo o array de cartas embaralhado. </li></ul>
  51. 51. <ul><li>Exercício para casa opcional (enviar por e-mail até antes da próxima aula). </li></ul>Dada a classe Baralho do exercício passado, crie uma classe VerificadorBaralho que testa se o embaralhamento foi eficaz e não perdeu nenhuma “carta”. Sugestão: Crie um outro array verificador de 52 ints, preenchido de 1 a 52, e percorra o array cartas, zerando a posição cartas[i] do array verificador. Ao final todas as posições do array verificador devem estar zeradas. Crie outra classe VerificadorBaralho2 utilizando a classe java.util.Arrays, método sort(), veja na API do Java o que ela faz e como utilizar.

×