Expressões, controle de fluxo, wrappers e strings Profa Expressões, controle de fluxo, wrappers e strings Profa. Isabel Harb Manssour (Material adaptado das aulas dos Profs.: Luciana Nedel, Júlio Machado e Bernardo Copstein) Revisão de Conceitos Tipos básicos de dados Escopo de variáveis Operadores Comandos da linguagem Wrappers Strings Exemplos de programa Java Exercícios

Revisão de Conceitos Referência Declaração de uma variável cujo tipo é um objeto Variável capaz de apontar para instâncias daquele tipo de objeto A alocação do objeto propriamente dita só ocorre após a execução do operador new

Revisão de Conceitos Limpando os objetos Eliminar um objeto significa garantir que nenhuma referência aponta mais para o mesmo Exemplo: atribuir null para a referência O objeto aparentemente fica “perdido” na memória, porém, Java dispõem de um mecanismo de coleta de lixo (garbage colector) que garante a remoção destes objetos O sistema de coleta de lixo é ativado automaticamente toda a vez que a quantidade de memória livre fica abaixo de um determinado limite, mas é possível acioná-lo manualmente através da chamada: System.gc()

Revisão de Conceitos Atributo de Objeto X Atributo de Classe (static) Método de Objeto X Método de Classe (static) Métodos construtores Acionados automaticamente quando da criação de uma instância Em Java o método construtor é identificado pelo fato de ter o mesmo nome que a classe e não ter parâmetro de retorno Toda classe Java possui um método construtor, que se não for providenciado explicitamente, o compilador providencia um construtor implícito (Obs: os construtores implícitos são vazio, ou seja, não fazem nada)

Revisão de Conceitos Sobrecarga de métodos Métodos com nomes idênticos mas com listas de parâmetros diferentes (no tipo ou na quantidade de parâmetros) ATENÇÃO: sobrecarga de métodos só tem sentido na medida que todas as versões semanticamente fizerem a mesma coisa. É um péssimo estilo de programação que dificulta muito a leitura do programa contrariar esse princípio.

Revisão de Conceitos Constantes Modificadores de acesso Atributos final double PI = 3.1415; Modificadores de acesso private: visível apenas na classe atual public: visível para qualquer classe externa protected: em breve... Atributos Métodos

Tipos básicos de dados Nome do tipo Tamanho Variação long 8 bytes 9.223.372.036.854.775.808 int 4 bytes 2.147.483.648 short 2 bytes 32768 byte 1 byte - 128 até +127 double 8 bytes  1,79769313486231570E+308 float 4 bytes 3,40292347E+38 char 2 bytes ‘\u0000’ a ‘\uFFFF’ (conj. caracteres Unicode ISO) boolean 1 byte true ou false Obs.: em Java os tipos de dados primitivos são portáveis através de todas plataformas que suportam Java (diferente de C/C++)

Tipos básicos de dados Quando variáveis de instância dos tipos de dados primitivos são declaradas em uma classe, atribuem-se a elas automaticamente valores-padrão, a menos que especificado de maneira contrária pelo programador byte, short, int, long: 0 char: \u0000 float, double: 0.0 boolean: false Object: null

Tipos básicos de dados Na linguagem Java, as únicas coisas que não são objetos são os tipos de dados básicos (por essa razão, por vezes, Java não é considerada uma linguagem puramente orientada a objetos) Os operadores aritméticos, de atribuição, relacionais e lógicos, assim como os literais são os mesmos da linguagem C

Tipos básicos de dados Exemplos: double sunDistance = 1.496E8; long big = 329484958L; float massa = 9E-28F; float peso = 185.2F; byte numero = 7;

Escopo de Variáveis O escopo de uma variável informa onde ela pode ser utilizada Exemplo: 1: class VerificaEscopo{ 2: int escopoA; 3: public void metodo(int escopoB){ 4: int escopoC; 5: } 6: int escopoD; 7: }

Escopo de Variáveis No exemplo anterior: escopoA e escopoD são atributos da classe “VerificaEscopo” e seu escopo vale a partir da linha 1 escopoB e escopoC são variáveis cujo escopo é válido somente dentro do método Variáveis locais podem ser declaradas a qualquer momento dentro de um método; exemplo: for (int i=1; i<5; i++){ int j = 0; //i e j só valem dentro do for } System.out.println(i);//erro

Escopo de Variáveis Variáveis locais declaradas dentro de método, obrigatoriamente, devem ser inicializadas O compilador Java irá indicar um erro se não inicializarmos as variáveis. Exemplo: class Aluguel { private int numero; public void adicItem(){ float itemCusto; int numDias; System.out.println("Numero="+numero);//OK System.out.println("ItemCusto="+itemCusto); //Erro }

Operadores Operadores (já visto) Precedência de operadores aritméticos: +, -, *, /, % (resto da divisão) relacionais: >, >=, <, <= igualdade: ==, != lógicos: &&, & (and), ||, | (or), ^ (xor), ! (not) atribuição: =, +=, -=, *=, /=, %= incremento, decremento: ++, -- Precedência de operadores Ver “Aprenda em 21 Dias Java 2”, pág. 83 Com && e || a expressão é avaliadas somente até que verdade ou falsidade seja detectada (avaliação em curto circuito - recurso de desempenho para a avaliação) Os operadores AND lógico booleano (&) e OR lógico booleano inclusivo (I), trabalham identicamente aos operadores lógicos regulares AND e OR lógicos com uma exceção - os operadores lógicos booleanos sempre avaliam seus dois operados (não há avaliação em curto-circuito) Exemplo de utilidade: (birthday==true | ++age>=65) “|” garante que a condição “++age>=65” será avaliada, de tal maneira que a variável age será incrementada na expressão independentemente da expressão ser T ou F

Operadores Precedência de Operadores (livro texto pg. 287) ( ) [ ] ++ -- + - ! (unário) * / % + - > >= < <= == != & ^ (xor) | && || ?: = += -= *= /= %= Precedência de operadores Ver “Aprenda em 21 Dias Java 2”, pág. 83 Com && e || a expressão é avaliadas somente até que verdade ou falsidade seja detectada (avaliação em curto circuito - recurso de desempenho para a avaliação) Os operadores AND lógico booleano (&) e OR lógico booleano inclusivo (I), trabalham identicamente aos operadores lógicos regulares AND e OR lógicos com uma exceção - os operadores lógicos booleanos sempre avaliam seus dois operados (não há avaliação em curto-circuito) Exemplo de utilidade: (birthday==true | ++age>=65) “|” garante que a condição “++age>=65” será avaliada, de tal maneira que a variável age será incrementada na expressão independentemente da expressão ser T ou F

Operadores Incremento e decremento: int count = 10; ++count; // count = count + 1; count++; --count; // count = count - 1; count--;

Operadores Operadores binários: AND OR XOR COMPLEMENTO 4 & 6 = 4 = 0100 & 0110 = 0100 OR 4 | 6 = 6 = 0100 | 0110 = 0110 XOR Resultado é verdadeiro se e somente se um de seus operandos resulta em um valor true e um resulta em um valor false 4 ^ 6 = 2 = 0100 ^ 0110 = 0010 COMPLEMENTO ~4 = 11 = ~0100 = 1011

Operadores Operadores aritméticos: c += 5; c = c + 5; c = a * b; c = a / b; c = a % b; // resto da divisão

Operadores Funções matemáticas (classe Math) Alguns métodos Exemplo: sqrt(x): cálculo da raiz quadrada de x (x é do tipo double) abs(x): valor absoluto de x (x pode ser float, int, long) ceil(x): arredonda x para o menor inteiro não menor que x (ceil(9.2)=10.0, ceil(-9.8)=-9.0) cos(x): coseno trigonométrico de x (x em radianos) exp(x): método exponencial ex pow(x,y): x elevado a potência y (xy) random(): gera valor double v (0.0 <= v < 1.0) Exemplo: double raio; raio = Math.sqrt(area/Math.PI);

Operadores Observação: Não é necessário importar a classe Math em um programa para utilizar os seus métodos, pois esta classe é parte do pacote java.lang que automaticamente é importado pelo compilador Outras classes do pacote java.lang String System

Comandos da linguagem Operador condicional: if (expressão) {expressão} else {expressão} Exemplo: if (i % 2 == 0) System.out.println(“Par”); else System.out.println(“Ímpar”); Operador condicional: expressão_lógica ? expressão1 : expressão 2 Exemplo: c = a>b ? a : b;

Comandos da linguagem switch (expressão) { case valor1: expressão1; break; case valor2: expressão2; default: expressão; } Utilizado para cobrir múltiplas escolhas sobre valores alternativos de variáveis int, byte, short, long ou char.

Comandos da linguagem Exemplos: switch (menuItem){ case 0: System.out.println(“zero”); break; case 1: System.out.println(“um”); break; default: System.out.println(“inválido”); } switch (nota){ case ‘A’: case ‘B’: case ‘C’: System.out.println(“Passou”); break; default: System.out.println(“Rodou”);

Comandos da linguagem for (i=0; i < 8; i++) { // código } Exemplo: int soma = 0; for (int i=1; i<=3; i++) soma +=i; System.out.println(“Soma “+soma);

Comandos da linguagem while (expressão) { // código } Exemplo: int i = 0; while (i<10) { System.out.println(“i= “ + i); i++;

Comandos da linguagem do { // código } while (expressão); Exemplo: int i = 0; do { System.out.println(“i= “ + i); i++; } while (i<10);

Comandos da linguagem continue e break continue: abandona a iteração atual do laço e passa para a próxima iteração break: transfere o controle para o primeiro comando após o laço (forçando o seu término imediato) ou switch Exemplo: soma = 0; soma = 0; for (i=0; i < 5; i++) for (i=0; i < 5; i++) { { if (i == 3) continue; if (i == 3) break; soma += i; soma += i; } } soma(break)= 3 soma(continue)= 7

Wrappers Como em Java apenas objetos podem ser passados por referência para subrotinas, a linguagem oferece os chamados wrappers ou objetos empacotadores dos tipos básicos Além da vantagem de serem passados por referência, os wrappers possuem diversos métodos úteis Sempre que possível deve-se dar preferência ao uso dos wrappers ao invés dos tipos básicos diretamente

Wrappers Para cada um dos tipos de dados básicos existe um tipo “empacotador” correspondente. São eles: Tipo primitivo Classe correspondente boolean Boolean char Character int Integer long Long float Float double Double

Wrappers Os tipos byte e short não possuem classe correspondente porque o valor armazenado em objetos da classe Integer poderão ser convertidos para esses tipos

Wrappers Exemplo: Integer n1 = new Integer(10); Integer n2 = new Integer(20); if (n1.equals(n2) == true) System.out.println(“Valores iguais!”); else System.out.println(“Valores diferentes!”); Obs: o método equals deve ser usado no lugar do operador “== ” porque o teste “if (n1 == n2) ... ” vai comparar as referências e não os valores. No caso, as referências nunca serão iguais.

Wrappers Alguns métodos da classe Integer: int compareTo(Integer anotherInteger)//retorna 0 se = static Integer decode(String nm)//string->Integer boolean equals(Object obj) double doubleValue()//retorna valor de Integer como double float floatValue() int intValue() long longValue() short shortValue() String toString()//retorna objeto String que representa o //valor do objeto Integer static String toString(int i)//retorna objeto String que //representa int especificado Consulte a documentação do JDK sobre os métodos das classes wrapper

Wrappers Exemplos de métodos de conversão de strings: Um método parse para cada tipo de dado. String texto = "12345"; int inteiro = Integer.parseInt(texto); byte - Byte.parseByte(aString) short - Short.parseShort(aString) int - Integer.parseInt(aString) long - Long.parseLong(aString) float - Float.parseFloat(aString) double - Double.parseDouble(aString) boolean - Boolean.valueOf(aString).booleanValue();

Strings Grupo de caracteres tratados como uma unidade Podem incluir letras, dígitos e caracteres especiais (+,- *...) Strings são objetos da classe String Sequência de caracteres entre aspas "João da Silva" ou "111222333"

Strings Podem ser atribuídos na declaração String color = "blue"; color é a referência a um String "blue" é um objeto do tipo String anônimo String color=new String("blue sky");

Strings Construtores da classe String s1 = new String() s1 é um string vazio s2 = new String(anotherString) s2 é uma cópia de anotherString s3 = new String(charArray) s3 contém todos os caracteres do array charArray s4 = new String(charArray, offset, numElements) s4 contém numElements caracteres do array charArray, começando na localização offset etc.

Strings Quando utilizamos um literal string (Ex: “Ola”) em Java, a JVM automaticamente cria uma instância da classe String que armazena o literal utilizado. Isso é fácil de verificar na medida em que podemos acionar os métodos da classe String a partir de um literal. Exemplo: int x; x = “Ola”.length(); // método length()-retorna tamanho System.out.println(“Tamanho do string \”Ola”:“,x);

Strings Pode-se também criar explicitamente referências e instâncias da classe String O operador “+” no caso de strings é um operador de concatenação String texto1 = "Início "; String texto2 = "Fim "; String tudo = texto1 + texto2; System.out.println(tudo);

Strings Comparando strings String string1 = “texto”; string1 == string2 // compara endereço ou string1.equals(string2); // compara conteúdo

Strings Alguns métodos da classe String: char charAt(int index)//retorna o caracter do índice especificado int compareTo(String anotherString)//retorna zero se forem iguais String concat(String str)//concatena str no final do string static String copyValueOf(char[] data)//retorna objeto String que //representa a seqüência de caracteres boolean endsWith(String suffix)//testa se termina c/suffix boolean equals(Object anObject) boolean equalsIgnoreCase(String anotherString) int indexOf(int ch)//retorna índice 1a ocorrência de ch int lastIndexOf(int ch)//retorna índice última ocorrência de ch int length() String replace(char oldChar, char newChar)//troca todas //ocorrências de oldChar por newChar

Strings boolean startsWith(String prefix)//testa se começa por prefix String substring(int beginIndex) String substring(int beginIndex, int endIndex) char[] toCharArray()//converte String para array de caracteres String toLowerCase() String toUpperCase() static String valueOf(boolean b)//retorna representação String //do argumento static String valueOf(char c) static String valueOf(char[] data) static String valueOf(char[] data, int offset, int count) static String valueOf(double d) static String valueOf(float f) static String valueOf(int i) static String valueOf(long l)

Strings Exemplos: String s1 = “As uvas estão verdes”; String s2 = “Mad dog”; String s3 = “Mad cat”; s1.startsWith(“As”)  true s1.startsWith(“As uvas”)  true s1.startsWith(“uvas”,3)  true s2.compareTo(s3)  > 0 s3.compareTo(s2)  < 0 s2 = s2.toLowerCase()  “mad dog” char c = ‘a’

Strings Character.isLetter(c)  true Character.isWhitespace(c) false int i = 0; i = s1.indexOf(‘e’);  8 i = s1.lastIndexOf(‘e’);  18 i = s1.indexOf(‘e’,10);  15 i = s1.indexOf(“uvas”);  3 c = s1.charAt(1);  ‘s’ c = Character.toLowerCase(s1.charAt(0))  ‘a’ String s4 = “hamburger”.substring(4);  “urger” String s5 = “hamburger”.substring(4,8);  “urge” String s6 = (new Integer(2)).toString();  “2” String s7 = Integer.toString(2);  “2”

Exemplos de programa Java (dialog box) 1 // Fig. 2.6: Welcome4.java 2 // Printing multiple lines in a dialog box Java program using dialog box Program Output 3 import javax.swing.JOptionPane; // import class JOptionPane 4 5 public class Welcome4 { 6 public static void main( String args[] ) 7 { Saída 8 JOptionPane.showMessageDialog( 9 null, "Welcome\nto\nJava\nProgramming!" ); 10 11 System.exit( 0 ); // terminate the program 12 } 13 }

Exemplos de programa Java (dialog box) 8 JOptionPane.showMessageDialog( Chama método showMessageDialog da classe JOptionPane Requer dois argumentos Por enquanto, o primeiro argumento será sempre null O segundo argumento é o string a apresentar showMessageDialog é um método static da classe JOptionPane métodos static são chamados usando o nome da classe, ponto (.) e o nome do método. 9 null, "Welcome\nto\nJava\nProgramming!" );

Exemplos de programa Java (dialog box) Chama método estático exit da classe System Termina a aplicação Como o método é estático, é necessário o uso do nome da classe e do ponto (.) Identificadores começando com maiúsculas usualmente referem-se a nomes de classes (convenção) O argumento 0 (zero) indica que a aplicação foi terminada corretamente Não-zero indica que um erro aconteceu A classe System é parte do pacote java.lang Não é necessário fazer import desta classe java.lang é automaticamente importada 11 System.exit( 0 ); // terminate the program

Exemplos de programa Java (uso de wrappers) Próximo programa: soma dois valores Usa input dialogs para entrada de 2 valores pelo usuário Usa message dialog para exibir resultado da soma dos 2 valores fornecidos Demonstra uso de wrappers e entrada de dados

1 // Fig. 2.8: Addition.java 2 // An addition program 3 4 import javax.swing.JOptionPane; // import class JOptionPane 5 6 public class Addition { 7 public static void main( String args[] ) 8 { 9 String firstNumber, // first string entered by user 10 secondNumber; // second string entered by user 11 int number1, // first number to add 12 number2, // second number to add 13 sum; // sum of number1 and number2 14 15 // read in first number from user as a string 16 firstNumber = 17 JOptionPane.showInputDialog( "Enter first integer" ); 18 19 // read in second number from user as a string 20 secondNumber = 21 JOptionPane.showInputDialog( "Enter second integer" ); 22 23 // convert numbers from type String to type int 24 number1 = Integer.parseInt( firstNumber ); 25 number2 = Integer.parseInt( secondNumber ); 26 27 // add the numbers 28 sum = number1 + number2; 29 30 // display the results

Entra primeiro inteiro como um String e armazena em firstNumber. 1 // Fig. 2.8: Addition.java 2 // An addition program 3 4 import javax.swing.JOptionPane; // import class JOptionPane 5 Declara variáveis 6 public class Addition { 7 public static void main( String args[] ) 8 { 9 String firstNumber, // first string entered by user 10 secondNumber; // second string entered by user 11 int number1, // first number to add 12 number2, // second number to add 13 sum; // sum of number1 and number2 Entra primeiro inteiro como um String e armazena em firstNumber. 14 15 // read in first number from user as a string 16 firstNumber = 17 JOptionPane.showInputDialog( "Enter first integer" ); 18 19 // read in second number from user as a string 20 secondNumber = 21 JOptionPane.showInputDialog( "Enter second integer" ); Converte string para inteiro 22 23 // convert numbers from type String to type int 24 number1 = Integer.parseInt( firstNumber ); 25 number2 = Integer.parseInt( secondNumber ); Adiciona e coloca resultado em sum. 26 27 // add the numbers 28 sum = number1 + number2; 29 30 // display the results

Exemplos de programa Java (uso de wrappers) 31 JOptionPane.showMessageDialog( 32 null, "The sum is " + sum, "Results", 33 JOptionPane.PLAIN_MESSAGE ); 34 35 System.exit( 0 ); // terminate the program 36 } 37 } Saída

Exemplos de programa Java (uso de wrappers) 9 String firstNumber, // first string entered by user Variáveis firstNumber e secondNumber são variáveis do tipo String (package java.lang) strings encapsuladas (wrapper) 10 secondNumber; // second string entered by user

Exemplos de programa Java (uso de wrappers) 15 // read in first number from user as a string 16 firstNumber = 17 JOptionPane.showInputDialog( "Enter first integer" ); Lê String do usuário, representando o primeiro número a ser adicionado Método JOptionPane.showInputDialog apresenta: Note que o argumento da função aparece como texto.

Exemplos de programa Java (uso de wrappers) 23 // convert numbers from type String to type int 24 number1 = Integer.parseInt( firstNumber ); 25 number2 = Integer.parseInt( secondNumber ); Método Integer.parseInt Converte um argumento String em um inteiro (tipo int) Classe Integer em java.lang O inteiro retornado por Integer.parseInt é atribuído a variável number1 (line 24) Lembre que number1 foi declarada como sendo do tipo int 27 // add the numbers 28 sum = number1 + number2;

Exemplos de programa Java (uso de wrappers) 31 JOptionPane.showMessageDialog( 32 null, "The sum is " + sum, "Results", 33 JOptionPane.PLAIN_MESSAGE ); Usa showMessageDialog para mostrar os resultados "The sum is " + soma Usa o operador + para concatenar a string "The sum is" e a variável sum Concatenação de String com outros tipos de dados Resultado gera um novo string

Exemplos de programa Java (uso de wrappers) 31 JOptionPane.showMessageDialog( 32 null, "The sum is " + sum, "Results", 33 JOptionPane.PLAIN_MESSAGE ); Outras versões de showMessageDialog Requerem 4 argumentos Primeiro argumento continua null por enquanto… Segundo: string a apresentar Terceiro: string para a barra de título Quarto: tipo de mensagem no diálogo JOptionPane.PLAIN_MESSAGE - sem ícone JOptionPane.ERROR_MESSAGE JOptionPane.INFORMATION_MESSAGE JOptionPane.WARNING_MESSAGE JOptionPane.QUESTION_MESSAGE

Exemplos de programa Java (uso de strings) O programa a seguir demonstra os seguintes métodos da classe String: length charAt getChars

Exemplo de uso de strings 1 // Fig. 10.2: StringMisc.java 2 // This program demonstrates the length, charAt and getChars 3 // methods of the String class. 4 // 5 // Note: Method getChars requires a starting point 6 // and ending point in the String. The starting point is the 7 // actual subscript from which copying starts. The ending point 8 // is one past the subscript at which the copying ends. 9 import javax.swing.*; 10 11 public class StringMisc { 12 public static void main( String args[] ) 13 { 14 String s1, output; 15 char charArray[]; 16 17 s1 = new String( "hello there" ); 18 charArray = new char[ 5 ]; 19 20 // output the string 21 output = "s1: " + s1; 22 23 // test the length method 24 output += "\nLength of s1: " + s1.length(); 25 26 // loop through the characters in s1 and display reversed 27 output += "\nThe string reversed is: "; 28 29 for ( int i = s1.length() - 1; i >= 0; i-- ) 30 output += s1.charAt( i ) + " "; Retorna o tamanho do String. Método charAt(posição)

Saída Copia caracteres para charArray 33 // copy characters from string into char array Copia caracteres para charArray public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 34 s1.getChars( 0, 5, charArray, 0 ); 35 output += "\nThe character array is: "; 36 37 for ( int i = 0; i < charArray.length; i++ ) 38 output += charArray[ i ]; 39 40 JOptionPane.showMessageDialog( null, output, 41 "Demonstrating String Class Constructors", 42 JOptionPane.INFORMATION_MESSAGE ); 43 44 System.exit( 0 ); 45 } 46 } Saída

Exercícios 1) Escreva um programa em Java que calcule o número de vogais, consoantes e espaços em branco de um string digitado pelo usuário e imprima o resultado (use dialog boxes).

Exercícios 2) Dada a seguinte classe, que define um objeto Esfera, resolva as próximas questões. class Esfera{ private float x, y, z; //centro private float raio; //raio public Esfera(float x1, float y1, float z1, float r1) {//construtor x = x1; y = y1; z = z1; raio = r1; }

Exercícios 2a) Através da sobrecarga, defina dois novos construtores, um que recebe o raio como parâmetro e cria uma esfera de centro (0,0,0) e outro sem parâmetros que cria uma esfera de raio 1 e centro (0,0,0). 2b) Altere a classe (seus atributos e métodos) para que seja possível guardar o número de esferas criadas e mostrá-lo ao usuário. 2c) Implemente um método para visualizar os atributos de uma esfera e escreva um programa em Java para testar a classe Esfera, utilizando dois objetos Esfera diferentes.

Respostas dos exercícios 1) import javax.swing.JOptionPane; public class DialogString { public static void main() String texto, msg; int espacos = 0, vogais = 0, letras = 0; texto = JOptionPane.showInputDialog("Digite um string:"); for (int i = 0; i < texto.length(); i++){ char c = Character.toLowerCase(texto.charAt(i)); if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') ++ vogais; if (Character.isLetter(c)) ++letras; if (Character.isWhitespace(c)) ++espacos; } msg = "O texto contem " + vogais + " vogais \n" + (letras - vogais) + " consoantes e " + espacos + " espacos."; JOptionPane.showMessageDialog(null, msg, "Resultado", JOptionPane.INFORMATION_MESSAGE); System.exit( 0 );