Aula3

Programação Orientada a Objetos com Java Aula 3 professor: Fábio Kimura e-mail: fkimura@yahoo.com

Agenda Operadores e expressões Estruturas de Decisão Estruturas de Repetição Comentários de código Exercícios Trabalho valendo nota

Operadores e Expressões Operadores nos permitem fazer cálculos ou comparações em etapas. Expressões permitem executar tarefas computacionais compostas de funções e operadores Operadores

Operadores Aritméticos soma (+); subtração (-); multiplicação (*); divisão (/); resto da divisão (%); 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); 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). Operadores

Exemplos public static void main(String[] args) { int x = 0; System.out.println(x++); System.out.println(++x); } Operadores public static void main(String[] args) { int x = 0; int y = 2/x; } public static void main(String[] args) { double x = 0; double y = 2/x; System.out.println(y); }

Operadores Lógicos complemento (~), operador unário que reverte os valores dos bits na representação interna; OR bit-a-bit (|), operador binário que resulta em um bit 1 se pelo menos um dos bits na posição era 1; AND bit-a-bit (&), operador binário que resulta em um bit 0 se pelo menos um dos bits na posição era 0; XOR bit-a-bit (^), operador binário que resulta em um bit 1 se os bits na posição eram diferentes; Operadores

Operadores Condicionais E lógico ( && ), retorna true se as duas expressões booleanas forem verdadeiras; OU lógico ( || ), retorna true se uma das duas expressões forem verdadeiras; maior (>), retorna true se o primeiro valor for exclusivamente maior que o segundo; maior ou igual (>=), retorna true se o primeiro valor for maior que ou igual ao segundo; Operadores

Operadores Condicionais menor (<), retorna true se o primeiro valor for exclusivamente menor que o segundo; menor ou igual (<=), retorna true se o primeiro valor for menor que ou igual ao segundo; igual (==), retorna true se o primeiro valor for igual ao segundo; diferente (!=), retorna true se o primeiro valor não for igual ao segundo. Operadores

Precedência de Operadores Regras de precedência: 1. Operações entre parênteses; 2. Incremento e Decremento; 3. Multiplicação e divisão, executados da esquerda para a direita; 4. Adição e subtração, executados da esquerda para a direita; Operadores

Operadores de Atribuição Atribuição: = Atribuição composta: +=, -=, *-, /= Operadores public static void main(String[] args) { int x = 1 + 1; x += 10; x -= 2; x /= 2; x *= 3; System.out.println(“x=“ + x); }

Exemplos: Operadores public static void main(String[] args) { int x = 2; x *= 2 + 1; System.out.println(“x=“ + x); } public static void main(String[] args) { short s = 1; s++; s += 5; s = s + 5; System.out.println(“s=“ + s); }

Um problema simples – imprimir os números da Sena! public class Sena { public static void main(String args[]) { System.out.println("1,2,3,4,5,6,7,8,9,10,16..,60"); } } Será que não tem uma forma mais fácil? Estruturas de Repetição

Execução de tarefas ou funções repetidas: 1. Facilitar a codificação; 2. Permitir a computação de iterações; Estruturas: while – ( enquanto – faça ) do ... while – ( faça – enquanto) for – ( para cada – faça ) Todas são “keywords” Estruturas de Repetição

while – projetado para: testar uma condição inicial; executar um bloco de código dentro do laço; Estruturas de Repetição - while

sintaxe: while (condicao booleana) { /* bloco de código que será repetido até que a condição booleana seja false */ } Estruturas de Repetição - while

sintaxe: while (condicao booleana) // linha de código que será repetida até que a condição booleana seja false Estruturas de Repetição - while

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("Números da Sena"); int i=1; while(i <= 60) { System.out.print(i+","); i++; } System.out.println(); } } Estruturas de Repetição - while

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("Números da Sena"); int i=1; while(i <= 60) { System.out.print(i+","); i++; } System.out.println(); } } Estruturas de Repetição - while “ Execute o que estiver compreendido no bloco de código do while enquanto i seja menor ou igual a 60 ”.

do .. while – projetado para: executar um bloco de código dentro do laço; testar uma condição no fim do laço; Estruturas de Repetição - do .. while

sintaxe: do { /* bloco de código que será repetido até que a condição booleana seja false */ } while ( condicao booleana ); Estruturas de Repetição - do .. while do // linha de código que será repetida até que a condição booleana seja false while ( condicao booleana );

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("Números da Sena"); int i=1; do { System.out.print(i+","); i++; } while(i < 60); System.out.println(); } } Estruturas de Repetição - do .. while

public class Sena { public static void main(String args[]) { System.out.println("Números da Sena"); int i=1; do { System.out.print(i+","); i++; } while(i < 60); System.out.println(); } } Estruturas de Repetição - do .. while Entendendo com funciona! “ Execute o que estiver compreendido no bloco de código do while enquanto i seja menor ou igual a 60 ”.

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. Estruturas de Repetição - for

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. */ } Estruturas de Repetição - for for ( [declaração] ; [condição booleana] ; [expressão] ) // linha de código que será repetida até que a condição seja false

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("Números da Sena"); for ( int i=1; i <= 60; i++ ) { System.out.print(i+","); } System.out.println(); } } Estruturas de Repetição - for

public class Sena { public static void main(String args[]) { System.out.println("Números da Sena"); for ( int i=1; i <= 60; i++ ) { System.out.print(i+","); } 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! Estruturas de Repetição - for

Exercício Crie uma classe Numeros.java que possui 3 métodos: imprimirSequencia() : Imprime todos os números de 150 a 300. imprimirSoma() : Imprime a soma de 1 até 1000. imprimirMultiplos() : Imprime todos os múltiplos de 3, entre 1 e 100. Crie uma classe TesteNumeros.java que invoca os 3 métodos da classe acima.

Execução de testes condicionais para: Implementar a tomada de decisões; Permitir a construção de algoritmos de escolha; Estruturas: if/else – (se) switch/case – (escolha para) Todas são “keywords” Estruturas de Decisão

Estruturas de Decisão - Representação

if – projetado para comparar: expressões, variáveis e condições booleanas e decidir o fluxo da execução; Estruturas de Decisão - if

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. */ }] Estruturas de Decisão - if

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. Estruturas de Decisão - if

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. */ } Estruturas de Decisão - if

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 */ } Estruturas de Decisão

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 */ } Estruturas de Decisão

Operadores SHORT-CIRCUIT 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 Estruturas de Decisão – Operadores short-circuit

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; Estruturas de Decisão – switch

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 } Estruturas de Decisão – switch

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 } Estruturas de Decisão – switch

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. Estruturas de Decisão – switch

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. Estruturas de Decisão – switch

Exercícios 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.

Arrays O que é um Array? É um contêiner de variáveis que tem uma quantidade fixa de valores do mesmo tipo; O tamanho de um array é estabelecido quando ela é criada. Depois da criação seu tamanho é fixo e não pode ser alterado; É possível declarar arrays de tipo primitivo e de classe; Todo array inicia em 0 (zero). Exemplo: uma array com 10 elementos.

Arrays 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("Elemento do índice 0: " + anArray[0]); System.out.println("Elemento do índice 1: " + anArray[1]); System.out.println("Elemento do índice 2: " + anArray[2]); System.out.println("Elemento do índice 3: " + anArray[3]); System.out.println("Elemento do índice 4: " + anArray[4]); } }

Arrays 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("Elemento do índice: " + 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("Elemento do array: " + a); } } }

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

Arrays 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("Elemento 1 no índice 0: " + anArray[0]); System.out.println("Elemento 2 no índice 1: " + anArray[1]); System.out.println("Elemento 3 no índice 2: " + anArray[2]); Declarar, Criar e Inicializar: int[] anArray = {100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};

Arrays Arrays Multidimensionais String[][] names = {{"Mr. ", "Mrs. ", "Ms. "}, {"Smith", "Jones"}}; 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];

Exercícios Crie uma classe Baralho que possui um atributo cartas que é um array de 52 ints, com um respectivo método accessor. Crie um método preencher() que preenche o array com valores de 1 a 52. Crie um método embaralhar() que embaralhe o array de ints utilizando o seguinte algoritmo: 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. Repita os passos acima para todas as posições do array Para efetuar o passo 1: int j = new java.util.Random().nextInt(cartas.length); int temp = cartas[j]; cartas[j] = cartas[i]; cartas[i] = temp; A seguir crie uma classe TesteBaralho que teste a classe acima embaralhando e exibindo o array de cartas embaralhado.

Exercício para casa opcional (enviar por e-mail até antes da próxima aula). 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.

Aula3

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Aula3

Aula3